Package com.ardor3d.scenegraph

Examples of com.ardor3d.scenegraph.Mesh


        // draw
        _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);
        mesh.setRenderState(blend);
        mesh.updateWorldRenderStates(false);
        mesh.setDefaultColor(ColorRGBA.LIGHT_GRAY);

        return mesh;
    }
View Full Code Here


        // draw mesh
        SubTexUtil._mesh.render(renderer);
    }

    private static Mesh createMesh() {
        final Mesh mesh = new Mesh();
        mesh.getMeshData().setVertexCoords(new FloatBufferData(BufferUtils.createVector2Buffer(4), 2));
        mesh.getMeshData().setTextureBuffer(BufferUtils.createVector2Buffer(4), 0);
        mesh.getMeshData().setIndexMode(IndexMode.TriangleFan);

        mesh.setRenderState(SubTexUtil._tstate);

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

        mesh.updateWorldRenderStates(false);

        return mesh;
    }
View Full Code Here

        }
        if (newEndTime < 0 || newEndTime > _keyframes.get(_keyframes.size() - 1)._time) {
            KeyframeController.logger.warning("Attempt to set invalid endtime:" + newEndTime);
            return;
        }
        Mesh begin = null, end = null;
        if (_prevKeyframes == null) {
            _prevKeyframes = new ArrayList<PointInTime>();
            begin = new Mesh();
            end = new Mesh();
        } else {
            begin = _prevKeyframes.get(0)._newShape;
            end = _prevKeyframes.get(1)._newShape;
            _prevKeyframes.clear();
        }
View Full Code Here

        } else {
            // general case
            delta = (clampedCurTime - _before._time) / (_after._time - _before._time);
        }

        final Mesh oldShape = _before._newShape;
        final Mesh newShape = _after._newShape;

        final FloatBuffer verts = _morphMesh.getMeshData().getVertexBuffer();
        final FloatBuffer norms = _morphMesh.getMeshData().getNormalBuffer();
        final FloatBuffer texts = _interpTex ? _morphMesh.getMeshData().getTextureCoords(0) != null ? _morphMesh
                .getMeshData().getTextureCoords(0).getBuffer() : null : null;
        final FloatBuffer colors = _morphMesh.getMeshData().getColorBuffer();

        final FloatBuffer oldverts = oldShape.getMeshData().getVertexBuffer();
        final FloatBuffer oldnorms = oldShape.getMeshData().getNormalBuffer();
        final FloatBuffer oldtexts = _interpTex ? oldShape.getMeshData().getTextureCoords(0) != null ? oldShape
                .getMeshData().getTextureCoords(0).getBuffer() : null : null;
        final FloatBuffer oldcolors = oldShape.getMeshData().getColorBuffer();

        final FloatBuffer newverts = newShape.getMeshData().getVertexBuffer();
        final FloatBuffer newnorms = newShape.getMeshData().getNormalBuffer();
        final FloatBuffer newtexts = _interpTex ? newShape.getMeshData().getTextureCoords(0) != null ? newShape
                .getMeshData().getTextureCoords(0).getBuffer() : null : null;
        final FloatBuffer newcolors = newShape.getMeshData().getColorBuffer();
        if (verts == null || oldverts == null || newverts == null) {
            return;
        }
        final int vertQuantity = verts.capacity() / 3;
        verts.rewind();
