Examples of com.jme3.scene.Mesh

com.jme3.scene.Mesh
Mesh is used to store rendering data.
All visible elements in a scene are represented by meshes. Meshes may contain three types of geometric primitives:
- Points - Every vertex represents a single point in space, the size of each point is specified via {@link Mesh#setPointSize(float) }. Points can also be used for {@link RenderState#setPointSprite(boolean) pointsprite} mode.
- Lines - 2 vertices represent a line segment, with the width specified via {@link Mesh#setLineWidth(float) }.
- Triangles - 3 vertices represent a solid triangle primitive.
@author Kirill Vainer

                    pageQuads.add(quads.getQuad());
                }
            }
        }


        Mesh m = getMesh();
        int vertCount = pageQuads.size() * 4;
        int triCount = pageQuads.size() * 2;


        VertexBuffer pb = m.getBuffer(Type.Position);
        VertexBuffer tb = m.getBuffer(Type.TexCoord);
        VertexBuffer ib = m.getBuffer(Type.Index);
        VertexBuffer cb = m.getBuffer(Type.Color);


        FloatBuffer fpb = (FloatBuffer) pb.getData();
        FloatBuffer ftb = (FloatBuffer) tb.getData();
        ShortBuffer sib = (ShortBuffer) ib.getData();
        ByteBuffer bcb = (ByteBuffer) cb.getData();


        // increase capacity of buffers as needed
        fpb.rewind();
        fpb = BufferUtils.ensureLargeEnough(fpb, vertCount * 3);
        fpb.limit(vertCount * 3);
        pb.updateData(fpb);


        ftb.rewind();
        ftb = BufferUtils.ensureLargeEnough(ftb, vertCount * 2);
        ftb.limit(vertCount * 2);
        tb.updateData(ftb);


        bcb.rewind();
        bcb = BufferUtils.ensureLargeEnough(bcb, vertCount * 4);
        bcb.limit(vertCount * 4);
        cb.updateData(bcb);


        sib.rewind();
        sib = BufferUtils.ensureLargeEnough(sib, triCount * 3);
        sib.limit(triCount * 3);
        ib.updateData(sib);


        m.updateCounts();


        // go for each quad and append it to the buffers
        if (pos != null) {
            for (int i = 0; i < pageQuads.size(); i++) {
                LetterQuad fq = pageQuads.get(i);

View Full Code Here


    public Triangle getTriangle(Triangle store){
        if (store == null)
            store = new Triangle();


        Mesh m = geometry.getMesh();
        m.getTriangle(triangleIndex, store);
        store.calculateCenter();
        store.calculateNormal();
        return store;
    }

View Full Code Here


        FloatBuffer[] vertexBuffers = new FloatBuffer[bevelObject.size()];
        FloatBuffer[] normalBuffers = new FloatBuffer[bevelObject.size()];
        IndexBuffer[] indexBuffers = new IndexBuffer[bevelObject.size()];
        for (int geomIndex = 0; geomIndex < bevelObject.size(); ++geomIndex) {
            Mesh mesh = bevelObject.get(geomIndex).getMesh();
            Vector3f[] positions = BufferUtils.getVector3Array(mesh.getFloatBuffer(Type.Position));
            Vector3f[] bevelPoints = this.transformToFirstLineOfBevelPoints(positions, curvePoints[0], curvePoints[1]);


            List<Vector3f[]> bevels = new ArrayList<Vector3f[]>(curvePoints.length);
            bevels.add(bevelPoints);


            vertexBuffers[geomIndex] = BufferUtils.createFloatBuffer(bevelPoints.length * 3 * curvePoints.length * (smooth ? 1 : 6));
            for (int i = 1; i < curvePoints.length - 1; ++i) {
                bevelPoints = this.transformBevel(bevelPoints, curvePoints[i - 1], curvePoints[i], curvePoints[i + 1]);
                bevels.add(bevelPoints);
            }
            bevelPoints = this.transformBevel(bevelPoints, curvePoints[curvePoints.length - 2], curvePoints[curvePoints.length - 1], null);
            bevels.add(bevelPoints);


            if (bevels.size() > 2) {
                // changing the first and last bevel so that they are parallel to their neighbours (blender works this way)
                // notice this implicates that the distances of every corresponding point in th two bevels must be identical and
                // equal to the distance between the points on curve that define the bevel position
                // so instead doing complicated rotations on each point we will simply properly translate each of them


                int[][] pointIndexes = new int[][] { { 0, 1 }, { curvePoints.length - 1, curvePoints.length - 2 } };
                for (int[] indexes : pointIndexes) {
                    float distance = curvePoints[indexes[1]].subtract(curvePoints[indexes[0]], subtractResult).length();
                    Vector3f[] bevel = bevels.get(indexes[0]);
                    Vector3f[] nextBevel = bevels.get(indexes[1]);
                    for (int i = 0; i < bevel.length; ++i) {
                        float d = bevel[i].subtract(nextBevel[i], subtractResult).length();
                        subtractResult.normalizeLocal().multLocal(distance - d);
                        bevel[i].addLocal(subtractResult);
                    }
                }
            }


            // apply scales to the bevels
            float lengthAlongCurve = 0;
            for (int i = 0; i < curvePoints.length; ++i) {
                if (i > 0) {
                    lengthAlongCurve += curvePoints[i].subtract(curvePoints[i - 1], subtractResult).length();
                }
                float taperScale = this.getTaperScale(taperObject, i == 0 ? 0 : lengthAlongCurve / curveLength);
                this.applyScale(bevels.get(i), curvePoints[i], taperScale);
            }


            if (smooth) {// add everything to the buffer
                for (Vector3f[] bevel : bevels) {
                    for (Vector3f d : bevel) {
                        vertexBuffers[geomIndex].put(d.x);
                        vertexBuffers[geomIndex].put(d.y);
                        vertexBuffers[geomIndex].put(d.z);
                    }
                }
            } else {// add vertices to the buffer duplicating them so that every vertex belongs only to a single triangle
                for (int i = 0; i < curvePoints.length - 1; ++i) {
                    for (int j = 0; j < bevelPoints.length - 1; ++j) {
                        // first triangle
                        vertexBuffers[geomIndex].put(bevels.get(i)[j].x);
                        vertexBuffers[geomIndex].put(bevels.get(i)[j].y);
                        vertexBuffers[geomIndex].put(bevels.get(i)[j].z);
                        vertexBuffers[geomIndex].put(bevels.get(i)[j + 1].x);
                        vertexBuffers[geomIndex].put(bevels.get(i)[j + 1].y);
                        vertexBuffers[geomIndex].put(bevels.get(i)[j + 1].z);
                        vertexBuffers[geomIndex].put(bevels.get(i + 1)[j].x);
                        vertexBuffers[geomIndex].put(bevels.get(i + 1)[j].y);
                        vertexBuffers[geomIndex].put(bevels.get(i + 1)[j].z);


                        // second triangle
                        vertexBuffers[geomIndex].put(bevels.get(i)[j + 1].x);
                        vertexBuffers[geomIndex].put(bevels.get(i)[j + 1].y);
                        vertexBuffers[geomIndex].put(bevels.get(i)[j + 1].z);
                        vertexBuffers[geomIndex].put(bevels.get(i + 1)[j + 1].x);
                        vertexBuffers[geomIndex].put(bevels.get(i + 1)[j + 1].y);
                        vertexBuffers[geomIndex].put(bevels.get(i + 1)[j + 1].z);
                        vertexBuffers[geomIndex].put(bevels.get(i + 1)[j].x);
                        vertexBuffers[geomIndex].put(bevels.get(i + 1)[j].y);
                        vertexBuffers[geomIndex].put(bevels.get(i + 1)[j].z);
                    }
                }
            }


            indexBuffers[geomIndex] = this.generateIndexes(bevelPoints.length, curvePoints.length, smooth);
            normalBuffers[geomIndex] = this.generateNormals(indexBuffers[geomIndex], vertexBuffers[geomIndex], smooth);
        }


        // creating and returning the result
        List<Geometry> result = new ArrayList<Geometry>(vertexBuffers.length);
        Float oneReferenceToCurveLength = new Float(curveLength);// its important for array modifier to use one reference here
        for (int i = 0; i < vertexBuffers.length; ++i) {
            Mesh mesh = new Mesh();
            mesh.setBuffer(Type.Position, 3, vertexBuffers[i]);
            if (indexBuffers[i].getBuffer() instanceof IntBuffer) {
                mesh.setBuffer(Type.Index, 3, (IntBuffer) indexBuffers[i].getBuffer());
            } else {
                mesh.setBuffer(Type.Index, 3, (ShortBuffer) indexBuffers[i].getBuffer());
            }
            mesh.setBuffer(Type.Normal, 3, normalBuffers[i]);
            Geometry g = new Geometry("g" + i, mesh);
            g.setUserData("curveLength", oneReferenceToCurveLength);
            g.updateModelBound();
            result.add(g);
        }

View Full Code Here

     * @param offset Target buffer offset.
     * @param outMesh The mesh to set the coords in (can be same as input).
     * @return true if texture has been found and coords have been changed, false otherwise.
     */
    public boolean applyCoords(Geometry geom, int offset, Mesh outMesh) {
        Mesh inMesh = geom.getMesh();
        geom.computeWorldMatrix();


        VertexBuffer inBuf = inMesh.getBuffer(Type.TexCoord);
        VertexBuffer outBuf = outMesh.getBuffer(Type.TexCoord);


        if (inBuf == null || outBuf == null) {
            throw new IllegalStateException("Geometry mesh has no texture coordinate buffer.");
        }

View Full Code Here

        TextureAtlas atlas = createAtlas(spat, atlasSize);
        if (atlas == null) {
            return null;
        }
        Geometry geom = new Geometry();
        Mesh mesh = new Mesh();
        GeometryBatchFactory.mergeGeometries(geometries, mesh);
        applyAtlasCoords(geometries, mesh, atlas);
        mesh.updateCounts();
        mesh.updateBound();
        geom.setMesh(mesh);


        Material mat = new Material(mgr, "Common/MatDefs/Light/Lighting.j3md");
        mat.getAdditionalRenderState().setAlphaTest(true);
        Texture diffuseMap = atlas.getAtlasTexture("DiffuseMap");

View Full Code Here


    private static void applyAtlasCoords(List<Geometry> geometries, Mesh outMesh, TextureAtlas atlas) {
        int globalVertIndex = 0;


        for (Geometry geom : geometries) {
            Mesh inMesh = geom.getMesh();
            geom.computeWorldMatrix();


            int geomVertCount = inMesh.getVertexCount();


            VertexBuffer inBuf = inMesh.getBuffer(Type.TexCoord);
            VertexBuffer outBuf = outMesh.getBuffer(Type.TexCoord);


            if (inBuf == null || outBuf == null) {
                continue;
            }

View Full Code Here

    public Map<Integer, Mesh> buildMeshes() {
        LOGGER.fine("Building point mesh.");
        Map<Integer, Mesh> result = new HashMap<Integer, Mesh>(1);


        if (vertices.size() > 0) {
            Mesh mesh = new Mesh();
            mesh.setMode(Mode.Points);
            mesh.setPointSize(3);


            // the point mesh does not need index buffer, but some modifiers applied by importer need it
            // the 'alone point' situation should be quite rare so not too many resources are wasted here
            LOGGER.fine("Creating indices buffer.");
            if (vertices.size() <= Short.MAX_VALUE) {
                short[] indices = new short[vertices.size()];
                for (int i = 0; i < vertices.size(); ++i) {
                    indices[i] = (short) i;
                }
                mesh.setBuffer(Type.Index, 1, indices);
            } else {
                int[] indices = new int[vertices.size()];
                for (int i = 0; i < vertices.size(); ++i) {
                    indices[i] = i;
                }
                mesh.setBuffer(Type.Index, 1, indices);
            }


            LOGGER.fine("Creating vertices buffer.");
            VertexBuffer verticesBuffer = new VertexBuffer(Type.Position);
            verticesBuffer.setupData(Usage.Static, 3, Format.Float, BufferUtils.createFloatBuffer(vertices.toArray(new Vector3f[vertices.size()])));
            mesh.setBuffer(verticesBuffer);
            
            LOGGER.fine("Creating normals buffer (in case of points it is required if skeleton is applied).");
            VertexBuffer normalsBuffer = new VertexBuffer(Type.Normal);
            normalsBuffer.setupData(Usage.Static, 3, Format.Float, BufferUtils.createFloatBuffer(normals.toArray(new Vector3f[normals.size()])));
            mesh.setBuffer(normalsBuffer);


            result.put(-1, mesh);
        }
        return result;
    }

View Full Code Here

     */
    public Map<Integer, Mesh> buildMeshes() {
        LOGGER.fine("Building line mesh.");
        Map<Integer, Mesh> result = new HashMap<Integer, Mesh>(1);
        if (vertices.size() > 0) {
            Mesh mesh = new Mesh();
            mesh.setMode(Mode.Lines);


            LOGGER.fine("Creating indices buffer.");
            if (vertices.size() <= Short.MAX_VALUE) {
                short[] indices = new short[vertices.size()];
                for (int i = 0; i < vertices.size(); ++i) {
                    indices[i] = (short) i;
                }
                mesh.setBuffer(Type.Index, 1, indices);
            } else {
                int[] indices = new int[vertices.size()];
                for (int i = 0; i < vertices.size(); ++i) {
                    indices[i] = i;
                }
                mesh.setBuffer(Type.Index, 1, indices);
            }


            LOGGER.fine("Creating vertices buffer.");
            VertexBuffer verticesBuffer = new VertexBuffer(Type.Position);
            verticesBuffer.setupData(Usage.Static, 3, Format.Float, BufferUtils.createFloatBuffer(vertices.toArray(new Vector3f[vertices.size()])));
            mesh.setBuffer(verticesBuffer);


            LOGGER.fine("Creating normals buffer (in case of lines it is required if skeleton is applied).");
            VertexBuffer normalsBuffer = new VertexBuffer(Type.Normal);
            normalsBuffer.setupData(Usage.Static, 3, Format.Float, BufferUtils.createFloatBuffer(normals.toArray(new Vector3f[normals.size()])));
            mesh.setBuffer(normalsBuffer);
            
            result.put(-1, mesh);
        }
        return result;
    }

View Full Code Here

            int inGeomIndex = entry.getKey().intValue();
            int outOffset = entry.getValue().start;
            int outLength = entry.getValue().length;


            Geometry inGeom = inGeoms[inGeomIndex];
            Mesh in = inGeom.getMesh();
            Mesh out = new Mesh();


            int outElementCount = outLength * 3;
            ShortBuffer ib = BufferUtils.createShortBuffer(outElementCount);
            out.setBuffer(Type.Index, 3, ib);


            // generate output buffers based on input buffers
            IntMap<VertexBuffer> bufs = in.getBuffers();
            for (Entry<VertexBuffer> ent : bufs){
                VertexBuffer vb = ent.getValue();
                if (vb.getBufferType() == Type.Index)
                    continue;


                // NOTE: we are not actually sure
                // how many elements will be in this buffer.
                // It will be compacted later.
                Buffer b = VertexBuffer.createBuffer(vb.getFormat(), 
                                                     vb.getNumComponents(),
                                                     outElementCount);


                VertexBuffer outVb = new VertexBuffer(vb.getBufferType());
                outVb.setNormalized(vb.isNormalized());
                outVb.setupData(vb.getUsage(), vb.getNumComponents(), vb.getFormat(), b);
                out.setBuffer(outVb);
            }


            int currentVertex = 0;
            for (int i = outOffset; i < outOffset + outLength; i++){
                OCTTriangle t = tris.get(i);


                // find vertex indices for triangle t
                in.getTriangle(t.getTriangleIndex(), vertIndicies);


                // find indices in new buf
                Integer i0 = indexCache.get(vertIndicies[0]);
                Integer i1 = indexCache.get(vertIndicies[1]);
                Integer i2 = indexCache.get(vertIndicies[2]);


                // check which ones were not created
                // if not created in new IB, create them
                if (i0 == null){
                    vertexCreated[0] = true;
                    newIndices[0] = currentVertex++;
                    indexCache.put(vertIndicies[0], newIndices[0]);
                }else{
                    newIndices[0] = i0.intValue();
                    vertexCreated[0] = false;
                }
                if (i1 == null){
                    vertexCreated[1] = true;
                    newIndices[1] = currentVertex++;
                    indexCache.put(vertIndicies[1], newIndices[1]);
                }else{
                    newIndices[1] = i1.intValue();
                    vertexCreated[1] = false;
                }
                if (i2 == null){
                    vertexCreated[2] = true;
                    newIndices[2] = currentVertex++;
                    indexCache.put(vertIndicies[2], newIndices[2]);
                }else{
                    newIndices[2] = i2.intValue();
                    vertexCreated[2] = false;
                }


                // if any verticies were created for this triangle
                // copy them to the output mesh
                IntMap<VertexBuffer> inbufs = in.getBuffers();
                for (Entry<VertexBuffer> ent : inbufs){
                    VertexBuffer vb = ent.getValue();
                    if (vb.getBufferType() == Type.Index)
                        continue;
                    
                    VertexBuffer outVb = out.getBuffer(vb.getBufferType());
                    // copy verticies that were created for this triangle
                    for (int v = 0; v < 3; v++){
                        if (!vertexCreated[v])
                            continue;


                        // copy triangle's attribute from one
                        // buffer to another
                        vb.copyElement(vertIndicies[v], outVb, newIndices[v]);
                    }
                }


                // write the indices onto the output index buffer
                ib.put((short)newIndices[0])
                  .put((short)newIndices[1])
                  .put((short)newIndices[2]);
            }
            ib.clear();
            indexCache.clear();


            // since some verticies were cached, it means there's
            // extra data in some buffers
            IntMap<VertexBuffer> outbufs = out.getBuffers();
            for (Entry<VertexBuffer> ent : outbufs){
                VertexBuffer vb = ent.getValue();
                if (vb.getBufferType() == Type.Index)
                    continue;


                vb.compact(currentVertex);
            }


            out.updateBound();
            out.updateCounts();
            out.setStatic();
            //out.setInterleaved();
            Geometry outGeom = new Geometry("Geom"+entry.getKey(), out);
            outGeom.setLocalTransform(inGeom.getWorldTransform());
            outGeom.setMaterial(inGeom.getMaterial());
            for (Light light : inGeom.getWorldLightList()){

View Full Code Here

     * @param blenderContext
     *            the blender context
     */
    @SuppressWarnings("unchecked")
    public void flatten(Geometry geometry, Long geometriesOMA, LinkedHashMap<String, List<Vector2f>> userDefinedUVCoordinates, BlenderContext blenderContext) {
        Mesh mesh = geometry.getMesh();
        Texture previousTexture = null;
        UVCoordinatesType masterUVCoordinatesType = null;
        String masterUserUVSetName = null;
        for (TextureData textureData : textureDatas) {
            // decompress compressed textures (all will be merged into one texture anyway)

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of com.jme3.scene.Mesh

clj3D.Utilities

clj3D.Viewer

clj3D.Viewer$AppActionListener

com.jme3.font.BitmapTextPage

com.jme3.swingGui.JMEDesktop

com.jme3.terrain.geomipmap.TerrainPatch

com.l2client.animsystem.example.AnimationInputTest

com.l2client.animsystem.jme.BoundsUpdateControl

com.l2client.animsystem.jme.test.TestNewAnimations

com.l2client.app.Assembler

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.