Lost here, how get indexes and vertexes from trimesh

There is no easy way like getFloatIndexBuffer and getFloatVertexBuffer? I'm lost because i have to instace a for method with vertexCount and batchcount (?) to get one by one.

So, how i really get this list back from my TriMesh?  :stuck_out_tongue: (damn noob  )

This is what I used:



Triangle[] triangles = breakingMesh.getMeshAsTriangles(null);




I'm not sure if it will be useful to you, but here is my attempt at CSG.. My maths is too weak to figure out how two triangles interact and I kind of got bored with tinkering with it. It runs in JME 2.0, but I havent updated svn for a while..


package jmetest.TutorialGuide;

import java.util.ArrayList;

import jmetest.effects.cloth.TestCloth;

import com.jme.app.SimpleGame;
import com.jme.bounding.BoundingBox;
import com.jme.bounding.BoundingSphere;
import com.jme.bounding.BoundingVolume;
import com.jme.bounding.CollisionTree;
import com.jme.bounding.CollisionTreeManager;
import com.jme.bounding.OrientedBoundingBox;
import com.jme.image.Texture;
import com.jme.intersection.CollisionResults;
import com.jme.intersection.TriangleCollisionResults;
import com.jme.math.Triangle;
import com.jme.math.Vector2f;
import com.jme.math.Vector3f;
import com.jme.renderer.ColorRGBA;
import com.jme.renderer.RenderQueue;
import com.jme.renderer.Renderer;
import com.jme.scene.Node;
import com.jme.scene.Spatial;
import com.jme.scene.TexCoords;
import com.jme.scene.TriMesh;
import com.jme.scene.Spatial.CullHint;
import com.jme.scene.shape.Box;
import com.jme.scene.shape.Sphere;
import com.jme.scene.state.TextureState;
import com.jme.util.TextureManager;
import com.jme.util.geom.BufferUtils;
import com.jmex.model.collada.schema.renderType;

public class TryingTriMesh extends SimpleGame {
   
    public static void main(String[] args) {
        TryingTriMesh app = new TryingTriMesh();
        app.setConfigShowMode(ConfigShowMode.AlwaysShow);
        app.start();
    }

    protected void simpleInitGame() {
       
       CollisionTreeManager.getInstance().setTreeType(CollisionTree.Type.OBB);
       
        // TriMesh is what most of what is drawn in jME actually is
        TriMesh box = (TriMesh)new Box("Box", new Vector3f(),10,2,5);
//        Box box2 = new Box("Box", new Vector3f(),10,2,5);
//        box2.hasTriangleCollision(toCheck)
       
       TriMesh sphere = (TriMesh)new Sphere("sphere 1", 10,10,10);
       
       // Create a bounds
//        m.getBinormalBuffer()
       sphere.setModelBound(new BoundingSphere());
       sphere.updateModelBound();
       
        // Create a bounds
        box.setModelBound(new BoundingBox());
        box.updateModelBound();
//        box.setColorBuffer(BufferUtils.createFloatBuffer(new ColorRGBA(1,1,1,0.5f)));
       
//        rootNode.attachChild(box);
//        box.setRenderQueueMode(Renderer.QUEUE_ORTHO);
//       
//        rootNode.attachChild(sphere);
//        sphere.setRenderQueueMode(Renderer.QUEUE_ORTHO);
//        box.setCullHint(CullHint.Always);
//        sphere.setCullHint(CullHint.Always);
       
       
        boolGeom(sphere, box, false, true);
       
        boolGeom(box, sphere, true, false);

        // Let us see the per vertex colors
        lightState.setEnabled(false);
    }
   
