javafx.scene.paint.PhongMaterial Java Examples

private void buildAxes(Group world) {
    PhongMaterial redMaterial = new PhongMaterial();
    redMaterial.setDiffuseColor(Color.DARKRED);
    redMaterial.setSpecularColor(Color.RED);
    PhongMaterial greenMaterial = new PhongMaterial();
    greenMaterial.setDiffuseColor(Color.DARKGREEN);
    greenMaterial.setSpecularColor(Color.GREEN);
    PhongMaterial blueMaterial = new PhongMaterial();
    blueMaterial.setDiffuseColor(Color.DARKBLUE);
    blueMaterial.setSpecularColor(Color.BLUE);

    Box xAxis = new Box(AXES_SIZE, 1, 1);
    xAxis.setMaterial(redMaterial);
    Box yAxis = new Box(1, AXES_SIZE, 1);
    yAxis.setMaterial(greenMaterial);
    Box zAxis = new Box(1, 1, AXES_SIZE);
    zAxis.setMaterial(blueMaterial);

    Group group = new Group();
    group.getChildren().addAll(xAxis, yAxis, zAxis);
    group.setVisible(true);
    world.getChildren().addAll(group);
    group.visibleProperty().bind(checkBoxAxes.selectedProperty());
}
 

private static MeshView makeMeshView(final PainteraTriangleMesh verticesAndNormals)
{
	final float[]      vertices = verticesAndNormals.getVertices();
	final float[]      normals  = verticesAndNormals.getNormals();
	final TriangleMesh mesh     = new TriangleMesh();
	mesh.getPoints().addAll(vertices);
	mesh.getNormals().addAll(normals);
	mesh.getTexCoords().addAll(0, 0);
	mesh.setVertexFormat(VertexFormat.POINT_NORMAL_TEXCOORD);
	final int[] faceIndices = new int[vertices.length];
	for (int i = 0, k = 0; i < faceIndices.length; i += 3, ++k)
	{
		faceIndices[i + 0] = k;
		faceIndices[i + 1] = k;
		faceIndices[i + 2] = 0;
	}
	mesh.getFaces().addAll(faceIndices);
	final PhongMaterial material = Meshes.painteraPhongMaterial();
	final MeshView mv = new MeshView(mesh);
	mv.setOpacity(1.0);
	mv.setCullFace(CullFace.FRONT);
	mv.setMaterial(material);
	mv.setDrawMode(DrawMode.FILL);
	return mv;
}
 

public void setXYZData(List<Double> xData, List<Double> yData, List<Double> zData, List<Color> colors) {
    xAxisData = xData;
    yAxisData = yData;
    zAxisData = zData;
    scatterDataGroup.getChildren().clear();
    //for now we will always default to x axis
    //later we could maybe dynamically determine the smallest axis and then
    //uses 0's for the other axes that are larger.
    for(int i=0;i<xAxisData.size();i++) {
        final Shape3D dataSphere = createDefaultNode(nodeRadius);
        double translateY = 0.0;
        double translateZ = 0.0;            
        if(!yAxisData.isEmpty() && yAxisData.size() > i)
            translateY = yAxisData.get(i);
        if(!zAxisData.isEmpty() && zAxisData.size() > i)
            translateZ = zAxisData.get(i);
        dataSphere.setTranslateX(xAxisData.get(i));
        dataSphere.setTranslateY(translateY);
        dataSphere.setTranslateZ(translateZ);
        dataSphere.setMaterial(new PhongMaterial(colors.get(i)));
        scatterDataGroup.getChildren().add(dataSphere);
    }        
}
 

private void buildSphereGroup() {

        final PhongMaterial material = new PhongMaterial();

        material.setDiffuseColor(Color.WHITE);//TRANSPARENT);//BROWN);
        material.diffuseMapProperty().bind(Bindings.when(diffuseMap).then(dImage).otherwise((Image) null));
        material.bumpMapProperty().bind(Bindings.when(bumpMap).then(nImage).otherwise((Image) null));
        material.setSpecularColor(Color.LIGHTGRAY);
        //material.selfIlluminationMapProperty().bind(Bindings.when(selfIlluminationMap).then(siImage).otherwise((Image) null));

        Xform marsXform = new Xform();
        Sphere mars = new Sphere(300.0);
        mars.setMaterial(material);
        marsXform.getChildren().add(mars);
        sphereGroup.getChildren().add(marsXform);

        world.getChildren().addAll(sphereGroup);//, ambientXform);
    }
 

