Examples of com.ardor3d.scenegraph.MeshData

com.ardor3d.scenegraph.MeshData
MeshData contains all the commonly used buffers for rendering a mesh.

        
        
    }
    public void generateFoliage(DetailLevel level, VoxelBlock block) {
        Mesh mesh = new Mesh();
        MeshData meshData = mesh.getMeshData();
        int numOfLeafs = foliagePositions.size();
               
        Vector3[] points = new Vector3[8];
        for (int i = 0; i<8; i++)
            points[i] = new Vector3();
        
        
        FloatBuffer vertexBuffer = BufferUtils.createVector3Buffer(numOfLeafs*8);
        FloatBuffer textureCoordBuffer = BufferUtils.createVector2Buffer(numOfLeafs*8);
        IntBuffer indexBuffer = BufferUtils.createIntBuffer(numOfLeafs * 12);
        //FloatBuffer normalBuffer = BufferUtils.createVector3Buffer(numOfLeafs*4);
       
       
        for (int i = 0; i<foliagePositions.size(); i++) {
            FszMatrix4 position = foliagePositions.get(i);
                        
            points[0].set(-14, -1, 0);
            points[1].set(-14, 20, 0);
            points[2].set(14, 20, 0);
            points[3].set(14, -1, 0);
            
            points[4].set(0, -1, -14);
            points[5].set(0, 20, -14);
            points[6].set(0, 20, 4);
            points[7].set(0, -1, 4);
            
            for (Vector3 p : points) {
                position.applyPost(p,p);
                vertexBuffer.put(p.getXf());
                vertexBuffer.put(p.getYf());
                vertexBuffer.put(p.getZf());
            }


            
            int i8 = i*8;
            indexBuffer.put(i8+0);
            indexBuffer.put(i8+1);
            indexBuffer.put(i8+2);
            indexBuffer.put(i8+2);
            indexBuffer.put(i8+3);
            indexBuffer.put(i8+0);
            
            indexBuffer.put(i8+0+4);
            indexBuffer.put(i8+1+4);
            indexBuffer.put(i8+2+4);
            indexBuffer.put(i8+2+4);
            indexBuffer.put(i8+3+4);
            indexBuffer.put(i8+0+4);
            
            textureCoordBuffer.put(0);textureCoordBuffer.put(0);
            textureCoordBuffer.put(0);textureCoordBuffer.put(1);
            textureCoordBuffer.put(1);textureCoordBuffer.put(1);
            textureCoordBuffer.put(1);textureCoordBuffer.put(0);
            
            textureCoordBuffer.put(0);textureCoordBuffer.put(0);
            textureCoordBuffer.put(0);textureCoordBuffer.put(1);
            textureCoordBuffer.put(1);textureCoordBuffer.put(1);
            textureCoordBuffer.put(1);textureCoordBuffer.put(0);
        }


        //indexBuffer.rewind();


        meshData.setVertexBuffer(vertexBuffer);
        meshData.setIndexBuffer(indexBuffer);
        meshData.setTextureBuffer(textureCoordBuffer, 0);
        //meshData.setNormalBuffer(normalBuffer);


        
        block.getFoliageNode().attachChild(mesh);
    }

