Examples with Animation com.jme3.animation.Animation used on opensource projects

Example 16 with Animation

use of com.jme3.animation.Animation in project jmonkeyengine by jMonkeyEngine.

the class KinematicRagdollControl method blendToKinematicMode.

/**
     * Smoothly blend from Ragdoll mode to Kinematic mode This is useful to
     * blend ragdoll actual position to a keyframe animation for example
     *
     * @param blendTime the blending time between ragdoll to anim.
     */
public void blendToKinematicMode(float blendTime) {
    if (mode == Mode.Kinematic) {
        return;
    }
    blendedControl = true;
    this.blendTime = blendTime;
    mode = Mode.Kinematic;
    AnimControl animControl = targetModel.getControl(AnimControl.class);
    animControl.setEnabled(true);
    TempVars vars = TempVars.get();
    for (PhysicsBoneLink link : boneLinks.values()) {
        Vector3f p = link.rigidBody.getMotionState().getWorldLocation();
        Vector3f position = vars.vect1;
        targetModel.getWorldTransform().transformInverseVector(p, position);
        Quaternion q = link.rigidBody.getMotionState().getWorldRotationQuat();
        Quaternion q2 = vars.quat1;
        Quaternion q3 = vars.quat2;
        q2.set(q).multLocal(link.initalWorldRotation).normalizeLocal();
        q3.set(targetModel.getWorldRotation()).inverseLocal().mult(q2, q2);
        q2.normalizeLocal();
        link.startBlendingPos.set(position);
        link.startBlendingRot.set(q2);
        link.rigidBody.setKinematic(true);
    }
    vars.release();
    for (Bone bone : skeleton.getRoots()) {
        RagdollUtils.setUserControl(bone, false);
    }
    blendStart = 0;
}

Example 17 with Animation

use of com.jme3.animation.Animation in project jmonkeyengine by jMonkeyEngine.

the class TemporalMesh method prepareFacesGeometry.

/**
     * The method creates geometries from faces.
     * @param result
     *            the list where new geometries will be appended
     * @param meshHelper
     *            the mesh helper
     */
