Examples with FloatBuffer java.nio.FloatBuffer used on opensource projects

Example 46 with FloatBuffer

use of java.nio.FloatBuffer in project jmonkeyengine by jMonkeyEngine.

the class ParticleTriMesh method initParticleData.

//    private Particle[] particlesCopy;
@Override
public void initParticleData(ParticleEmitter emitter, int numParticles) {
    setMode(Mode.Triangles);
    this.emitter = emitter;
    //        particlesCopy = new Particle[numParticles];
    // set positions
    FloatBuffer pb = BufferUtils.createVector3Buffer(numParticles * 4);
    // if the buffer is already set only update the data
    VertexBuffer buf = getBuffer(VertexBuffer.Type.Position);
    if (buf != null) {
        buf.updateData(pb);
    } else {
        VertexBuffer pvb = new VertexBuffer(VertexBuffer.Type.Position);
        pvb.setupData(Usage.Stream, 3, Format.Float, pb);
        setBuffer(pvb);
    }
    // set colors
    ByteBuffer cb = BufferUtils.createByteBuffer(numParticles * 4 * 4);
    buf = getBuffer(VertexBuffer.Type.Color);
    if (buf != null) {
        buf.updateData(cb);
    } else {
        VertexBuffer cvb = new VertexBuffer(VertexBuffer.Type.Color);
        cvb.setupData(Usage.Stream, 4, Format.UnsignedByte, cb);
        cvb.setNormalized(true);
        setBuffer(cvb);
    }
    // set texcoords
    FloatBuffer tb = BufferUtils.createVector2Buffer(numParticles * 4);
    uniqueTexCoords = false;
    for (int i = 0; i < numParticles; i++) {
        tb.put(0f).put(1f);
        tb.put(1f).put(1f);
        tb.put(0f).put(0f);
        tb.put(1f).put(0f);
    }
    tb.flip();
    buf = getBuffer(VertexBuffer.Type.TexCoord);
    if (buf != null) {
        buf.updateData(tb);
    } else {
        VertexBuffer tvb = new VertexBuffer(VertexBuffer.Type.TexCoord);
        tvb.setupData(Usage.Static, 2, Format.Float, tb);
        setBuffer(tvb);
    }
    // set indices
    ShortBuffer ib = BufferUtils.createShortBuffer(numParticles * 6);
    for (int i = 0; i < numParticles; i++) {
        int startIdx = (i * 4);
        // triangle 1
        ib.put((short) (startIdx + 1)).put((short) (startIdx + 0)).put((short) (startIdx + 2));
        // triangle 2
        ib.put((short) (startIdx + 1)).put((short) (startIdx + 2)).put((short) (startIdx + 3));
    }
    ib.flip();
    buf = getBuffer(VertexBuffer.Type.Index);
    if (buf != null) {
        buf.updateData(ib);
    } else {
        VertexBuffer ivb = new VertexBuffer(VertexBuffer.Type.Index);
        ivb.setupData(Usage.Static, 3, Format.UnsignedShort, ib);
        setBuffer(ivb);
    }
    updateCounts();
}

Example 47 with FloatBuffer

use of java.nio.FloatBuffer in project jmonkeyengine by jMonkeyEngine.

the class GlfwJoystickInput method loadJoysticks.

@Override
public Joystick[] loadJoysticks(final InputManager inputManager) {
    for (int i = 0; i < GLFW_JOYSTICK_LAST; i++) {
        if (glfwJoystickPresent(i)) {
            final String name = glfwGetJoystickName(i);
            final GlfwJoystick joystick = new GlfwJoystick(inputManager, this, i, name);
            joysticks.put(i, joystick);
            final FloatBuffer floatBuffer = glfwGetJoystickAxes(i);
            int axisIndex = 0;
            while (floatBuffer.hasRemaining()) {
                floatBuffer.get();
                final String logicalId = JoystickCompatibilityMappings.remapComponent(joystick.getName(), convertAxisIndex(axisIndex));
                final JoystickAxis joystickAxis = new DefaultJoystickAxis(inputManager, joystick, axisIndex, convertAxisIndex(axisIndex), logicalId, true, false, 0.0f);
                joystick.addAxis(axisIndex, joystickAxis);
                axisIndex++;
            }
            final ByteBuffer byteBuffer = glfwGetJoystickButtons(i);
            int buttonIndex = 0;
            while (byteBuffer.hasRemaining()) {
                byteBuffer.get();
                final String logicalId = JoystickCompatibilityMappings.remapComponent(joystick.getName(), String.valueOf(buttonIndex));
                joystick.addButton(new DefaultJoystickButton(inputManager, joystick, buttonIndex, String.valueOf(buttonIndex), logicalId));
                buttonIndex++;
            }
        }
    }
    return joysticks.values().toArray(new GlfwJoystick[joysticks.size()]);
}