public static PhongMaterial getMaterial(String face){
    PhongMaterial arrowMat = new PhongMaterial();
    arrowMat.setSpecularColor(Color.WHITESMOKE);
    Color color=Color.WHITE;
    switch(face){
        case "F": 
        case "Fi":  color=Color.BLUE.brighter();
                    break;
        case "B": 
        case "Bi":  color=Color.BLUE.brighter();
                    break;
        case "R":  
        case "Ri":  color=Color.RED.brighter();
                    break;
        case "L":  
        case "Li":  color=Color.RED.brighter();
                    break;
        case "U":   
        case "Ui":  color=Color.FORESTGREEN.brighter();
                    break;
        case "D": 
        case "Di":  color=Color.FORESTGREEN.brighter();
                    break;
        case "Z": 
        case "Zi":  color=Color.BLUE.brighter();
                    break;
        case "X":  
        case "Xi":  color=Color.RED.brighter();
                    break;
        case "Y":   
        case "Yi":  color=Color.FORESTGREEN.brighter();
                    break;
    }
    arrowMat.setDiffuseColor(color);
    return arrowMat;
}
 

private void buildAxes() {
    double length = 2d*dimModel;
    double width = dimModel/100d;
    double radius = 2d*dimModel/100d;
    final PhongMaterial redMaterial = new PhongMaterial();
    redMaterial.setDiffuseColor(Color.DARKRED);
    redMaterial.setSpecularColor(Color.RED);
    final PhongMaterial greenMaterial = new PhongMaterial();
    greenMaterial.setDiffuseColor(Color.DARKGREEN);
    greenMaterial.setSpecularColor(Color.GREEN);
    final PhongMaterial blueMaterial = new PhongMaterial();
    blueMaterial.setDiffuseColor(Color.DARKBLUE);
    blueMaterial.setSpecularColor(Color.BLUE);
    
    Sphere xSphere = new Sphere(radius);
    Sphere ySphere = new Sphere(radius);
    Sphere zSphere = new Sphere(radius);
    xSphere.setMaterial(redMaterial);
    ySphere.setMaterial(greenMaterial);
    zSphere.setMaterial(blueMaterial);
    
    xSphere.setTranslateX(dimModel);
    ySphere.setTranslateY(dimModel);
    zSphere.setTranslateZ(dimModel);
    
    Box xAxis = new Box(length, width, width);
    Box yAxis = new Box(width, length, width);
    Box zAxis = new Box(width, width, length);
    xAxis.setMaterial(redMaterial);
    yAxis.setMaterial(greenMaterial);
    zAxis.setMaterial(blueMaterial);
    
    autoScalingGroup.getChildren().addAll(xAxis, yAxis, zAxis);
    autoScalingGroup.getChildren().addAll(xSphere, ySphere, zSphere);
}
 

public Axes(double scale) {
    axisX.getTransforms().addAll(new Rotate(90, Rotate.Z_AXIS), new Translate(0, 30, 0));
    axisX.setMaterial(new PhongMaterial(Color.RED));
    axisY.getTransforms().add(new Translate(0, 30, 0));
    axisY.setMaterial(new PhongMaterial(Color.GREEN));
    axisZ.setMaterial(new PhongMaterial(Color.BLUE));
    axisZ.getTransforms().addAll(new Rotate(90, Rotate.X_AXIS), new Translate(0, 30, 0));
    getChildren().addAll(axisX, axisY, axisZ);
    getTransforms().add(new Scale(scale, scale, scale));
}
 

private void clearMaterialAndSetColor(PhongMaterial mat, Color col){
    mat.setBumpMap(null);
    mat.setSpecularMap(null);
    mat.setSelfIlluminationMap(null);
    mat.setDiffuseMap(null);
    
    mat.setDiffuseColor(col);
}
 