View Full Code Here

    }
    
    
    public void generateNonVoxelBranches(DetailLevel level, VoxelBlock block) {
        Mesh mesh = new Mesh();
        MeshData meshData = mesh.getMeshData();
        
        int numOfSegments = 6;
        
        Vector3 point1 = new Vector3();
        Vector3 point2 = new Vector3();
        Vector3 normal = new Vector3();
        
        FloatBuffer vertexBuffer = BufferUtils.createVector3Buffer(numOfNonVoxelBranches * numOfSegments * 2);
        FloatBuffer textureCoordBuffer = BufferUtils.createVector2Buffer(numOfNonVoxelBranches * numOfSegments * 2);
        IntBuffer indexBuffer = BufferUtils.createIntBuffer(numOfNonVoxelBranches * (numOfSegments + 1) * 2);
        FloatBuffer normalBuffer = BufferUtils.createVector3Buffer(numOfNonVoxelBranches * numOfSegments * 2);
              
        for (int i = 0; i<branches.size(); i++) {
            Branch branch = branches.get(i);
            FszMatrix4 transform = branch.getTransform();
            double startRadius = branch.getStartRadius();
            double endRadius = branch.getEndRadius();
            double length = branch.getLength();
            
            int ii = i* numOfSegments * 2;
            Vector3 startPoint = branch.getStartPoint();


            for (int s = 0; s<numOfSegments; s++) {
                double angle = s * Math.PI * 2 /numOfSegments ;
                float texCoordX = s/(float)numOfSegments;
                
                double ux = Math.cos(angle);
                double uz = Math.sin(angle);
                
                VoxelWorld.logger.info("SZOG " + angle +" "+ ux +" "+uz);
                point1.set( ux*startRadius, 0, uz*startRadius);
                point2.set( ux*endRadius, length, uz*endRadius);
                
                transform.applyPost(point1,point1);
                transform.applyPost(point2,point2);
                
                vertexBuffer.put(point1.getXf());
                vertexBuffer.put(point1.getYf());
                vertexBuffer.put(point1.getZf());
                
                vertexBuffer.put(point2.getXf());
                vertexBuffer.put(point2.getYf());
                vertexBuffer.put(point2.getZf());


                point1.subtract(startPoint,normal);


                normalBuffer.put(normal.getXf());
                normalBuffer.put(normal.getYf());
                normalBuffer.put(normal.getZf());


                normalBuffer.put(normal.getXf());
                normalBuffer.put(normal.getYf());
                normalBuffer.put(normal.getZf());
                
                textureCoordBuffer.put(texCoordX);
                textureCoordBuffer.put(0);
                textureCoordBuffer.put(texCoordX);
                textureCoordBuffer.put(1);


                indexBuffer.put(ii + s*2);
                indexBuffer.put(ii + s*2 + 1);
            }
            indexBuffer.put(ii + 0);
            indexBuffer.put(ii + 1);


        }


        //String log = "INDEXBUFFER: ";
        //for (int i=0; i<numOfNonVoxelBranches * (numOfSegments + 1) * 2; i++)
        //    log += ", " + indexBuffer.get(i);
        //VoxelWorld.logger.info(log);
        
            


        meshData.setVertexBuffer(vertexBuffer);
        meshData.setIndexBuffer(indexBuffer);
        
        IndexMode[] indexModes = new IndexMode[numOfNonVoxelBranches];
        int[] indexLengths = new int[numOfNonVoxelBranches];
        
        for (int i = 0; i<numOfNonVoxelBranches; i++ ) {
            indexModes[i] = IndexMode.TriangleStrip;
            indexLengths[i] = (numOfSegments+1)*2;
        }
        
        //meshData.setIndexMode(IndexMode.TriangleStrip);
        meshData.setIndexModes(indexModes);
        meshData.setIndexLengths(indexLengths);
        
        meshData.setTextureBuffer(textureCoordBuffer, 0);
        meshData.setNormalBuffer(normalBuffer);


        
        block.getNonVoxelTreeBranchNode().attachChild(mesh);
    }