View Full Code Here

    }

    @Override
    public void visit(final Spatial spatial) {
        if (spatial instanceof Mesh) {
            final Mesh mesh = (Mesh) spatial;
            final MeshData md = mesh.getMeshData();
            if (md.getTotalPrimitiveCount() < 1 || md.getVertexCount() < 3) {
                return;
            }
            for (final IndexMode mode : md.getIndexModes()) {
                if (mode != IndexMode.Triangles) {
                    return;
                }
            }

            final int[] indices;
            if (md.getIndices() == null) {
                indices = new int[md.getVertexCount()];
                for (int i = 0; i < indices.length; i++) {
                    indices[i] = i;
                }
            } else {
                indices = BufferUtils.getIntArray(md.getIndices());
            }
            PrimitiveGroup[] strips = generateStrips(indices, false);

            if (_reorderVertices) {
                final AtomicReference<int[]> newOrder = new AtomicReference<int[]>();
                strips = remapIndices(strips, newOrder, md.getVertexCount());

                // ask mesh to apply new vertex order
                mesh.reorderVertexData(newOrder.get());
            }

            // construct our new index buffer, modes and counts
            int indexCount = 0, j = 0, count = 0;
            for (final PrimitiveGroup group : strips) {
                if (group.getIndices().length > 0) {
                    count++;
                }
            }
            final int[] counts = new int[count];
            final IndexMode[] modes = new IndexMode[count];
            for (final PrimitiveGroup group : strips) {
                indexCount += group.getIndices().length;
                if (group.getIndices().length > 0) {
                    modes[j] = group.getType();
                    counts[j++] = group.getIndices().length;
                }
            }
            final IndexBufferData<?> newIndices = BufferUtils.createIndexBufferData(indexCount, md.getVertexCount());
            for (final PrimitiveGroup group : strips) {
                final IntBufferData data = new IntBufferData(group.getIndices().length);
                data.getBuffer().put(group.getIndices());
                data.rewind();
                newIndices.put(data);
            }
            newIndices.rewind();

            // ask mesh to apply new index data
            mesh.reorderIndices(newIndices, modes, counts);
        }
    }