protected void prepareFacesGeometry(List<Geometry> result, MeshHelper meshHelper) {
    LOGGER.fine("Preparing faces geometries.");
    this.triangulate();
    Vector3f[] tempVerts = new Vector3f[3];
    Vector3f[] tempNormals = new Vector3f[3];
    byte[][] tempVertColors = new byte[3][];
    List<Map<Float, Integer>> boneBuffers = new ArrayList<Map<Float, Integer>>(3);
    LOGGER.log(Level.FINE, "Appending {0} faces to mesh buffers.", faces.size());
    Map<Integer, MeshBuffers> faceMeshes = new HashMap<Integer, MeshBuffers>();
    for (Face face : faces) {
        MeshBuffers meshBuffers = faceMeshes.get(face.getMaterialNumber());
        if (meshBuffers == null) {
            meshBuffers = new MeshBuffers(face.getMaterialNumber());
            faceMeshes.put(face.getMaterialNumber(), meshBuffers);
        }
        List<List<Integer>> triangulatedIndexes = face.getCurrentIndexes();
        List<byte[]> vertexColors = face.getVertexColors();
        for (List<Integer> indexes : triangulatedIndexes) {
            assert indexes.size() == 3 : "The mesh has not been properly triangulated!";
            Vector3f normal = null;
            if (!face.isSmooth()) {
                normal = FastMath.computeNormal(vertices.get(indexes.get(0)), vertices.get(indexes.get(1)), vertices.get(indexes.get(2)));
            }
            boneBuffers.clear();
            for (int i = 0; i < 3; ++i) {
                int vertIndex = indexes.get(i);
                tempVerts[i] = vertices.get(vertIndex);
                tempNormals[i] = normal != null ? normal : normals.get(vertIndex);
                tempVertColors[i] = vertexColors != null ? vertexColors.get(face.getIndexes().indexOf(vertIndex)) : null;
                if (boneIndexes.size() > 0 && vertexGroups.size() > 0) {
                    Map<Float, Integer> boneBuffersForVertex = new HashMap<Float, Integer>();
                    Map<String, Float> vertexGroupsForVertex = vertexGroups.get(vertIndex);
                    for (Entry<String, Integer> entry : boneIndexes.entrySet()) {
                        if (vertexGroupsForVertex.containsKey(entry.getKey())) {
                            float weight = vertexGroupsForVertex.get(entry.getKey());
                            if (weight > MINIMUM_BONE_WEIGHT) {
                                // only values of weight greater than MINIMUM_BONE_WEIGHT are used
                                // if all non zero weights were used, and they were samm enough, problems with normalisation would occur
                                // because adding a very small value to 1.0 will give 1.0
                                // so in order to avoid such errors, which can cause severe animation artifacts we need to use some minimum weight value
                                boneBuffersForVertex.put(weight, entry.getValue());
                            }
                        }
                    }
                    if (boneBuffersForVertex.size() == 0) {
                        // attach the vertex to zero-indexed bone so that it does not collapse to (0, 0, 0)
                        boneBuffersForVertex.put(1.0f, 0);
                    }
                    boneBuffers.add(boneBuffersForVertex);
                }
            }
            Map<String, List<Vector2f>> uvs = meshHelper.selectUVSubset(face, indexes.toArray(new Integer[indexes.size()]));
            meshBuffers.append(face.isSmooth(), tempVerts, tempNormals, uvs, tempVertColors, boneBuffers);
        }
    }
    LOGGER.fine("Converting mesh buffers to geometries.");
    Map<Geometry, MeshBuffers> geometryToBuffersMap = new HashMap<Geometry, MeshBuffers>();
    for (Entry<Integer, MeshBuffers> entry : faceMeshes.entrySet()) {
        MeshBuffers meshBuffers = entry.getValue();
        Mesh mesh = new Mesh();
        if (meshBuffers.isShortIndexBuffer()) {
            mesh.setBuffer(Type.Index, 1, (ShortBuffer) meshBuffers.getIndexBuffer());
        } else {
            mesh.setBuffer(Type.Index, 1, (IntBuffer) meshBuffers.getIndexBuffer());
        }
        mesh.setBuffer(meshBuffers.getPositionsBuffer());
        mesh.setBuffer(meshBuffers.getNormalsBuffer());
        if (meshBuffers.areVertexColorsUsed()) {
            mesh.setBuffer(Type.Color, 4, meshBuffers.getVertexColorsBuffer());
            mesh.getBuffer(Type.Color).setNormalized(true);
        }
        BoneBuffersData boneBuffersData = meshBuffers.getBoneBuffers();
        if (boneBuffersData != null) {
            mesh.setMaxNumWeights(boneBuffersData.maximumWeightsPerVertex);
            mesh.setBuffer(boneBuffersData.verticesWeights);
            mesh.setBuffer(boneBuffersData.verticesWeightsIndices);
            LOGGER.fine("Generating bind pose and normal buffers.");
            mesh.generateBindPose(true);
            // change the usage type of vertex and normal buffers from Static to Stream
            mesh.getBuffer(Type.Position).setUsage(Usage.Stream);
            mesh.getBuffer(Type.Normal).setUsage(Usage.Stream);
            // creating empty buffers for HW skinning; the buffers will be setup if ever used
            VertexBuffer verticesWeightsHW = new VertexBuffer(Type.HWBoneWeight);
            VertexBuffer verticesWeightsIndicesHW = new VertexBuffer(Type.HWBoneIndex);
            mesh.setBuffer(verticesWeightsHW);
            mesh.setBuffer(verticesWeightsIndicesHW);
        }
        Geometry geometry = new Geometry(name + (result.size() + 1), mesh);
        if (properties != null && properties.getValue() != null) {
            meshHelper.applyProperties(geometry, properties);
        }
        result.add(geometry);
        geometryToBuffersMap.put(geometry, meshBuffers);
    }
    LOGGER.fine("Applying materials to geometries.");
    for (Entry<Geometry, MeshBuffers> entry : geometryToBuffersMap.entrySet()) {
        int materialIndex = entry.getValue().getMaterialIndex();
        Geometry geometry = entry.getKey();
        if (materialIndex >= 0 && materials != null && materials.length > materialIndex && materials[materialIndex] != null) {
            materials[materialIndex].applyMaterial(geometry, meshStructure.getOldMemoryAddress(), entry.getValue().getUvCoords(), blenderContext);
        } else {
            Material defaultMaterial = blenderContext.getDefaultMaterial().clone();
            defaultMaterial.getAdditionalRenderState().setFaceCullMode(FaceCullMode.Off);
            geometry.setMaterial(defaultMaterial);
        }
    }
}

Example 18 with Animation

use of com.jme3.animation.Animation in project jmonkeyengine by jMonkeyEngine.

the class CinematicTest method clearAnimationEvent.

/**
     * No ClassCastException when clear() a Cinematic with AnimationEvent
     */
@Test
public void clearAnimationEvent() {
    Cinematic sut = new Cinematic();
    Node model = new Node("model");
    AnimControl ac = new AnimControl();
    ac.addAnim(new Animation("animName", 1.0f));
    model.addControl(ac);
    sut.enqueueCinematicEvent(new AnimationEvent(model, "animName"));
    sut.initialize(null, null);
    sut.clear();
}

Example 19 with Animation

use of com.jme3.animation.Animation in project jmonkeyengine by jMonkeyEngine.

the class BlenderKey method write.