Example 48 with FloatBuffer

use of java.nio.FloatBuffer in project jmonkeyengine by jMonkeyEngine.

the class Cylinder method updateGeometry.

/**
     * Rebuilds the cylinder based on a new set of parameters.
     *
     * @param axisSamples the number of samples along the axis.
     * @param radialSamples the number of samples around the radial.
     * @param radius the radius of the bottom of the cylinder.
     * @param radius2 the radius of the top of the cylinder.
     * @param height the cylinder's height.
     * @param closed should the cylinder have top and bottom surfaces.
     * @param inverted is the cylinder is meant to be viewed from the inside.
     */
public void updateGeometry(int axisSamples, int radialSamples, float radius, float radius2, float height, boolean closed, boolean inverted) {
    this.axisSamples = axisSamples;
    this.radialSamples = radialSamples;
    this.radius = radius;
    this.radius2 = radius2;
    this.height = height;
    this.closed = closed;
    this.inverted = inverted;
    //        VertexBuffer pvb = getBuffer(Type.Position);
    //        VertexBuffer nvb = getBuffer(Type.Normal);
    //        VertexBuffer tvb = getBuffer(Type.TexCoord);
    axisSamples += (closed ? 2 : 0);
    // Vertices
    int vertCount = axisSamples * (radialSamples + 1) + (closed ? 2 : 0);
    setBuffer(Type.Position, 3, createVector3Buffer(getFloatBuffer(Type.Position), vertCount));
    // Normals
    setBuffer(Type.Normal, 3, createVector3Buffer(getFloatBuffer(Type.Normal), vertCount));
    // Texture co-ordinates
    setBuffer(Type.TexCoord, 2, createVector2Buffer(vertCount));
    int triCount = ((closed ? 2 : 0) + 2 * (axisSamples - 1)) * radialSamples;
    setBuffer(Type.Index, 3, createShortBuffer(getShortBuffer(Type.Index), 3 * triCount));
    // generate geometry
    float inverseRadial = 1.0f / radialSamples;
    float inverseAxisLess = 1.0f / (closed ? axisSamples - 3 : axisSamples - 1);
    float inverseAxisLessTexture = 1.0f / (axisSamples - 1);
    float halfHeight = 0.5f * height;
    // Generate points on the unit circle to be used in computing the mesh
    // points on a cylinder slice.
    float[] sin = new float[radialSamples + 1];
    float[] cos = new float[radialSamples + 1];
    for (int radialCount = 0; radialCount < radialSamples; radialCount++) {
        float angle = FastMath.TWO_PI * inverseRadial * radialCount;
        cos[radialCount] = FastMath.cos(angle);
        sin[radialCount] = FastMath.sin(angle);
    }
    sin[radialSamples] = sin[0];
    cos[radialSamples] = cos[0];
    // calculate normals
    Vector3f[] vNormals = null;
    Vector3f vNormal = Vector3f.UNIT_Z;
    if ((height != 0.0f) && (radius != radius2)) {
        vNormals = new Vector3f[radialSamples];
        Vector3f vHeight = Vector3f.UNIT_Z.mult(height);
        Vector3f vRadial = new Vector3f();
        for (int radialCount = 0; radialCount < radialSamples; radialCount++) {
            vRadial.set(cos[radialCount], sin[radialCount], 0.0f);
            Vector3f vRadius = vRadial.mult(radius);
            Vector3f vRadius2 = vRadial.mult(radius2);
            Vector3f vMantle = vHeight.subtract(vRadius2.subtract(vRadius));
            Vector3f vTangent = vRadial.cross(Vector3f.UNIT_Z);
            vNormals[radialCount] = vMantle.cross(vTangent).normalize();
        }
    }
    FloatBuffer nb = getFloatBuffer(Type.Normal);
    FloatBuffer pb = getFloatBuffer(Type.Position);
    FloatBuffer tb = getFloatBuffer(Type.TexCoord);
    // generate the cylinder itself
    Vector3f tempNormal = new Vector3f();
    for (int axisCount = 0, i = 0; axisCount < axisSamples; axisCount++, i++) {
        float axisFraction;
        float axisFractionTexture;
        int topBottom = 0;
        if (!closed) {
            // in [0,1]
            axisFraction = axisCount * inverseAxisLess;
            axisFractionTexture = axisFraction;
        } else {
            if (axisCount == 0) {
                // bottom
                topBottom = -1;
                axisFraction = 0;
                axisFractionTexture = inverseAxisLessTexture;
            } else if (axisCount == axisSamples - 1) {
                // top
                topBottom = 1;
                axisFraction = 1;
                axisFractionTexture = 1 - inverseAxisLessTexture;
            } else {
                axisFraction = (axisCount - 1) * inverseAxisLess;
                axisFractionTexture = axisCount * inverseAxisLessTexture;
            }
        }
        // compute center of slice
        float z = -halfHeight + height * axisFraction;
        Vector3f sliceCenter = new Vector3f(0, 0, z);
        // compute slice vertices with duplication at end point
        int save = i;
        for (int radialCount = 0; radialCount < radialSamples; radialCount++, i++) {
            // in [0,1)
            float radialFraction = radialCount * inverseRadial;
            tempNormal.set(cos[radialCount], sin[radialCount], 0.0f);
            if (vNormals != null) {
                vNormal = vNormals[radialCount];
            } else if (radius == radius2) {
                vNormal = tempNormal;
            }
            if (topBottom == 0) {
                if (!inverted)
                    nb.put(vNormal.x).put(vNormal.y).put(vNormal.z);
                else
                    nb.put(-vNormal.x).put(-vNormal.y).put(-vNormal.z);
            } else {
                nb.put(0).put(0).put(topBottom * (inverted ? -1 : 1));
            }
            tempNormal.multLocal((radius - radius2) * axisFraction + radius2).addLocal(sliceCenter);
            pb.put(tempNormal.x).put(tempNormal.y).put(tempNormal.z);
            tb.put((inverted ? 1 - radialFraction : radialFraction)).put(axisFractionTexture);
        }
        BufferUtils.copyInternalVector3(pb, save, i);
        BufferUtils.copyInternalVector3(nb, save, i);
        tb.put((inverted ? 0.0f : 1.0f)).put(axisFractionTexture);
    }
    if (closed) {
        // bottom center
        pb.put(0).put(0).put(-halfHeight);
        nb.put(0).put(0).put(-1 * (inverted ? -1 : 1));
        tb.put(0.5f).put(0);
        // top center
        pb.put(0).put(0).put(halfHeight);
        nb.put(0).put(0).put(1 * (inverted ? -1 : 1));
        tb.put(0.5f).put(1);
    }
    IndexBuffer ib = getIndexBuffer();
    int index = 0;
    // Connectivity
    for (int axisCount = 0, axisStart = 0; axisCount < axisSamples - 1; axisCount++) {
        int i0 = axisStart;
        int i1 = i0 + 1;
        axisStart += radialSamples + 1;
        int i2 = axisStart;
        int i3 = i2 + 1;
        for (int i = 0; i < radialSamples; i++) {
            if (closed && axisCount == 0) {
                if (!inverted) {
                    ib.put(index++, i0++);
                    ib.put(index++, vertCount - 2);
                    ib.put(index++, i1++);
                } else {
                    ib.put(index++, i0++);
                    ib.put(index++, i1++);
                    ib.put(index++, vertCount - 2);
                }
            } else if (closed && axisCount == axisSamples - 2) {
                ib.put(index++, i2++);
                ib.put(index++, inverted ? vertCount - 1 : i3++);
                ib.put(index++, inverted ? i3++ : vertCount - 1);
            } else {
                ib.put(index++, i0++);
                ib.put(index++, inverted ? i2 : i1);
                ib.put(index++, inverted ? i1 : i2);
                ib.put(index++, i1++);
                ib.put(index++, inverted ? i2++ : i3++);
                ib.put(index++, inverted ? i3++ : i2++);
            }
        }
    }
    updateBound();
    setStatic();
}