private void clearMaterialAndSetDiffMap(PhongMaterial mat, Image diff){
    mat.setBumpMap(null);
    mat.setSpecularMap(null);
    mat.setSelfIlluminationMap(null);
    
    mat.setDiffuseColor(DEFAULT_DIFFUSE_COLOR);
    mat.setSpecularColor(DEFAULT_SPECULAR_COLOR);
    
    mat.setDiffuseMap(diff);        
}
 

public Material getMaterialWithColor(Color color, String image){
        PhongMaterial mat = new PhongMaterial(color);
        if(image!=null && !image.isEmpty()){
            Image img = new Image(image);
            mat.setDiffuseMap(img);
            NormalMap normal = new NormalMap(img);
//            normal.setIntensity(10);
//            normal.setIntensityScale(2);
            mat.setBumpMap(normal);
        }
        mat.setSpecularPower(32);
        mat.setSpecularColor(Color.WHITE);
        return mat;
    }
 

public ShapeContainer(T shape) {
    this.shape = shape;
    this.material = new PhongMaterial();
    this.emissive = new PointLight();
    this.selfIllumination = new AmbientLight();
    
    this.selfIllumination.getScope().add(ShapeContainer.this);
    initialize();
}
 

private Group buildScene() {
	    Sphere mars = new Sphere(MARS_RADIUS);
	    mars.setTranslateX(VIEWPORT_SIZE / 2d);
	    mars.setTranslateY(VIEWPORT_SIZE / 2d);

	    PhongMaterial material = new PhongMaterial();
	    material.setDiffuseMap(
	      new Image(this.getClass().getResource(DIFFUSE_MAP).toExternalForm(),
	        MAP_WIDTH,
	        MAP_HEIGHT,
	        true,
	        true
	      )
	    );

	    material.setBumpMap(
	      new Image(this.getClass().getResource(NORMAL_MAP).toExternalForm(),
	        MAP_WIDTH,
	        MAP_HEIGHT,
	        true,
	        true
	      )
	    );
/*
	    material.setSpecularMap(
	      new Image(this.getClass().getResource(SPECULAR_MAP).toExternalForm(),
	        MAP_WIDTH,
	        MAP_HEIGHT,
	        true,
	        true
	      )
	    );
*/
	    mars.setMaterial(
	        material
	    );

	    return new Group(mars);
	}
 

public static PhongMaterial getMaterial(String face){
    PhongMaterial arrowMat = new PhongMaterial();
    arrowMat.setSpecularColor(Color.WHITESMOKE);
    Color color = Color.WHITE;
    switch(face){
        case "F": 
        case "Fi":  color = Color.BLUE.brighter();
                    break;
        case "B": 
        case "Bi":  color = Color.BLUE.brighter();
                    break;
        case "R":  
        case "Ri":  color = Color.RED.brighter();
                    break;
        case "L":  
        case "Li":  color = Color.RED.brighter();
                    break;
        case "U":   
        case "Ui":  color = Color.FORESTGREEN.brighter();
                    break;
        case "D": 
        case "Di":  color = Color.FORESTGREEN.brighter();
                    break;
        case "Z": 
        case "Zi":  color = Color.BLUE.brighter();
                    break;
        case "X":  
        case "Xi":  color = Color.RED.brighter();
                    break;
        case "Y":   
        case "Yi":  color = Color.FORESTGREEN.brighter();
                    break;
    }
    arrowMat.setDiffuseColor(color);
    return arrowMat;
}
 