@Override
public void write(JmeExporter e) throws IOException {
    super.write(e);
    OutputCapsule oc = e.getCapsule(this);
    oc.write(fps, "fps", DEFAULT_FPS);
    oc.write(featuresToLoad, "features-to-load", FeaturesToLoad.ALL);
    oc.write(loadUnlinkedAssets, "load-unlinked-assets", false);
    oc.write(assetRootPath, "asset-root-path", null);
    oc.write(fixUpAxis, "fix-up-axis", true);
    oc.write(generatedTexturePPU, "generated-texture-ppu", 128);
    oc.write(usedWorld, "used-world", null);
    oc.write(defaultMaterial, "default-material", null);
    oc.write(faceCullMode, "face-cull-mode", FaceCullMode.Off);
    oc.write(layersToLoad, "layers-to-load", -1);
    oc.write(mipmapGenerationMethod, "mipmap-generation-method", MipmapGenerationMethod.GENERATE_WHEN_NEEDED);
    oc.write(skyGeneratedTextureSize, "sky-generated-texture-size", 1000);
    oc.write(skyGeneratedTextureRadius, "sky-generated-texture-radius", 1f);
    oc.write(skyGeneratedTextureShape, "sky-generated-texture-shape", SkyGeneratedTextureShape.SPHERE);
    oc.write(optimiseTextures, "optimise-textures", false);
    oc.write(animationMatchMethod, "animation-match-method", AnimationMatchMethod.AT_LEAST_ONE_NAME_MATCH);
    oc.write(pointsSize, "points-size", 1);
    oc.write(linesWidth, "lines-width", 1);
}

Example 20 with Animation

use of com.jme3.animation.Animation in project jmonkeyengine by jMonkeyEngine.

the class BlenderContext method getLinkedFeature.

/**
     * The method returns linked feature of a given name from the specified blender path.
     * @param blenderFilePath
     *            the blender file path
     * @param featureName
     *            the feature name we want to get
     * @return linked feature or null if none was found
     */
@SuppressWarnings("unchecked")
public Object getLinkedFeature(String blenderFilePath, String featureName) {
    Map<String, Object> linkedFeatures = this.linkedFeatures.get(blenderFilePath);
    if (linkedFeatures != null) {
        String namePrefix = (featureName.charAt(0) + "" + featureName.charAt(1)).toUpperCase();
        featureName = featureName.substring(2);
        if ("SC".equals(namePrefix)) {
            List<Node> scenes = (List<Node>) linkedFeatures.get("scenes");
            if (scenes != null) {
                for (Node scene : scenes) {
                    if (featureName.equals(scene.getName())) {
                        return scene;
                    }
                }
            }
        } else if ("OB".equals(namePrefix)) {
            List<Node> features = (List<Node>) linkedFeatures.get("objects");
            if (features != null) {
                for (Node feature : features) {
                    if (featureName.equals(feature.getName())) {
                        return feature;
                    }
                }
            }
        } else if ("ME".equals(namePrefix)) {
            List<TemporalMesh> temporalMeshes = (List<TemporalMesh>) linkedFeatures.get("meshes");
            if (temporalMeshes != null) {
                for (TemporalMesh temporalMesh : temporalMeshes) {
                    if (featureName.equals(temporalMesh.getName())) {
                        return temporalMesh;
                    }
                }
            }
        } else if ("MA".equals(namePrefix)) {
            List<MaterialContext> features = (List<MaterialContext>) linkedFeatures.get("materials");
            if (features != null) {
                for (MaterialContext feature : features) {
                    if (featureName.equals(feature.getName())) {
                        return feature;
                    }
                }
            }
        } else if ("TX".equals(namePrefix)) {
            List<Texture> features = (List<Texture>) linkedFeatures.get("textures");
            if (features != null) {
                for (Texture feature : features) {
                    if (featureName.equals(feature.getName())) {
                        return feature;
                    }
                }
            }
        } else if ("IM".equals(namePrefix)) {
            List<Texture> features = (List<Texture>) linkedFeatures.get("images");
            if (features != null) {
                for (Texture feature : features) {
                    if (featureName.equals(feature.getName())) {
                        return feature;
                    }
                }
            }
        } else if ("AC".equals(namePrefix)) {
            List<Animation> features = (List<Animation>) linkedFeatures.get("animations");
            if (features != null) {
                for (Animation feature : features) {
                    if (featureName.equals(feature.getName())) {
                        return feature;
                    }
                }
            }
        } else if ("CA".equals(namePrefix)) {
            List<Camera> features = (List<Camera>) linkedFeatures.get("cameras");
            if (features != null) {
                for (Camera feature : features) {
                    if (featureName.equals(feature.getName())) {
                        return feature;
                    }
                }
            }
        } else if ("LA".equals(namePrefix)) {
            List<Light> features = (List<Light>) linkedFeatures.get("lights");
            if (features != null) {
                for (Light feature : features) {
                    if (featureName.equals(feature.getName())) {
                        return feature;
                    }
                }
            }
        } else if ("FI".equals(featureName)) {
            List<Filter> features = (List<Filter>) linkedFeatures.get("lights");
            if (features != null) {
                for (Filter feature : features) {
                    if (featureName.equals(feature.getName())) {
                        return feature;
                    }
                }
            }
        }
    }
    return null;
}