Example 49 with FloatBuffer

use of java.nio.FloatBuffer in project jmonkeyengine by jMonkeyEngine.

the class Torus method setGeometryData.

private void setGeometryData() {
    // allocate vertices
    int vertCount = (circleSamples + 1) * (radialSamples + 1);
    FloatBuffer fpb = BufferUtils.createVector3Buffer(vertCount);
    setBuffer(Type.Position, 3, fpb);
    // allocate normals if requested
    FloatBuffer fnb = BufferUtils.createVector3Buffer(vertCount);
    setBuffer(Type.Normal, 3, fnb);
    // allocate texture coordinates
    FloatBuffer ftb = BufferUtils.createVector2Buffer(vertCount);
    setBuffer(Type.TexCoord, 2, ftb);
    // generate geometry
    float inverseCircleSamples = 1.0f / circleSamples;
    float inverseRadialSamples = 1.0f / radialSamples;
    int i = 0;
    // generate the cylinder itself
    Vector3f radialAxis = new Vector3f(), torusMiddle = new Vector3f(), tempNormal = new Vector3f();
    for (int circleCount = 0; circleCount < circleSamples; circleCount++) {
        // compute center point on torus circle at specified angle
        float circleFraction = circleCount * inverseCircleSamples;
        float theta = FastMath.TWO_PI * circleFraction;
        float cosTheta = FastMath.cos(theta);
        float sinTheta = FastMath.sin(theta);
        radialAxis.set(cosTheta, sinTheta, 0);
        radialAxis.mult(outerRadius, torusMiddle);
        // compute slice vertices with duplication at end point
        int iSave = i;
        for (int radialCount = 0; radialCount < radialSamples; radialCount++) {
            float radialFraction = radialCount * inverseRadialSamples;
            // in [0,1)
            float phi = FastMath.TWO_PI * radialFraction;
            float cosPhi = FastMath.cos(phi);
            float sinPhi = FastMath.sin(phi);
            tempNormal.set(radialAxis).multLocal(cosPhi);
            tempNormal.z += sinPhi;
            fnb.put(tempNormal.x).put(tempNormal.y).put(tempNormal.z);
            tempNormal.multLocal(innerRadius).addLocal(torusMiddle);
            fpb.put(tempNormal.x).put(tempNormal.y).put(tempNormal.z);
            ftb.put(radialFraction).put(circleFraction);
            i++;
        }
        BufferUtils.copyInternalVector3(fpb, iSave, i);
        BufferUtils.copyInternalVector3(fnb, iSave, i);
        ftb.put(1.0f).put(circleFraction);
        i++;
    }
    // duplicate the cylinder ends to form a torus
    for (int iR = 0; iR <= radialSamples; iR++, i++) {
        BufferUtils.copyInternalVector3(fpb, iR, i);
        BufferUtils.copyInternalVector3(fnb, iR, i);
        BufferUtils.copyInternalVector2(ftb, iR, i);
        ftb.put(i * 2 + 1, 1.0f);
    }
}