    public void boolGeom(TriMesh breakingMesh, TriMesh opposingMesh, boolean keepInsideTris, boolean keepOutsideTris){
       
        Triangle[] triangles = breakingMesh.getMeshAsTriangles(null);
        ArrayList<SubstantialTriangle> subdata = new ArrayList<SubstantialTriangle>();
        for (int i = 0; i< triangles.length; i++){
           subdata.add(new SubstantialTriangle(triangles[i]));
        }
       
        Node holderNode = new Node("mesh");
       
        holderNode.getLocalTranslation().set(breakingMesh.getLocalTranslation());
       
        for (int reduce = 0; reduce<12; reduce++){
           ArrayList<SubstantialTriangle> more = new ArrayList<SubstantialTriangle>();
           
           for (SubstantialTriangle each:subdata){
//              BoundingVolume bv = opposingMesh.getWorldBound();
//               if (bv.contains(each.getData().get(0))||bv.contains(each.getData().get(1))||bv.contains(each.getData().get(2))||bv.contains(each.getData().getCenter())){
              if (each.getMesh().hasTriangleCollision(opposingMesh)){
                 more.add(each.split());
              }
           }
           subdata.addAll(more);
        }
       
        for (SubstantialTriangle each:subdata){
//           CollisionResults coll = new TriangleCollisionResults();
//           each.getMesh().calculateCollisions(opposingMesh, coll);
//           
           // dont show the edge of our objects:
           if (each.getMesh().hasTriangleCollision(opposingMesh)){
              continue;
           }
//           if (opposingMesh.getWorldBound().intersects(each.getMesh().getWorldBound())){
           BoundingVolume bv = opposingMesh.getWorldBound();
           if (bv.contains(each.getData().get(0))||bv.contains(each.getData().get(1))||bv.contains(each.getData().get(2))||bv.contains(each.getData().getCenter())){
              if (keepInsideTris){
                 holderNode.attachChild(each.getMesh());
              }
           }
           else {
              if (keepOutsideTris){
                 holderNode.attachChild(each.getMesh());
              }
           }
        }
       
        rootNode.attachChild(holderNode);
       
       
        TextureState ts = display.getRenderer().createTextureState();
      ts.setTexture(
         TextureManager.loadTexture(
         TestCloth.class.getClassLoader().getResource(
         "jmetest/data/images/Monkey.jpg"),
         Texture.MinificationFilter.Trilinear,
         Texture.MagnificationFilter.Bilinear));
       
        holderNode.setRenderState(ts);
    }

   
    public class SubstantialTriangle {
       
       private TriMesh mesh;
       private Triangle t1;
       
       public SubstantialTriangle(Triangle t1){
          updateTriangle(t1);
       }
       
       public void updateTriangle(Triangle t){
          t1 = t;
          regenerateMesh();
       }
       
       public void regenerateMesh(){
          mesh = new TriMesh("Triangle");

          Vector3f[] verts = new Vector3f[] {
                t1.get(0),
                t1.get(1),
                t1.get(2),
          };

          int[] inds = new int[] { 0, 1, 2};

          mesh.setMode(TriMesh.Mode.Strip);
          mesh.setVertexBuffer(BufferUtils.createFloatBuffer(verts));
          mesh.setIndexBuffer(BufferUtils.createIntBuffer(inds));
          Vector2f[] texCoords={
                   new Vector2f(0,1),
                   new Vector2f(.5f,0),
                   new Vector2f(1,1),
               };
          mesh.setTextureCoords(TexCoords.makeNew(texCoords));
          
          t1.calculateNormal();
          Vector3f[] normals={
                   t1.getNormal(),
                   t1.getNormal(),
                   t1.getNormal()
               };
          
          mesh.setNormalBuffer(BufferUtils.createFloatBuffer(normals));
          mesh.setModelBound(new OrientedBoundingBox());
          mesh.updateModelBound();
       }
       
       public TriMesh getMesh(){
          return mesh;
       }
       
       public Triangle getData(){
          return t1;
       }
       
       public SubstantialTriangle split(){
          Vector3f[][] array = {{t1.get(0), t1.get(1)},
                         {t1.get(1), t1.get(2)},
                         {t1.get(0), t1.get(2)}};
          Vector3f[] complement = {t1.get(2), t1.get(0), t1.get(1)};
          int selected = 0;
          float distance = array[0][0].distance(array[0][1]);
          for (int a = 1; a<3; a++){
             float attemptDistance = array[a][0].distance(array[a][1]);
             if (attemptDistance > distance){
                distance = attemptDistance;
                selected = a;
             }
          }
          Vector3f midpoint = new Vector3f();
          midpoint.interpolate(array[selected][0], array[selected][1], .5f);
          Triangle dupe = new Triangle(array[selected][0].clone(), complement[selected].clone(), midpoint.clone());
          Triangle replace = new Triangle(array[selected][1].clone(), complement[selected].clone(), midpoint.clone());
          updateTriangle(replace);
          return new SubstantialTriangle(dupe);
       }
    }
   
}