private void buildAxes() {
    double length = 2d * dimModel;
    double width = dimModel / 100d;
    double radius = 2d * dimModel / 100d;
    final PhongMaterial redMaterial = new PhongMaterial();
    redMaterial.setDiffuseColor(Color.DARKRED);
    redMaterial.setSpecularColor(Color.RED);
    final PhongMaterial greenMaterial = new PhongMaterial();
    greenMaterial.setDiffuseColor(Color.DARKGREEN);
    greenMaterial.setSpecularColor(Color.GREEN);
    final PhongMaterial blueMaterial = new PhongMaterial();
    blueMaterial.setDiffuseColor(Color.DARKBLUE);
    blueMaterial.setSpecularColor(Color.BLUE);
    
    Sphere xSphere = new Sphere(radius);
    Sphere ySphere = new Sphere(radius);
    Sphere zSphere = new Sphere(radius);
    xSphere.setMaterial(redMaterial);
    ySphere.setMaterial(greenMaterial);
    zSphere.setMaterial(blueMaterial);
    
    xSphere.setTranslateX(dimModel);
    ySphere.setTranslateY(dimModel);
    zSphere.setTranslateZ(dimModel);
    
    Box xAxis = new Box(length, width, width);
    Box yAxis = new Box(width, length, width);
    Box zAxis = new Box(width, width, length);
    xAxis.setMaterial(redMaterial);
    yAxis.setMaterial(greenMaterial);
    zAxis.setMaterial(blueMaterial);
    
    autoScalingGroup.getChildren().addAll(xAxis, yAxis, zAxis);
    autoScalingGroup.getChildren().addAll(xSphere, ySphere, zSphere);
}
 

@Test
public void buildStructure_goodInputWithComment_returnNewStructure() throws Exception
{
    String inputWithComment = "sphere(10, 20, 30, 10.0, 150, 160, 170, 1.0, \"This is round.\")";
    Xform struct = Viewer3d.buildStructure(new ByteArrayInputStream(inputWithComment.getBytes()));
    Sphere sphere = (Sphere) struct.getChildren().get(0);

    /* Check that the transforms are correct. */

    assertEquals(10, sphere.getTranslateX(), 0);
    assertEquals(20, sphere.getTranslateY(), 0);
    assertEquals(30, sphere.getTranslateZ(), 0);

    /* Check that the size is correct. */

    assertEquals(10.0, sphere.getRadius(), 0);

    /* Check that the color is correct. */

    PhongMaterial material = (PhongMaterial) sphere.getMaterial();
    Color color = material.getDiffuseColor();

    assertEquals(150/255.0, color.getRed(), 0.001);
    assertEquals(160/255.0, color.getGreen(), 0.001);
    assertEquals(170/255.0, color.getBlue(), 0.001);
    assertEquals(1.0, color.getOpacity(), 0.0);
}
 

public void setSelectedTile(Tile3D tile) {
    // Simulate SV behavior
    if (currentSelectedNode != null) {
        ((PhongMaterial) currentSelectedNode.getMaterial()).setDiffuseColor(Color.WHITE);
        final Node currentSelectedNodeToUnselect = currentSelectedNode;
        // Wait for principal UI to be updated (the selection)
        Platform.runLater(() -> {
            ((Tile3D) currentSelectedNodeToUnselect).snapshot();   // In case of changes on 2D node after edit
        });

    }
    currentSelectedNode = tile;
    ((PhongMaterial) tile.getMaterial()).setDiffuseColor(Color.YELLOW); // Simulate SV selection color
}
 

private Xform buildAxes()
{
    Xform axes = new Xform();
    final PhongMaterial red = new PhongMaterial();
    red.setDiffuseColor(Color.RED);
    red.setSpecularColor(Color.DARKRED);

    final PhongMaterial green = new PhongMaterial();
    green.setDiffuseColor(Color.GREEN);
    green.setSpecularColor(Color.DARKGREEN);

    final PhongMaterial blue = new PhongMaterial();
    blue.setDiffuseColor(Color.BLUE);
    blue.setSpecularColor(Color.DARKBLUE);

    final Box xAxis = new Box(AXIS_LENGTH, 1, 1);
    final Box yAxis = new Box(1, AXIS_LENGTH, 1);
    final Box zAxis = new Box(1, 1, AXIS_LENGTH);

    xAxis.setTranslateX(AXIS_LENGTH/2 + 0.5);
    yAxis.setTranslateY(AXIS_LENGTH/2 + 0.5);
    zAxis.setTranslateZ(AXIS_LENGTH/2 + 0.5);

    xAxis.setMaterial(red);
    yAxis.setMaterial(green);
    zAxis.setMaterial(blue);

    axes.getChildren().addAll(xAxis, yAxis, zAxis);

    return axes;
}
 

