Examples with Curve com.jme3.scene.shape.Curve used on opensource projects

Example 6 with Curve

use of com.jme3.scene.shape.Curve in project jmonkeyengine by jMonkeyEngine.

the class Curve method createNurbMesh.

/**
     * This method creates the Nurb path for this curve.
     *
     * @param nbSubSegments amount of subsegments between position control
     * points
     */
private void createNurbMesh(int nbSubSegments) {
    if (spline.getControlPoints() != null && spline.getControlPoints().size() > 0) {
        if (nbSubSegments == 0) {
            nbSubSegments = spline.getControlPoints().size() + 1;
        } else {
            nbSubSegments = spline.getControlPoints().size() * nbSubSegments + 1;
        }
        float minKnot = spline.getMinNurbKnot();
        float maxKnot = spline.getMaxNurbKnot();
        float deltaU = (maxKnot - minKnot) / nbSubSegments;
        float[] array = new float[(nbSubSegments + 1) * 3];
        float u = minKnot;
        Vector3f interpolationResult = new Vector3f();
        for (int i = 0; i < array.length; i += 3) {
            spline.interpolate(u, 0, interpolationResult);
            array[i] = interpolationResult.x;
            array[i + 1] = interpolationResult.y;
            array[i + 2] = interpolationResult.z;
            u += deltaU;
        }
        //calculating indexes
        int i = 0;
        short[] indices = new short[nbSubSegments << 1];
        for (int j = 0; j < nbSubSegments; ++j) {
            indices[i++] = (short) j;
            indices[i++] = (short) (j + 1);
        }
        this.setMode(Mesh.Mode.Lines);
        this.setBuffer(VertexBuffer.Type.Position, 3, array);
        this.setBuffer(VertexBuffer.Type.Index, 2, indices);
        this.updateBound();
        this.updateCounts();
    }
}

Example 7 with Curve

use of com.jme3.scene.shape.Curve in project jmonkeyengine by jMonkeyEngine.

the class AnimationHelper method getCurveType.

/**
     * This method returns the type of the ipo curve.
     * 
     * @param structure
     *            the structure must contain the 'rna_path' field and
     *            'array_index' field (the type is not important here)
     * @param blenderContext
     *            the blender context
     * @return the type of the curve
     */
public int getCurveType(Structure structure, BlenderContext blenderContext) {
    // reading rna path first
    BlenderInputStream bis = blenderContext.getInputStream();
    int currentPosition = bis.getPosition();
    Pointer pRnaPath = (Pointer) structure.getFieldValue("rna_path");
    FileBlockHeader dataFileBlock = blenderContext.getFileBlock(pRnaPath.getOldMemoryAddress());
    bis.setPosition(dataFileBlock.getBlockPosition());
    String rnaPath = bis.readString();
    bis.setPosition(currentPosition);
    int arrayIndex = ((Number) structure.getFieldValue("array_index")).intValue();
    // determining the curve type
    if (rnaPath.endsWith("location")) {
        return Ipo.AC_LOC_X + arrayIndex;
    }
    if (rnaPath.endsWith("rotation_quaternion")) {
        return Ipo.AC_QUAT_W + arrayIndex;
    }
    if (rnaPath.endsWith("scale")) {
        return Ipo.AC_SIZE_X + arrayIndex;
    }
    if (rnaPath.endsWith("rotation") || rnaPath.endsWith("rotation_euler")) {
        return Ipo.OB_ROT_X + arrayIndex;
    }
    LOGGER.log(Level.WARNING, "Unknown curve rna path: {0}", rnaPath);
    return -1;
}

Example 8 with Curve

use of com.jme3.scene.shape.Curve in project jmonkeyengine by jMonkeyEngine.

the class CurvesTemporalMesh method loadNurbSurface.

/**
     * This method loads the NURBS curve or surface.
     * @param nurb
     *            the NURBS data structure
     * @throws BlenderFileException
     *             an exception is thrown when problems with reading occur
     */