View Full Code Here

    public void addModelToScene() {
        
        OctreeRoot octree = block.getOctree();


        Mesh mesh = new Mesh();
        MeshData meshData = mesh.getMeshData();
        int numOfQuads = quads.size();
        int numOfVoxels = voxelCounter;


        FloatBuffer vertexBuffer = BufferUtils.createVector3Buffer(numOfVoxels);
        IntBuffer indexBuffer = BufferUtils.createIntBuffer(numOfQuads * 6);
        FloatBuffer normalBuffer = BufferUtils.createVector3Buffer(numOfVoxels);
        // FloatBuffer texCoordBuffer = BufferUtils.createVector2Buffer(numOfVoxels);
        FloatBuffer colorBuffer  = BufferUtils.createColorBuffer(numOfVoxels);


        ArrayList<Integer> verticesWithGrass = new ArrayList<Integer>();
        
        
        int blockSize = VoxelWorld.BLOCK_SIZE;
        
        for (int x = 0; x < blockSize + 1; x++) {
            for (int y = 0; y < blockSize + 1; y++) {
                for (int z = 0; z < blockSize + 1; z++) {
                    Voxel voxel = voxels[x][y][z];
                    if (voxel != null) {
                        voxel.summarize();
                        
                        octree.insertVertex(x, y, z, voxel.index);
                        
                        int i3 = voxel.index * 3;
                        
                        vertexBuffer.put(i3+0, voxel.vertexPosition.getXf());
                        vertexBuffer.put(i3+1, voxel.vertexPosition.getYf());
                        vertexBuffer.put(i3+2, voxel.vertexPosition.getZf());


                        Vector3 normal = computeVoxelNormal(x,y,z,voxel.vertexPosition);
                        normalBuffer.put(i3+0, normal.getXf());
                        normalBuffer.put(i3+1, normal.getYf());
                        normalBuffer.put(i3+2, normal.getZf());   
                        
                        int i4 = voxel.index * 4;
                        colorBuffer.put(i4+0, voxel.materials.getXf());
                        colorBuffer.put(i4+1, voxel.materials.getYf());
                        colorBuffer.put(i4+2, voxel.materials.getZf());
                        colorBuffer.put(i4+3, voxel.materials.getWf());
                        
                        ///GRASS  
                        if (voxel.vertexPosition.getY() > 33 && voxel.vertexPosition.getYf() < 210 && normal.getY() > 0.7)
                            verticesWithGrass.add(voxel.index);
                    }
                }
            }
        }


        for (int q = 0; q < quads.size(); q++) {
            Quad quad = quads.get(q);


            indexBuffer.put(quad.voxel1.index);
            indexBuffer.put(quad.voxel2.index);
            indexBuffer.put(quad.voxel3.index);
            indexBuffer.put(quad.voxel1.index);
            indexBuffer.put(quad.voxel3.index);
            indexBuffer.put(quad.voxel4.index);
        }


        indexBuffer.rewind();
        //colorBuffer.flip();


        meshData.setVertexBuffer(vertexBuffer);
        meshData.setIndexBuffer(indexBuffer);
        meshData.setNormalBuffer(normalBuffer);
        meshData.setColorBuffer(colorBuffer);




        // meshData.setColorBuffer(colorBuffer);


        block.numOfTriangles = quads.size()*2;
        block.numOfVertices = voxelCounter;


        Vector3 center = basePosition;
        double halfSize = pool.getLevel().getScale() * VoxelWorld.BLOCK_SIZE / 2.0;
        center.addLocal(halfSize, halfSize, halfSize);
        mesh.setModelBound(new BoundingBox(center, halfSize, halfSize, halfSize));


        block.getVoxelNode().attachChild(mesh);
        
        //////////GRASS///////////////////
        if (pool.getLevel().getLevelID() == 0) {
            int numOfGrasses = verticesWithGrass.size();


            Mesh grassMesh = new Mesh();
            MeshData grassMeshData = grassMesh.getMeshData();


            FloatBuffer grassVertexBuffer = BufferUtils.createVector3Buffer(numOfGrasses * 4);
            IntBuffer grassIndexBuffer = BufferUtils.createIntBuffer(numOfGrasses * 6);
            FloatBuffer grassNormalBuffer = BufferUtils.createVector3Buffer(numOfGrasses * 4);
            FloatBuffer grassTexCoordBuffer = BufferUtils.createVector2Buffer(numOfGrasses * 4);
            //FloatBuffer grassBasePositionBuffer = BufferUtils.createVector2Buffer(numOfGrasses * 4);
            for (int i=0, size = verticesWithGrass.size(); i<size; i++) {


                int i3 = verticesWithGrass.get(i) * 3;
                int i4 = i * 4;


                float topY = 2.5f + (float) Math.random();
                float bottomY = -0.1f;
                float halfEidth = 1.5f + (float) Math.random();


                //double alpha = Math.random()*Math.PI;
                //float offsetX = (FastMath.sin(alpha) * halfEidth);
                //float offsetZ = (float)(FastMath.cos(alpha) * halfEidth);
 
                float offsetX = (float)Math.random()-0.5f;
                float offsetZ = (float)Math.random()-0.5f;
 
                grassVertexBuffer.put(vertexBuffer.get(i3 +0) + offsetX);
                grassVertexBuffer.put(vertexBuffer.get(i3 +1) + bottomY);
                grassVertexBuffer.put(vertexBuffer.get(i3 +2) + offsetZ);


                grassVertexBuffer.put(vertexBuffer.get(i3 +0) + offsetX);
                grassVertexBuffer.put(vertexBuffer.get(i3 +1) + topY);
                grassVertexBuffer.put(vertexBuffer.get(i3 +2) + offsetZ);


                grassVertexBuffer.put(vertexBuffer.get(i3 +0) + offsetX);
                grassVertexBuffer.put(vertexBuffer.get(i3 +1) + topY);
                grassVertexBuffer.put(vertexBuffer.get(i3 +2) + offsetZ);


                grassVertexBuffer.put(vertexBuffer.get(i3 +0) + offsetX);
                grassVertexBuffer.put(vertexBuffer.get(i3 +1) + bottomY);
                grassVertexBuffer.put(vertexBuffer.get(i3 +2) + offsetZ);
                
                /*grassVertexBuffer.put(vertexBuffer.get(i3 +0) + offsetX);
                grassVertexBuffer.put(vertexBuffer.get(i3 +1) + bottomY);
                grassVertexBuffer.put(vertexBuffer.get(i3 +2) + offsetZ);


                grassVertexBuffer.put(vertexBuffer.get(i3 +0) + offsetX);
                grassVertexBuffer.put(vertexBuffer.get(i3 +1) + topY);
                grassVertexBuffer.put(vertexBuffer.get(i3 +2) + offsetZ);


                grassVertexBuffer.put(vertexBuffer.get(i3 +0) - offsetX);
                grassVertexBuffer.put(vertexBuffer.get(i3 +1) + topY);
                grassVertexBuffer.put(vertexBuffer.get(i3 +2) - offsetZ);


                grassVertexBuffer.put(vertexBuffer.get(i3 +0) - offsetX);
                grassVertexBuffer.put(vertexBuffer.get(i3 +1) + bottomY);
                grassVertexBuffer.put(vertexBuffer.get(i3 +2) - offsetZ);*/


                float nx = normalBuffer.get(i3 +0);
                float ny = normalBuffer.get(i3 +1);
                float nz = normalBuffer.get(i3 +2);


                grassNormalBuffer.put(nx);
                grassNormalBuffer.put(ny);
                grassNormalBuffer.put(nz);  
                grassNormalBuffer.put(nx);
                grassNormalBuffer.put(ny);
                grassNormalBuffer.put(nz);  
                grassNormalBuffer.put(nx);
                grassNormalBuffer.put(ny);
                grassNormalBuffer.put(nz);  
                grassNormalBuffer.put(nx);
                grassNormalBuffer.put(ny);
                grassNormalBuffer.put(nz);  




                grassTexCoordBuffer.put(0);
                grassTexCoordBuffer.put(0);
                grassTexCoordBuffer.put(0);
                grassTexCoordBuffer.put(1);
                grassTexCoordBuffer.put(1);
                grassTexCoordBuffer.put(1);
                grassTexCoordBuffer.put(1);
                grassTexCoordBuffer.put(0);


                grassIndexBuffer.put(i4);
                grassIndexBuffer.put(i4+1);
                grassIndexBuffer.put(i4+2);
                grassIndexBuffer.put(i4);
                grassIndexBuffer.put(i4+2);
                grassIndexBuffer.put(i4+3);           
            }


            //grassIndexBuffer.rewind();
            //colorBuffer.flip();


            grassMeshData.setVertexBuffer(grassVertexBuffer);
            grassMeshData.setIndexBuffer(grassIndexBuffer);
            grassMeshData.setNormalBuffer(grassNormalBuffer);
            grassMeshData.setTextureBuffer(grassTexCoordBuffer,0);


            grassMesh.setModelBound(new BoundingBox(center, halfSize, halfSize, halfSize));


            block.getGrassNode().attachChild(grassMesh);            
        }

View Full Code Here


            // Walk through our source meshes and populate return MeshData buffers.
            int vertexOffset = 0;
            for (final Mesh mesh : sources) {


                final MeshData md = mesh.getMeshData();


                // Vertices
                md.getVertexBuffer().rewind();
                vertices.getBuffer().put(mesh.getWorldVectors(null));


                // Normals
                if (useNormals) {
                    final FloatBuffer nb = md.getNormalBuffer();
                    if (nb != null) {
                        nb.rewind();
                        normals.getBuffer().put(mesh.getWorldNormals(null));
                    } else {
                        for (int i = 0; i < md.getVertexCount(); i++) {
                            normals.getBuffer().put(DEFAULT_NORMAL);
                        }
                    }
                }


                // Colors
                if (useColors) {
                    final FloatBuffer cb = md.getColorBuffer();
                    if (cb != null) {
                        cb.rewind();
                        colors.getBuffer().put(cb);
                    } else {
                        for (int i = 0; i < md.getVertexCount(); i++) {
                            colors.getBuffer().put(DEFAULT_COLOR);
                        }
                    }
                }


                // Tex Coords
                if (useTextures) {
                    for (int i = 0; i < maxTextures; i++) {
                        final FloatBuffer dest = texCoordsList.get(i).getBuffer();
                        final FloatBuffer tb = md.getTextureBuffer(i);
                        if (tb != null) {
                            tb.rewind();
                            dest.put(tb);
                        } else {
                            for (int j = 0; j < md.getVertexCount() * texCoords; j++) {
                                dest.put(DEFAULT_TEXCOORD);
                            }
                        }
                    }
                }


                // Indices
                if (useIndices) {
                    iCombiner.addEntry(md, vertexOffset);
                    vertexOffset += md.getVertexCount();
                }
            }


            // Apply our index combiner to the mesh
            if (useIndices) {

View Full Code Here

            sources.add(mesh);


            // update world transforms
            mesh.updateWorldTransform(false);


            final MeshData md = mesh.getMeshData();
            if (first) {
                // copy info from first mesh
                vertCoords = md.getVertexCoords().getValuesPerTuple();
                volumeType = mesh.getModelBound(null);
                states = mesh.getLocalRenderStates();
                first = false;
            } else if (vertCoords != md.getVertexCoords().getValuesPerTuple()) {
                throw new IllegalArgumentException("all MeshData vertex coords must use same tuple size.");
            }


            // update total vertices
            totalVertices += md.getVertexCount();


            // check for indices
            if (useIndices || md.getIndices() != null) {
                useIndices = true;
                if (md.getIndices() != null) {
                    totalIndices += md.getIndices().capacity();
                } else {
                    totalIndices += md.getVertexCount();
                }
            } else {
                mode = md.getIndexMode(0);
            }


            // check for normals
            if (!useNormals && md.getNormalBuffer() != null) {
                useNormals = true;
            }


            // check for colors
            if (!useColors && md.getColorBuffer() != null) {
                useColors = true;
            }


            // check for texcoord usage
            if (md.getNumberOfUnits() > 0) {
                if (!useTextures) {
                    useTextures = true;
                    texCoords = md.getTextureCoords(0).getValuesPerTuple();
                } else if (md.getTextureCoords(0) != null && texCoords != md.getTextureCoords(0).getValuesPerTuple()) {
                    throw new IllegalArgumentException("all MeshData objects with texcoords must use same tuple size.");
                }
                maxTextures = Math.max(maxTextures, md.getNumberOfUnits());
            }
        }

View Full Code Here


        // both are leaves
        final ReadOnlyTransform transformA = getMesh().getWorldTransform();
        final ReadOnlyTransform transformB = collisionTree.getMesh().getWorldTransform();


        final MeshData dataA = getMesh().getMeshData();
        final MeshData dataB = collisionTree.getMesh().getMeshData();


        Vector3[] storeA = null;
        Vector3[] storeB = null;


        // for every primitive to compare, put them into world space and check for intersections
        for (int i = _start; i < _end; i++) {
            storeA = dataA.getPrimitiveVertices(_primitiveIndices[i], _section, storeA);
            // to world space
            for (int t = 0; t < storeA.length; t++) {
                transformA.applyForward(storeA[t]);
            }
            for (int j = collisionTree._start; j < collisionTree._end; j++) {
                storeB = dataB.getPrimitiveVertices(collisionTree._primitiveIndices[j], collisionTree._section, storeB);
                // to world space
                for (int t = 0; t < storeB.length; t++) {
                    transformB.applyForward(storeB[t]);
                }
                if (Intersection.intersection(storeA, storeB)) {

View Full Code Here

        // switch to checking the contained primitives with each other. Any
        // that are found to intersect are placed in the appropriate list.
        final ReadOnlyTransform transformA = getMesh().getWorldTransform();
        final ReadOnlyTransform transformB = collisionTree.getMesh().getWorldTransform();


        final MeshData dataA = getMesh().getMeshData();
        final MeshData dataB = collisionTree.getMesh().getMeshData();


        Vector3[] storeA = null;
        Vector3[] storeB = null;


        boolean test = false;


        for (int i = _start; i < _end; i++) {
            storeA = dataA.getPrimitiveVertices(_primitiveIndices[i], _section, storeA);
            // to world space
            for (int t = 0; t < storeA.length; t++) {
                transformA.applyForward(storeA[t]);
            }
            for (int j = collisionTree._start; j < collisionTree._end; j++) {
                storeB = dataB.getPrimitiveVertices(collisionTree._primitiveIndices[j], collisionTree._section, storeB);
                // to world space
                for (int t = 0; t < storeB.length; t++) {
                    transformB.applyForward(storeB[t]);
                }
                if (Intersection.intersection(storeA, storeB)) {

View Full Code Here

            _right.intersect(ray, result);
        } else if (_left == null) {
            // This is a leaf node. We can therefore check each primitive this node contains. If an intersection occurs,
            // place it in the list.


            final MeshData data = getMesh().getMeshData();
            final ReadOnlyTransform transform = getMesh().getWorldTransform();


            Vector3[] points = null;
            for (int i = _start; i < _end; i++) {
                points = data.getPrimitiveVertices(_primitiveIndices[i], _section, points);
                for (int t = 0; t < points.length; t++) {
                    transform.applyForward(points[t]);
                }
                if (ray.intersects(points, null)) {
                    result.add(new PrimitiveKey(_primitiveIndices[i], _section));

View Full Code Here

            verts.add(yOffset + height);
            verts.add(0f);


            yOffset += height;
        }
        final MeshData mData = _standin.getMeshData();
        mData.setVertexBuffer(BufferUtils.createVector3Buffer(mData.getVertexBuffer(), verts.size()));
        final FloatBuffer vertBuffer = mData.getVertexBuffer();
        for (final float f : verts) {
            vertBuffer.put(f);
        }
    }

View Full Code Here

        _standin.render(renderer);
    }


    protected Mesh createSelectionMesh() {
        final Mesh mesh = new Mesh("selectionMesh");
        final MeshData mData = mesh.getMeshData();
        mData.setVertexBuffer(BufferUtils.createVector3Buffer(6));
        mData.setIndexMode(IndexMode.Triangles);


        final BlendState blend = new BlendState();
        blend.setBlendEnabled(true);
        blend.setSourceFunction(SourceFunction.SourceAlpha);
        blend.setDestinationFunction(DestinationFunction.OneMinusSourceAlpha);

View Full Code Here

0 1 2

TOP

Related Classes of com.ardor3d.scenegraph.MeshData

com.ardor3d.bounding.CollisionTree

com.ardor3d.example.collision.CollisionTreeExample

com.ardor3d.example.pipeline.ExportImportExample

com.ardor3d.example.renderer.DegenerateTrianglesExample

com.ardor3d.example.renderer.MultiStripExample

com.ardor3d.extension.effect.particle.ParticleController

com.ardor3d.extension.effect.particle.ParticleMesh

com.ardor3d.extension.effect.particle.ParticleSystem

com.ardor3d.extension.model.collada.jdom.ColladaAnimUtils

com.ardor3d.extension.model.md2.Md2Importer

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.