private Node createBlockShape(final ShapeKey<T> key)
	{
		final Interval keyInterval = key.interval();
		final double[] worldMin = new double[3], worldMax = new double[3];
		Arrays.setAll(worldMin, d -> keyInterval.min(d));
		Arrays.setAll(worldMax, d -> keyInterval.min(d) + keyInterval.dimension(d));
		unshiftedWorldTransforms.apply(key.scaleIndex()).apply(worldMin, worldMin);
		unshiftedWorldTransforms.apply(key.scaleIndex()).apply(worldMax, worldMax);

		final RealInterval blockWorldInterval = new FinalRealInterval(worldMin, worldMax);
		final double[] blockWorldSize = new double[blockWorldInterval.numDimensions()];
		Arrays.setAll(blockWorldSize, d -> blockWorldInterval.realMax(d) - blockWorldInterval.realMin(d));

		// the standard Box primitive is made up of triangles, so the unwanted diagonals are visible when using DrawMode.Line
//		final Box box = new Box(
//				blockWorldSize[0],
//				blockWorldSize[1],
//				blockWorldSize[2]
//			);
		final PolygonMeshView box = new PolygonMeshView(Meshes.createQuadrilateralMesh(
				(float) blockWorldSize[0],
				(float) blockWorldSize[1],
				(float) blockWorldSize[2]
		));

		final double[] blockWorldTranslation = new double[blockWorldInterval.numDimensions()];
		Arrays.setAll(blockWorldTranslation, d -> blockWorldInterval.realMin(d) + blockWorldSize[d] * 0.5);

		box.setTranslateX(blockWorldTranslation[0]);
		box.setTranslateY(blockWorldTranslation[1]);
		box.setTranslateZ(blockWorldTranslation[2]);

		final PhongMaterial material = Meshes.painteraPhongMaterial();
		box.setCullFace(CullFace.NONE);
		box.setMaterial(material);
		box.setDrawMode(DrawMode.LINE);

		return box;
	}
 

@Test
public void buildStructure_goodInput_returnNewStructure() throws Exception
{
    String input = "sphere(25, 20, 35, 108.0, 155, 24, 43, 0.565)";
    Xform struct = Viewer3d.buildStructure(new ByteArrayInputStream(input.getBytes()));
    Sphere sphere = (Sphere) struct.getChildren().get(0);

    /* Check that the transforms are correct. */

    assertEquals(25, sphere.getTranslateX(), 0);
    assertEquals(20, sphere.getTranslateY(), 0);
    assertEquals(35, sphere.getTranslateZ(), 0);

    /* Check that the size is correct. */

    assertEquals(108.0, sphere.getRadius(), 0);

    /* Check that the color is correct. */

    PhongMaterial material = (PhongMaterial) sphere.getMaterial();
    Color color = material.getDiffuseColor();

    assertEquals(155/255.0, color.getRed(), 0.001);
    assertEquals(24/255.0, color.getGreen(), 0.001);
    assertEquals(43/255.0, color.getBlue(), 0.001);
    assertEquals(0.565, color.getOpacity(), 0.001);
}
 

public PolyLine3D(List<Point3D> points, int width, Color color) {
    this.points = points;
    this.width = width;
    this.color = color;
    setDepthTest(DepthTest.ENABLE);        
    mesh  = new TriangleMesh();
    //add each point. For each point add another point shifted on Z axis by width
    //This extra point allows us to build triangles later
    for(Point3D point: points) {
        mesh.getPoints().addAll(point.x,point.y,point.z);
        mesh.getPoints().addAll(point.x,point.y,point.z+width);
    }
    //add dummy Texture Coordinate
    mesh.getTexCoords().addAll(0,0); 
    //Now generate trianglestrips for each line segment
    for(int i=2;i<points.size()*2;i+=2) {  //add each segment
        //Vertices wound counter-clockwise which is the default front face of any Triange
        //These triangles live on the frontside of the line facing the camera
        mesh.getFaces().addAll(i,0,i-2,0,i+1,0); //add primary face
        mesh.getFaces().addAll(i+1,0,i-2,0,i-1,0); //add secondary Width face
        //Add the same faces but wind them clockwise so that the color looks correct when camera is rotated
        //These triangles live on the backside of the line facing away from initial the camera
        mesh.getFaces().addAll(i+1,0,i-2,0,i,0); //add primary face
        mesh.getFaces().addAll(i-1,0,i-2,0,i+1,0); //add secondary Width face
    }
    //Need to add the mesh to a MeshView before adding to our 3D scene 
    meshView = new MeshView(mesh);
    meshView.setDrawMode(DrawMode.FILL);  //Fill so that the line shows width
    material = new PhongMaterial(color);
    material.setDiffuseColor(color);
    material.setSpecularColor(color);
    meshView.setMaterial(material); 
    //Make sure you Cull the Back so that no black shows through
    meshView.setCullFace(CullFace.BACK);

    //Add some ambient light so folks can see it
    AmbientLight light = new AmbientLight(Color.WHITE);
    light.getScope().add(meshView);
    getChildren().add(light);
    getChildren().add(meshView);           
}
 

