How to use

JavaFXMeshBuilder

in

us.ihmc.javaFXToolkit.shapes

private void processCollisions(List<Point3D> collisions)
{
 JavaFXMeshBuilder meshBuilder = new JavaFXMeshBuilder();
 for (Point3D collision : collisions)
   meshBuilder.addTetrahedron(COLLISION_SIZE, collision);
 MeshView meshView = new MeshView(meshBuilder.generateMesh());
 meshView.setMaterial(new PhongMaterial(Color.RED));
 collisionGraphics.set(meshView);
}

/**
* Clears the meshes contained in this builder.
*/
public void clear()
{
 meshBuilder.clear();
}

/**
* Translates then combines the given mesh with the mesh contained in this builder.
* @param meshDataHolder the mesh to translate and combine. Not Modified.
* @param offset the translation to apply to the given mesh. Not modified.
* @param color color of the given mesh. Color accuracy depends on the color palette in use.
*/
public void addMesh(MeshDataHolder meshDataHolder, Tuple3DReadOnly offset, Color color)
{
 meshBuilder.addMesh(setColor(meshDataHolder, color), offset);
}

  private void addCones(JavaFXMeshBuilder meshBuilder)
  {
   Point3d conePosition = new Point3d(0.4, 0.0, 0.0);
   double height = 0.3;
   double radius = 0.1;
   meshBuilder.addCone(height, radius, conePosition);
//      meshBuilder.addMesh(MeshDataGenerator.ArcTorus(0.0, 2.0 * Math.PI, 0.3, 0.01, 128));
   meshBuilder.addMesh(MeshDataGenerator.Cone(height, radius, 64));
  }

  private void addCylinders(JavaFXMeshBuilder meshBuilder)
  {
   Point3d cylinderPosition = new Point3d(1.0, 0.0, 0.0);
   double height = 0.3;
   double radius = 0.1;
   meshBuilder.addCylinder(height, radius, cylinderPosition);
//      meshBuilder.addMesh(MeshDataGenerator.ArcTorus(0.0, 2.0 * Math.PI, 0.3, 0.01, 128));
   meshBuilder.addMesh(MeshDataGenerator.Cylinder(radius, height, 64));
  }

private void processMap(VisibilityMapHolder visibilityMapHolder)
{
 JavaFXMeshBuilder meshBuilder = new JavaFXMeshBuilder();
 for (Connection connection : visibilityMapHolder.getVisibilityMapInWorld())
   meshBuilder.addLine(connection.getSourcePoint(), connection.getTargetPoint(), VisualizationParameters.INTER_REGION_CONNECTIVITY_LINE_THICKNESS);
 MeshView meshView = new MeshView(meshBuilder.generateMesh());
 if (customMaterial != null)
   meshView.setMaterial(customMaterial);
 else
   meshView.setMaterial(new PhongMaterial(PlanarRegionViewer.getRegionColor(visibilityMapHolder.getMapId())));
 mapToRender.set(meshView);
}

@Override
public void run()
{
 LineSegment3DMessage[] newMessage = intersectionsMessage.getAndSet(null);
 // Reset both clears by using only one pipe
 if (clearOcTree.getAndSet(false) | clear.getAndSet(false))
 {
   meshAndMaterialToRender.set(new Pair<>(null, null));
   return;
 }
 if (!enable.get())
   return;
 uiMessager.submitStateRequestToModule(REAModuleAPI.RequestPlanarRegionsIntersections);
 if (newMessage == null)
   return;
 meshBuilder.clear();
 for (LineSegment3DMessage intersection : newMessage)
 {
   Point3D32 start = intersection.getStart();
   Point3D32 end = intersection.getEnd();
   float lineWidth = 0.01f;
   meshBuilder.addLine(start, end, lineWidth);
 }
 meshAndMaterialToRender.set(new Pair<Mesh, Material>(meshBuilder.generateMesh(), material));
}