View Full Code Here

            final Mesh[] meshes = new Mesh[header.numFrames];
            MeshData mData;
            for (int i = 0; i < header.numFrames; i++) {
                final Md2Frame frame = frames[i];

                meshes[i] = new Mesh(frames[i].name);
                mData = meshes[i].getMeshData();
                mData.setIndexLengths(counts);
                mData.setIndexModes(modes);

                final FloatBufferData verts = new FloatBufferData(vertexCount * 3, 3);
                final FloatBufferData norms = new FloatBufferData(vertexCount * 3, 3);
                final FloatBufferData texs = new FloatBufferData(vertexCount * 3, 2);
                mData.setVertexCoords(verts);
                mData.setNormalCoords(norms);
                mData.setTextureCoords(texs, 0);

                // go through the triangle strips/fans and add them in
                // first the strips
                if (stripIndices.size() != 0) {
                    for (int maxJ = stripIndices.size(), j = 0; j < maxJ; j++) {
                        cmd = commands[stripIndices.get(j)];
                        if (cmd.vertIndices.length < 3) {
                            continue;
                        }

                        addVert(cmd, frame, 0, verts);
                        norms.getBuffer().put(0).put(0).put(0);
                        texs.getBuffer().put(0).put(0);

                        // add strip verts / normals
                        for (int k = 0; k < cmd.vertIndices.length; k++) {
                            addVert(cmd, frame, k, verts);
                            addNormal(cmd, frame, k, norms);
                        }

                        // add strip tex coords
                        texs.getBuffer().put(cmd.texCoords);

                        // if we're not the last strip, add a vert or two for degenerate triangle connector
                        if (j != maxJ - 1) {
                            addVert(cmd, frame, cmd.vertIndices.length - 1, verts);
                            norms.getBuffer().put(0).put(0).put(0);
                            texs.getBuffer().put(0).put(0);
                            if (cmd.vertIndices.length % 2 == 1) {
                                // extra vert to maintain wind order
                                addVert(cmd, frame, cmd.vertIndices.length - 1, verts);
                                norms.getBuffer().put(0).put(0).put(0);
                                texs.getBuffer().put(0).put(0);
                            }
                        }
                    }
                }
                // Now the fans
                // XXX: could add these to the strip instead
                for (final int j : fanIndices) {
                    cmd = commands[j];
                    texs.getBuffer().put(cmd.texCoords[0]).put(cmd.texCoords[1]);
                    addNormal(cmd, frame, 0, norms);
                    addVert(cmd, frame, 0, verts);
                    for (int k = cmd.vertIndices.length; --k >= 1;) {
                        texs.getBuffer().put(cmd.texCoords[k * 2]).put(cmd.texCoords[k * 2 + 1]);
                        addNormal(cmd, frame, k, norms);
                        addVert(cmd, frame, k, verts);
                    }
                }
            }

            // Clone frame 0 as mesh for initial mesh
            final Mesh mesh = meshes[0].makeCopy(false);
            mesh.setModelBound(new BoundingBox());

            // Use resource name for mesh
            mesh.setName(resource.getName());

            // Add controller
            final KeyframeController<Mesh> controller = new KeyframeController<Mesh>();
            mesh.addController(controller);
            controller.setMorphingMesh(mesh);
            controller.setInterpTex(false);
            int i = 0;
            for (final Mesh meshX : meshes) {
                controller.setKeyframe(i, meshX);
                i++;
            }

            // Make a store object to return
            final Md2DataStore store = new Md2DataStore(mesh, controller);

            // store names
            for (final Md2Frame frame : frames) {
                store.getFrameNames().add(frame.name);
            }

            // store skin names
            for (final String name : texNames) {
                store.getSkinNames().add(name);
            }

            // Apply our texture
            if (isLoadTextures()) {
                Texture tex = null;
                for (final String name : texNames) {
                    tex = loadTexture(name);
                    if (tex != null) {
                        break;
                    }
                }

                // try using model name
                if (tex == null) {
                    tex = loadTexture(resource.getName());
                }

                if (tex != null) {
                    final TextureState ts = new TextureState();
                    ts.setTexture(tex);
                    mesh.setRenderState(ts);
                }
            }

            return store;
        } catch (final Exception e) {
View Full Code Here

            String name = _currentObjectName;
            if (name == null) {
                name = "obj_mesh" + _totalMeshes;
            }

            final Mesh mesh = new Mesh(name);

            final FloatBuffer vertices = BufferUtils.createVector3Buffer(_meshManager.getStore().size());
            final FloatBuffer normals = BufferUtils.createFloatBuffer(vertices.capacity());
            final FloatBuffer uvs = BufferUtils.createFloatBuffer(vertices.capacity());
            boolean hasNormals = false, hasUVs = false;

            int j = 0;
            final long[] vertGroups = new long[_meshManager.getStore().size()];
            final List<Long> groups = Lists.newArrayList();
            Vector3 vector;
            for (final ObjIndexSet set : _meshManager.getStore().keySet()) {
                vertGroups[j] = set.getSmoothGroup();
                if (!groups.contains(set.getSmoothGroup())) {
                    groups.add(set.getSmoothGroup());
                }
                vector = _dataStore.getVertices().get(set.getVIndex());
                vertices.put(vector.getXf()).put(vector.getYf()).put(vector.getZf());
                if (set.getVnIndex() >= 0) {
                    vector = _dataStore.getNormals().get(set.getVnIndex());
                    normals.put(vector.getXf()).put(vector.getYf()).put(vector.getZf());
                    hasNormals = true;
                } else if (set.getVnIndex() < -1) {
                    vector = _dataStore.getGeneratedNormals().get(-1 * set.getVnIndex() - 2);
                    normals.put(vector.getXf()).put(vector.getYf()).put(vector.getZf());
                    hasNormals = true;
                }
                if (set.getVtIndex() >= 0) {
                    vector = _dataStore.getUvs().get(set.getVtIndex());
                    // TODO: add 3d tex support?
                    uvs.put(vector.getXf()).put(vector.getYf());
                    hasUVs = true;
                }
                j++;
            }

            mesh.getMeshData().setVertexBuffer(vertices);
            if (hasNormals) {
                mesh.getMeshData().setNormalBuffer(normals);
            }
            if (hasUVs) {
                mesh.getMeshData().setTextureBuffer(uvs, 0);
            }

            final IndexBufferData<? extends Buffer> indexBuffer = BufferUtils.createIndexBufferData(_meshManager
                    .getIndices().size(), _meshManager.getStore().size() - 1);
            for (final int index : _meshManager.getIndices()) {
                indexBuffer.put(index);
            }
            mesh.getMeshData().setIndices(indexBuffer);

            final VertGroupData groupData = new VertGroupData();
            // set all smooth groups to use "blend as long as UVs and SmoothGroup are same".
            for (final long group : groups) {
                groupData.setGroupConditions(group, EnumSet.of(MatchCondition.UVs));
            }
            // set the "no smooth" smooth group to use "blend only if vertex is same". (No color data in obj, so
            // ignoring)
            groupData.setVertGroups(vertGroups);
            groupData.setGroupConditions(VertGroupData.DEFAULT_GROUP,
                    EnumSet.of(MatchCondition.Normal, MatchCondition.UVs));
            GeometryTool.minimizeVerts(mesh, groupData);

            applyCurrentMaterial(mesh);
            mapToGroups(mesh);

            mesh.updateModelBound();

            _root.attachChild(mesh);
            _meshManager = null;
            _totalMeshes++;
        }