@SuppressWarnings("unchecked")
private void loadNurbSurface(Structure nurb, int materialIndex) throws BlenderFileException {
    // loading the knots
    List<Float>[] knots = new List[2];
    Pointer[] pKnots = new Pointer[] { (Pointer) nurb.getFieldValue("knotsu"), (Pointer) nurb.getFieldValue("knotsv") };
    for (int i = 0; i < knots.length; ++i) {
        if (pKnots[i].isNotNull()) {
            FileBlockHeader fileBlockHeader = blenderContext.getFileBlock(pKnots[i].getOldMemoryAddress());
            BlenderInputStream blenderInputStream = blenderContext.getInputStream();
            blenderInputStream.setPosition(fileBlockHeader.getBlockPosition());
            int knotsAmount = fileBlockHeader.getCount() * fileBlockHeader.getSize() / 4;
            knots[i] = new ArrayList<Float>(knotsAmount);
            for (int j = 0; j < knotsAmount; ++j) {
                knots[i].add(Float.valueOf(blenderInputStream.readFloat()));
            }
        }
    }
    // loading the flags and orders (basis functions degrees)
    int flag = ((Number) nurb.getFieldValue("flag")).intValue();
    boolean smooth = (flag & FLAG_SMOOTH) != 0;
    int flagU = ((Number) nurb.getFieldValue("flagu")).intValue();
    int flagV = ((Number) nurb.getFieldValue("flagv")).intValue();
    int orderU = ((Number) nurb.getFieldValue("orderu")).intValue();
    int orderV = ((Number) nurb.getFieldValue("orderv")).intValue();
    // loading control points and their weights
    int pntsU = ((Number) nurb.getFieldValue("pntsu")).intValue();
    int pntsV = ((Number) nurb.getFieldValue("pntsv")).intValue();
    List<Structure> bPoints = ((Pointer) nurb.getFieldValue("bp")).fetchData();
    List<List<Vector4f>> controlPoints = new ArrayList<List<Vector4f>>(pntsV);
    for (int i = 0; i < pntsV; ++i) {
        List<Vector4f> uControlPoints = new ArrayList<Vector4f>(pntsU);
        for (int j = 0; j < pntsU; ++j) {
            DynamicArray<Float> vec = (DynamicArray<Float>) bPoints.get(j + i * pntsU).getFieldValue("vec");
            if (blenderContext.getBlenderKey().isFixUpAxis()) {
                uControlPoints.add(new Vector4f(vec.get(0).floatValue(), vec.get(2).floatValue(), -vec.get(1).floatValue(), vec.get(3).floatValue()));
            } else {
                uControlPoints.add(new Vector4f(vec.get(0).floatValue(), vec.get(1).floatValue(), vec.get(2).floatValue(), vec.get(3).floatValue()));
            }
        }
        if ((flagU & 0x01) != 0) {
            for (int k = 0; k < orderU - 1; ++k) {
                uControlPoints.add(uControlPoints.get(k));
            }
        }
        controlPoints.add(uControlPoints);
    }
    if ((flagV & 0x01) != 0) {
        for (int k = 0; k < orderV - 1; ++k) {
            controlPoints.add(controlPoints.get(k));
        }
    }
    int originalVerticesAmount = vertices.size();
    int resolu = ((Number) nurb.getFieldValue("resolu")).intValue();
    if (knots[1] == null) {
        // creating the NURB curve
        Curve curve = new Curve(new Spline(controlPoints.get(0), knots[0]), resolu);
        FloatBuffer vertsBuffer = (FloatBuffer) curve.getBuffer(Type.Position).getData();
        beziers.add(new BezierLine(BufferUtils.getVector3Array(vertsBuffer), materialIndex, smooth, false));
    } else {
        // creating the NURB surface
        int resolv = ((Number) nurb.getFieldValue("resolv")).intValue();
        int uSegments = resolu * controlPoints.get(0).size() - 1;
        int vSegments = resolv * controlPoints.size() - 1;
        Surface nurbSurface = Surface.createNurbsSurface(controlPoints, knots, uSegments, vSegments, orderU, orderV, smooth);
        FloatBuffer vertsBuffer = (FloatBuffer) nurbSurface.getBuffer(Type.Position).getData();
        vertices.addAll(Arrays.asList(BufferUtils.getVector3Array(vertsBuffer)));
        FloatBuffer normalsBuffer = (FloatBuffer) nurbSurface.getBuffer(Type.Normal).getData();
        normals.addAll(Arrays.asList(BufferUtils.getVector3Array(normalsBuffer)));
        IndexBuffer indexBuffer = nurbSurface.getIndexBuffer();
        for (int i = 0; i < indexBuffer.size(); i += 3) {
            int index1 = indexBuffer.get(i) + originalVerticesAmount;
            int index2 = indexBuffer.get(i + 1) + originalVerticesAmount;
            int index3 = indexBuffer.get(i + 2) + originalVerticesAmount;
            faces.add(new Face(new Integer[] { index1, index2, index3 }, smooth, materialIndex, null, null, this));
        }
    }
}

Example 9 with Curve

use of com.jme3.scene.shape.Curve in project jmonkeyengine by jMonkeyEngine.

the class CurvesTemporalMesh method getValueAlongCurve.

/**
     * The method computes the value of a point at the certain relational distance from its beggining.
     * @param alongRatio
     *            the relative distance along the curve; should be a value between 0 and 1 inclusive;
     *            if the value exceeds the boundaries it is truncated to them
     * @return computed value along the curve
     */
private Vector3f getValueAlongCurve(float alongRatio) {
    alongRatio = FastMath.clamp(alongRatio, 0, 1);
    Vector3f result = new Vector3f();
    float probeLength = this.getLength() * alongRatio, length = 0;
    for (BezierLine bezier : beziers) {
        float edgeLength = bezier.getLength();
        if (length + edgeLength >= probeLength) {
            float ratioAlongEdge = (probeLength - length) / edgeLength;
            return bezier.getValueAlongCurve(ratioAlongEdge);
        }
        length += edgeLength;
    }
    return result;
}

Example 10 with Curve

use of com.jme3.scene.shape.Curve in project jmonkeyengine by jMonkeyEngine.

the class CurvesHelper method transformToFirstLineOfBevelPoints.

/**
     * This method transforms the first line of the bevel points positioning it
     * on the first point of the curve.
     * 
     * @param startingLinePoints
     *            the vbevel shape points
     * @param firstCurvePoint
     *            the first curve's point
     * @param secondCurvePoint
     *            the second curve's point
     * @return points of transformed bevel
     */
protected Vector3f[] transformToFirstLineOfBevelPoints(Vector3f[] startingLinePoints, Vector3f firstCurvePoint, Vector3f secondCurvePoint) {
    Vector3f planeNormal = secondCurvePoint.subtract(firstCurvePoint).normalizeLocal();
    float angle = FastMath.acos(planeNormal.dot(Vector3f.UNIT_X));
    Vector3f rotationVector = Vector3f.UNIT_X.cross(planeNormal).normalizeLocal();
    Matrix4f m = new Matrix4f();
    m.setRotationQuaternion(new Quaternion().fromAngleAxis(angle, rotationVector));
    m.setTranslation(firstCurvePoint);
    Vector3f temp = new Vector3f();
    Vector3f[] verts = new Vector3f[startingLinePoints.length];
    for (int i = 0; i < verts.length; ++i) {
        verts[i] = m.mult(startingLinePoints[i], temp).clone();
    }
    return verts;
}