@Override
public void run()
{
 NormalOcTreeMessage newBufferState = bufferState.getAndSet(null);
 if (!showBuffer.get())
 {
   if (hasClearedBufferGraphics)
    return;
   bufferMeshBuilder.clear();
   meshAndMaterialToRender.set(new Pair<>(null, null));
   hasClearedBufferGraphics = true;
   return;
 }
 uiMessager.submitStateRequestToModule(REAModuleAPI.RequestBuffer);
 bufferMeshBuilder.clear();
 if (newBufferState == null)
   return;
 UIOcTree uiOcTree = new UIOcTree(newBufferState);
 for (UIOcTreeNode uiOcTreeNode : uiOcTree)
 {
   Point3D nodeCenter = new Point3D(uiOcTreeNode.getX(), uiOcTreeNode.getY(), uiOcTreeNode.getZ());
   bufferMeshBuilder.addTetrahedron(NODE_SCALE * uiOcTreeNode.getSize(), nodeCenter);
 }
 meshAndMaterialToRender.set(new Pair<>(bufferMeshBuilder.generateMesh(), bufferMaterial));
 hasClearedBufferGraphics = false;
}

private void buildMeshAndMaterial(PlanarRegionsList planarRegionsList)
{
 if (VERBOSE)
   PrintTools.info(this, "Creating mesh and material for new planar regions.");
 RigidBodyTransform transformToWorld = new RigidBodyTransform();
 List<MeshView> regionMeshViews = new ArrayList<>();
 for (int regionIndex = 0; regionIndex < planarRegionsList.getNumberOfPlanarRegions(); regionIndex++)
 {
   JavaFXMeshBuilder meshBuilder = new JavaFXMeshBuilder();
   PlanarRegion planarRegion = planarRegionsList.getPlanarRegion(regionIndex);
   int regionId = planarRegion.getRegionId();
   planarRegion.getTransformToWorld(transformToWorld);
   meshBuilder.addMultiLine(transformToWorld, Arrays.asList(planarRegion.getConcaveHull()), VisualizationParameters.CONCAVEHULL_LINE_THICKNESS, true);
   for (int polygonIndex = 0; polygonIndex < planarRegion.getNumberOfConvexPolygons(); polygonIndex++)
   {
    ConvexPolygon2D convexPolygon2d = planarRegion.getConvexPolygon(polygonIndex);
    meshBuilder.addPolygon(transformToWorld, convexPolygon2d);
   }
   MeshView regionMeshView = new MeshView(meshBuilder.generateMesh());
   regionMeshView.setMaterial(new PhongMaterial(getRegionColor(regionId)));
   regionMeshViews.add(regionMeshView);
 }
 graphicsToRender.set(regionMeshViews);
}

private Node createConcavePocketsGraphics(PlanarRegionSegmentationRawData rawData, ConcaveHullFactoryResult concaveHullFactoryResult)
{
 JavaFXMeshBuilder meshBuilder = new JavaFXMeshBuilder();
 ConcaveHullCollection concaveHullCollection = concaveHullFactoryResult.getConcaveHullCollection();
 RigidBodyTransform transform = rawData.getTransformFromLocalToWorld();
 for (ConcaveHull concaveHull : concaveHullCollection)
 {
   Set<ConcaveHullPocket> pockets = concaveHull.findConcaveHullPockets(polygonizerParameters.getDepthThreshold());
   for (ConcaveHullPocket pocket : pockets)
   {
    List<Point2D> pocketVertices = ListWrappingIndexTools.subListInclusive(pocket.getStartBridgeIndex(), pocket.getEndBridgeIndex(),
                                        concaveHull.getConcaveHullVertices());
    Point2D average = new Point2D();
    average.interpolate(pocket.getStartBridgeVertex(), pocket.getEndBridgeVertex(), 0.5);
    pocketVertices.add(0, average);
    ConcaveHullTools.ensureClockwiseOrdering(pocketVertices);
    meshBuilder.addPolygon(transform, pocketVertices);
   }
 }
 MeshView meshView = new MeshView(meshBuilder.generateMesh());
 meshView.setMaterial(new PhongMaterial(OcTreeMeshBuilder.getRegionColor(rawData.getRegionId())));
 return meshView;
}

   rawPointsMeshBuilder.addTetrahedron(VisualizationParameters.CLUSTER_RAWPOINT_SIZE, rawPoint);
 navigableExtrusionsMeshBuilder
    .addMultiLine(cluster.getNavigableExtrusionsInWorld(), VisualizationParameters.NAVIGABLECLUSTER_LINE_THICKNESS, false);
 nonNavigableExtrusionsMeshBuilder
    .addMultiLine(cluster.getNonNavigableExtrusionsInWorld(), VisualizationParameters.NON_NAVIGABLECLUSTER_LINE_THICKNESS, false);