Example 50 with FloatBuffer

use of java.nio.FloatBuffer in project jmonkeyengine by jMonkeyEngine.

the class Sphere method setGeometryData.

/**
     * builds the vertices based on the radius, radial and zSamples.
     */
private void setGeometryData() {
    // allocate vertices
    vertCount = (zSamples - 2) * (radialSamples + 1) + 2;
    FloatBuffer posBuf = BufferUtils.createVector3Buffer(vertCount);
    // allocate normals if requested
    FloatBuffer normBuf = BufferUtils.createVector3Buffer(vertCount);
    // allocate texture coordinates
    FloatBuffer texBuf = BufferUtils.createVector2Buffer(vertCount);
    setBuffer(Type.Position, 3, posBuf);
    setBuffer(Type.Normal, 3, normBuf);
    setBuffer(Type.TexCoord, 2, texBuf);
    // generate geometry
    float fInvRS = 1.0f / radialSamples;
    float fZFactor = 2.0f / (zSamples - 1);
    // Generate points on the unit circle to be used in computing the mesh
    // points on a sphere slice.
    float[] afSin = new float[(radialSamples + 1)];
    float[] afCos = new float[(radialSamples + 1)];
    for (int iR = 0; iR < radialSamples; iR++) {
        float fAngle = FastMath.TWO_PI * fInvRS * iR;
        afCos[iR] = FastMath.cos(fAngle);
        afSin[iR] = FastMath.sin(fAngle);
    }
    afSin[radialSamples] = afSin[0];
    afCos[radialSamples] = afCos[0];
    TempVars vars = TempVars.get();
    Vector3f tempVa = vars.vect1;
    Vector3f tempVb = vars.vect2;
    Vector3f tempVc = vars.vect3;
    // generate the sphere itself
    int i = 0;
    for (int iZ = 1; iZ < (zSamples - 1); iZ++) {
        // in (-pi/2, pi/2)
        float fAFraction = FastMath.HALF_PI * (-1.0f + fZFactor * iZ);
        float fZFraction;
        if (useEvenSlices) {
            // in (-1, 1)
            fZFraction = -1.0f + fZFactor * iZ;
        } else {
            // in (-1,1)
            fZFraction = FastMath.sin(fAFraction);
        }
        float fZ = radius * fZFraction;
        // compute center of slice
        Vector3f kSliceCenter = tempVb.set(Vector3f.ZERO);
        kSliceCenter.z += fZ;
        // compute radius of slice
        float fSliceRadius = FastMath.sqrt(FastMath.abs(radius * radius - fZ * fZ));
        // compute slice vertices with duplication at end point
        Vector3f kNormal;
        int iSave = i;
        for (int iR = 0; iR < radialSamples; iR++) {
            // in [0,1)
            float fRadialFraction = iR * fInvRS;
            Vector3f kRadial = tempVc.set(afCos[iR], afSin[iR], 0);
            kRadial.mult(fSliceRadius, tempVa);
            posBuf.put(kSliceCenter.x + tempVa.x).put(kSliceCenter.y + tempVa.y).put(kSliceCenter.z + tempVa.z);
            BufferUtils.populateFromBuffer(tempVa, posBuf, i);
            kNormal = tempVa;
            kNormal.normalizeLocal();
            if (// allow interior texture vs. exterior
            !interior) {
                normBuf.put(kNormal.x).put(kNormal.y).put(kNormal.z);
            } else {
                normBuf.put(-kNormal.x).put(-kNormal.y).put(-kNormal.z);
            }
            if (textureMode == TextureMode.Original) {
                texBuf.put(fRadialFraction).put(0.5f * (fZFraction + 1.0f));
            } else if (textureMode == TextureMode.Projected) {
                texBuf.put(fRadialFraction).put(FastMath.INV_PI * (FastMath.HALF_PI + FastMath.asin(fZFraction)));
            } else if (textureMode == TextureMode.Polar) {
                float r = (FastMath.HALF_PI - FastMath.abs(fAFraction)) / FastMath.PI;
                float u = r * afCos[iR] + 0.5f;
                float v = r * afSin[iR] + 0.5f;
                texBuf.put(u).put(v);
            }
            i++;
        }
        BufferUtils.copyInternalVector3(posBuf, iSave, i);
        BufferUtils.copyInternalVector3(normBuf, iSave, i);
        if (textureMode == TextureMode.Original) {
            texBuf.put(1.0f).put(0.5f * (fZFraction + 1.0f));
        } else if (textureMode == TextureMode.Projected) {
            texBuf.put(1.0f).put(FastMath.INV_PI * (FastMath.HALF_PI + FastMath.asin(fZFraction)));
        } else if (textureMode == TextureMode.Polar) {
            float r = (FastMath.HALF_PI - FastMath.abs(fAFraction)) / FastMath.PI;
            texBuf.put(r + 0.5f).put(0.5f);
        }
        i++;
    }
    vars.release();
    // south pole
    posBuf.position(i * 3);
    posBuf.put(0f).put(0f).put(-radius);
    normBuf.position(i * 3);
    if (!interior) {
        // allow for inner
        normBuf.put(0).put(0).put(-1);
    } else // texture orientation
    // later.
    {
        normBuf.put(0).put(0).put(1);
    }
    texBuf.position(i * 2);
    if (textureMode == TextureMode.Polar) {
        texBuf.put(0.5f).put(0.5f);
    } else {
        texBuf.put(0.5f).put(0.0f);
    }
    i++;
    // north pole
    posBuf.put(0).put(0).put(radius);
    if (!interior) {
        normBuf.put(0).put(0).put(1);
    } else {
        normBuf.put(0).put(0).put(-1);
    }
    if (textureMode == TextureMode.Polar) {
        texBuf.put(0.5f).put(0.5f);
    } else {
        texBuf.put(0.5f).put(1.0f);
    }
    updateBound();
}