View Full Code Here

        final Node scene = new Node();
        scene.getSceneHints().setCullHint(CullHint.Dynamic);
        _root.attachChild(scene);

        // Generate many boxes and place them in a 2D grid pattern, under the origNode.
        Mesh mesh;
        for (int i = 0, max = edge * edge; i < max; i++) {
            mesh = new StripBox("stripbox" + i, new Vector3(), .5, .5, .5);
            mesh.setTranslation(new Vector3(i % edge, i / edge, 0));

            mesh.setModelBound(new BoundingBox());
            mesh.setSolidColor(ColorRGBA.randomColor(null));
            origNode.attachChild(mesh);
        }

        // Create a single Mesh from the origNode and its children.
        final Mesh merged = MeshCombiner.combine(origNode);
        // attach to scene.. default will be to show the merged version first
        scene.attachChild(merged);

        // Use VBO, if indicated. This improves the rendering speed of the merged mesh.
        // Note that sometimes it is not efficient/possible to turn on VBO for tons of small meshes, but works well for
        // a single larger combined mesh.
        if (useVBO) {
            merged.getSceneHints().setDataMode(DataMode.VBO);
        }

        // and a texture, this will cover both the uncombined and combined meshes.
        final TextureState ts = new TextureState();
        ts.setTexture(TextureManager.load("images/ardor3d_white_256.jpg", Texture.MinificationFilter.Trilinear, true));
        scene.setRenderState(ts);

        // set a material state that applies our vertex coloring to the lighting equation
        final MaterialState ms = new MaterialState();
        ms.setColorMaterial(ColorMaterial.AmbientAndDiffuse);
        scene.setRenderState(ms);

        // position our camera to take in all of the mesh
        _canvas.getCanvasRenderer().getCamera().setLocation(edge / 2, edge / 2, 2 * edge);

        // |---------------- UI and control code below... ----------------|
        // Add a trigger on the M key to switch between merged and non-merged
        _logicalLayer.registerTrigger(new InputTrigger(new KeyPressedCondition(Key.M), new TriggerAction() {
            @Override
            public void perform(final Canvas source, final TwoInputStates inputState, final double tpf) {
                showMerged = !showMerged;
                if (showMerged) {
                    origNode.removeFromParent();
                    scene.attachChild(merged);
                } else {
                    merged.removeFromParent();
                    scene.attachChild(origNode);
                }
                updateMergedLabel();
            }
        }));

        // Add a trigger on the V key to toggle VBO use (only on merged mesh)
        _logicalLayer.registerTrigger(new InputTrigger(new KeyPressedCondition(Key.V), new TriggerAction() {
            @Override
            public void perform(final Canvas source, final TwoInputStates inputState, final double tpf) {
                useVBO = !useVBO;
                if (useVBO) {
                    merged.getSceneHints().setDataMode(DataMode.VBO);
                } else {
                    merged.getSceneHints().setDataMode(DataMode.Arrays);
                }
                updateMergedLabel();
            }
        }));

View Full Code Here

        _root.attachChild(n1);

        final Random rand = new Random(1337);
        for (int i = 0; i < 500; i++) {
            final Mesh sm = sphere.makeCopy(true);

            sm.setTranslation(new Vector3(rand.nextDouble() * 100.0 - 50.0, rand.nextDouble() * 100.0 - 50.0, rand
                    .nextDouble() * 100.0 - 50.0));
            n1.attachChild(sm);
        }

        final Node n2 = n1.makeCopy(true);
View Full Code Here

        }));

        // Combine into one mesh
        _logicalLayer.registerTrigger(new InputTrigger(new KeyPressedCondition(Key.G), new TriggerAction() {
            public void perform(final Canvas source, final TwoInputStates inputStates, final double tpf) {
                final Mesh merged = MeshCombiner.combine(boxNode);
                boxNode.detachAllChildren();
                boxNode.attachChild(merged);
            }
        }));
View Full Code Here

TOP

Related Classes of com.ardor3d.scenegraph.Mesh

Copyright © 2018 www.massapicom. All rights reserved.
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.