MeshView rawPointsMeshView = new MeshView(rawPointsMeshBuilders.get(id).generateMesh());
rawPointsMeshView.setMaterial(nonNavigableMaterials.get(id));
rawPointsMapToRender.put(id, rawPointsMeshView);
MeshView navigableExtrusionsMeshView = new MeshView(navigableExtrusionsMeshBuilders.get(id).generateMesh());
navigableExtrusionsMeshView.setMaterial(navigableMaterials.get(id));
navigableExtrusionsMapToRender.put(id, navigableExtrusionsMeshView);
MeshView nonNavigableExtrusionsMeshView = new MeshView(nonNavigableExtrusionsMeshBuilders.get(id).generateMesh());
nonNavigableExtrusionsMeshView.setMaterial(nonNavigableMaterials.get(id));
nonNavigableExtrusionsMapToRender.put(id, nonNavigableExtrusionsMeshView);

private Node createBorderVerticesGraphics(PlanarRegionSegmentationRawData rawData, ConcaveHullFactoryResult concaveHullFactoryResult)
{
 JavaFXMeshBuilder meshBuilder = new JavaFXMeshBuilder();
 Point3D planeOrigin = rawData.getOrigin();
 Quaternion planeOrientation = rawData.getOrientation();
 for (ConcaveHullVariables intermediateVariables : concaveHullFactoryResult.getIntermediateVariables())
 {
   for (Vertex vertex2d : intermediateVariables.getBorderVertices())
   {
    Point3D vertex3d = PolygonizerTools.toPointInWorld(vertex2d.getX(), vertex2d.getY(), planeOrigin, planeOrientation);
    meshBuilder.addSphere(0.003, vertex3d);
   }
 }
 MeshView meshView = new MeshView(meshBuilder.generateMesh());
 meshView.setMaterial(new PhongMaterial(OcTreeMeshBuilder.getRegionColor(rawData.getRegionId())));
 meshView.setMouseTransparent(true);
 return meshView;
}

palette.setHueBased(0.9, 0.8);
JavaFXMultiColorMeshBuilder occupiedMeshBuilder = new JavaFXMultiColorMeshBuilder(palette);
JavaFXMeshBuilder freeMeshBuilder = new JavaFXMeshBuilder();
   freeMeshBuilder.addCube((float) boxSize, new Point3D32(nodeCenter));
  freeMeshView.setMesh(freeMeshBuilder.generateMesh());
  PhongMaterial material = new PhongMaterial();
  material.setDiffuseColor(FREE_COLOR);

view3dFactory.addWorldCoordinateSystem(0.3);
JavaFXMeshBuilder meshBuilder = new JavaFXMeshBuilder();
switch (MESH_TO_DISPLAY)
MeshView meshView = new MeshView(meshBuilder.generateMesh());
PhongMaterial material = new PhongMaterial();
material.setDiffuseColor(Color.CYAN);

/**
* @return the resulting JavaFX {@link Mesh}. 
*/
public Mesh generateMesh()
{
 return meshBuilder.generateMesh();
}

private JavaFXMeshBuilder getOrCreate(Map<Integer, JavaFXMeshBuilder> meshBuilders, int regionId)
{
 JavaFXMeshBuilder meshBuilder = meshBuilders.get(regionId);
 if (meshBuilder == null)
 {
   meshBuilder = new JavaFXMeshBuilder();
   meshBuilders.put(regionId, meshBuilder);
 }
 return meshBuilder;
}

private void addLines(JavaFXMeshBuilder meshBuilder)
{
 Point3d start = new Point3d(0.3, 0.0, -0.);
 Point3d end = new Point3d(0.0, 0.3, 0.0);
 double lineWidth = 0.01;
 meshBuilder.addLine(start, end, lineWidth);
}

/**
* @return the resulting mesh as an immutable mesh ready to be interpreted by the adequate mesh data interpreter. 
*/
public MeshDataHolder generateMeshDataHolder()
{
 return meshBuilder.generateMeshDataHolder();
}

if (meshBuilder == null)
 meshBuilder = new JavaFXMeshBuilder();
 meshBuilders.put(regionId, meshBuilder);
 meshBuilder.addLine(edgeSource, edgeTarget, VisualizationParameters.VISBILITYMAP_LINE_THICKNESS);
MeshView meshView = new MeshView(meshBuilders.get(id).generateMesh());
meshView.setMaterial(materials.get(id));
regionVisMapToRender.put(id, meshView);

/**
* @return the resulting JavaFX {@link Mesh}. 
*/
public Mesh generateMesh()
{
 return meshBuilder.generateMesh();
}