@Override
public void setNodeColor(Color featureColor) {
  PhongMaterial material = new PhongMaterial();
  material.setDiffuseColor(featureColor);
  featureBox.setMaterial(material);
}
 

public void clearSelection() {
    if (currentSelectedNode != null) {
        ((PhongMaterial) currentSelectedNode.getMaterial()).setDiffuseColor(Color.WHITE);
        ((Tile3D) currentSelectedNode).snapshot();   // In case of changes
    }
}
 

public Tile3D(SVNode currentRoot2D, double factor2d3d, SVNode node2D, double depth, double thickness, ITile3DListener l, IThreeDOM i) {
        this.depth = depth;
        this.currentRoot2D = currentRoot2D;
        this.factor2d3d = factor2d3d;
        this.iTile3DListener = l;
        this.iThreeDOM = i;

        node2d = node2D;
        material = new PhongMaterial();
        material.setDiffuseColor(Color.WHITE);
        material.setSpecularColor(Color.TRANSPARENT);

        Bounds bounds2D = localetoRoot(node2D);
        //
        Bounds bounds3D = new BoundingBox(bounds2D.getMinX() * factor2d3d,
                bounds2D.getMinY() * factor2d3d,
                bounds2D.getWidth() * factor2d3d,
                bounds2D.getHeight() * factor2d3d);
        super.setDepth(thickness);
        super.setWidth(bounds3D.getWidth());
        super.setHeight(bounds3D.getHeight());

        // Place object as 0,0 that is curently in the middle of 3D universe
        getTransforms().add(new Translate(bounds3D.getMinX() + bounds3D.getWidth() / 2,
                bounds3D.getMinY() + bounds3D.getHeight() / 2,
                0));
        setMaterial(material);

        snapshot();

        super.setOnMouseMoved((MouseEvent me) -> {
            String mouseOverTileText = node2D.getImpl().getClass().getSimpleName();
            iTile3DListener.onMouseMovedOnTile(mouseOverTileText);
        });
//        super.setOnMouseClicked((MouseEvent event) -> {
        super.setOnMousePressed((MouseEvent event) -> {
           
            // Selection
            iTile3DListener.onMouseClickedOnTile(Tile3D.this);
             if(event.isSecondaryButtonDown()){
                  iTile3DListener.onMouseRightClickedOnTile(event);
            }
        });

    }
 

public PhongMaterial getMaterial()
{
	return material;
}
 

public final PhongMaterial getMaterial() {
    return material;
}
 

/**
 * @param radius radius of the sphere segment
 * @param color The sphere segment color.
 * @param phimin The starting azimutal angle [rad], 0-2*pi.
 * @param phimax The ending azimutal angle [rad], 0-2*pi, phimax >
 * phimin.
 * @param thetamin The starting polar angle [rad], -pi/2-pi/2.
 * @param thetamax The ending polar angle [rad], -pi/2-pi/2, thetamax >
 * thetamin.
 * @param granularity The number of segments of curves approximations,
 * granulariy > 2.
 * @param ambient Whether to have an ambient light or not
 * @param fill whether to show filled with the color param or as wire mesh
 */
public SphereSegment(double radius, Color color,
        double phimin, double phimax, double thetamin, double thetamax,
        int granularity, boolean ambient, boolean fill) {

    this.radius = radius;
    this.color = color;
    this.phimin = phimin;
    this.phimax = phimax;
    this.thetamin = thetamin;
    this.thetamax = thetamax;
    this.granularity = granularity;
    this.ambient = ambient;
    this.fill = fill;
    setDepthTest(DepthTest.ENABLE);

    mesh = new TriangleMesh();
    // Fill Points
    double phi = phimin;
    double theta;

    PhongMaterial maxPhong = new PhongMaterial();
    maxPhong.setSpecularColor(color);
    maxPhong.setDiffuseColor(color);

    for (int i = 0; i < granularity + 1; i++) {
        theta = thetamin;
        for (int j = 0; j < granularity + 1; j++) {
            Point3D p3D = new Point3D((float) (radius * Math.cos(theta) * Math.sin(phi)),
                    (float) (radius * Math.cos(theta) * Math.cos(phi)),
                    (float) (radius * Math.sin(theta)));
            mesh.getPoints().addAll(new Float(p3D.getX()), new Float(p3D.getY()), new Float(p3D.getZ()));
            theta += (thetamax - thetamin) / granularity;
        }
        phi += (phimax - phimin) / granularity;
    }

    //for now we'll just make an empty texCoordinate group
    mesh.getTexCoords().addAll(0, 0);
    //Add the faces "winding" the points generally counter clock wise
    for (int i = 0; i < granularity; i++) {
        int multiplier = (i * granularity) + i;
        //Up the Outside
        for (int j = multiplier; j < granularity + multiplier; j++) {
            mesh.getFaces().addAll(j, 0, j + 1, 0, j + granularity + 1, 0); //lower triangle
            mesh.getFaces().addAll(j + granularity + 1, 0, j + 1, 0, j + granularity + 2, 0); //upper triangle
        }
        //Down the Inside            
        for (int j = granularity + multiplier; j > multiplier; j--) {
            mesh.getFaces().addAll(j, 0, j - 1, 0, j + granularity + 1, 0); //lower triangle
            mesh.getFaces().addAll(j - 1, 0, j + granularity, 0, j + granularity + 1, 0); //upper triangle
        }
    }

    //Create a viewable MeshView to be added to the scene
    //To add a TriangleMesh to a 3D scene you need a MeshView container object
    meshView = new MeshView(mesh);
    //The MeshView allows you to control how the TriangleMesh is rendered
    if (fill) {
        meshView.setDrawMode(DrawMode.FILL);
    } else {
        meshView.setDrawMode(DrawMode.LINE); //show lines only by default
    }
    meshView.setCullFace(CullFace.BACK); //Removing culling to show back lines

    getChildren().add(meshView);
    meshView.setMaterial(maxPhong);
    if (ambient) {
        AmbientLight light = new AmbientLight(Color.WHITE);
        light.getScope().add(meshView);
        getChildren().add(light);
    }
}
 

@Override
public PhongMaterial getMaterial() {
    return material;
}
 

public static PhongMaterial painteraPhongMaterial() {
	return painteraPhongMaterial(DEFAULT_MESH_COLOR);
}
 

public void setXYZData(ArrayList<Double> xData, ArrayList<Double> yData, ArrayList<Double> zData) {
        xAxisData = xData;
        yAxisData = yData;
        zAxisData = zData;
        getChildren().clear();
        //for now we will always default to x axis
        //later we could maybe dynamically determine the smallest axis and then
        //uses 0's for the other axes that are larger.
        ArrayList<Point3D> point3DList = new ArrayList<>();

        for(int i=0;i<xAxisData.size();i++) {
            //some safety checks for array sizes
            double translateY = 0.0;
            double translateZ = 0.0;            
            if(!yAxisData.isEmpty() && yAxisData.size() > i)
                translateY = yAxisData.get(i);
            if(!zAxisData.isEmpty() && zAxisData.size() > i)
                translateZ = zAxisData.get(i);
            setTranslateX(xAxisData.get(i));
            //Convert to Floats and build list of adjusted points
            point3DList.add(new Point3D(new Float(xAxisData.get(i)), new Float(translateY), new Float(translateZ)));

            float width = 1;
            final TriangleMesh mesh = new TriangleMesh();
            //add each point. For each point add another point shifted on Z axis by width
            //This extra point allows us to build triangles later
            for(Point3D point: point3DList) {
                //Rear points
                //top right rear point
                mesh.getPoints().addAll(point.x+width,point.y+width,point.z+width);
                //top left rear point
                mesh.getPoints().addAll(point.x-width,point.y+width,point.z+width);
                //bottom right rear point
                mesh.getPoints().addAll(point.x+width,point.y-width,point.z+width);
                //bottom left rear point
                mesh.getPoints().addAll(point.x-width,point.y-width,point.z+width);
                //Front points
                //top right front point
                mesh.getPoints().addAll(point.x+width,point.y+width,point.z-width);
                //top left front point
                mesh.getPoints().addAll(point.x-width,point.y+width,point.z-width);
                //bottom right front point
                mesh.getPoints().addAll(point.x+width,point.y-width,point.z-width);
                //bottom left front point
                mesh.getPoints().addAll(point.x-width,point.y-width,point.z-width);
            }
            //add dummy Texture Coordinate
            mesh.getTexCoords().addAll(0,0);
            //Now generate nodes for each point
            for(int p=8;p<point3DList.size()*7;p+=8) {  //add each segment
                //Wind the next 8 vertices as a cube.  The cube itself will represent the data
                //Vertices wound counter-clockwise which is the default front face of any Triangle
                //Rear triangle faces should be wound clockwise to face away from center
                mesh.getFaces().addAll(p,0,p+3,0,p+2,0); //TRR,BLR,BRR
                mesh.getFaces().addAll(p+3,0,p,0,p+1,0); //BLR,TRR,TLR
                //left side faces
                mesh.getFaces().addAll(p+1,0,p+5,0,p+3,0); //TLR,TLF,BLR
                mesh.getFaces().addAll(p+5,0,p+7,0,p+3,0); //TLF,BLR,BLF
                //front side faces
                mesh.getFaces().addAll(p+5,0,p+7,0,p+4,0); //TLF,BLF,TLR
                mesh.getFaces().addAll(p+4,0,p+7,0,p+6,0); //TRF,BLF,BRF
                //front side faces
                mesh.getFaces().addAll(p+4,0,p+6,0,p+2,0); //TRF,BRF,BRR
                mesh.getFaces().addAll(p+4,0,p+2,0,p,0); //TRF,BRR,TRR
               
                //Top faces
                mesh.getFaces().addAll(p,0,p+1,0,p+3,0); //TRR,TLR,TRF
                mesh.getFaces().addAll(p+1,0,p+5,0,p+3,0); //TLR,TLF,TRF
               
                //bottom faces
                mesh.getFaces().addAll(p+3,0,p+7,0,p+6,0); //BLR,BLF,BRF
                mesh.getFaces().addAll(p+3,0,p+6,0,p+2,0); //BLR,BRF,BRR
            }
           
            //Need to add the mesh to a MeshView before adding to our 3D scene
            MeshView meshView = new MeshView(mesh);
            meshView.setDrawMode(DrawMode.FILL);  //Fill so that the line shows width
                              
            Color hsb = Color.hsb((new Double(i)  / 12) * 360, 1.0, 1.0, 0.5);
            PhongMaterial material = new PhongMaterial(hsb);
            material.setDiffuseColor(hsb);
            material.setSpecularColor(hsb);
            meshView.setMaterial(material);
            //Make sure you Cull the Back so that no black shows through
            meshView.setCullFace(CullFace.BACK);    
//            //Add some ambient light so folks can see it
//            Group line = new Group();
//            AmbientLight light = new AmbientLight(Color.WHITE);
//            light.getScope().add(meshView);
//            line.getChildren().add(light);
//            line.getChildren().add(meshView);           
            getChildren().addAll(meshView);           
        }
    }
 

public static PhongMaterial painteraPhongMaterial(final Color color) {
	final PhongMaterial material = new PhongMaterial();
	material.setSpecularColor(color);
	material.setSpecularPower(50);
	return material;
}