Processing is a creative coding platform - language, IDE & ecosystem - maintained by the Processing community with the backing of the Processing Foundation https://processing.org. Processing Java Mode can usually benefit from code in Java libraries.
JCSG is a Java implementation of BSP based CSG (Constructive Solid Geometry) https://github.com/miho/JCSG.
There are few hoops to jumps through coming from Processing alone, but yes, you can use any Java library in Processing. (Simply drag the library .jar on top of the saved sketch)
First you'll need to compile the JCSG .jar library along with the VVecMath .jar library to run the sample code.
To do that you'll need Gradle. You can install it from scratch or use an existing installation from your system if you've used the Android SDK / Android Studio / IntelliJ / etc.
As the readme mentions, on OSX/Linux/etc. from each library folder run:
bash gradlew assemble
On Windows run:
gradlew assemble
In my case I used the Gradle install that came with Android Studio which I had on my mac:
bash /Applications/IDEsAndEditors/Android\ Studio.app/Contents/plugins/android/lib/templates/gradle/wrapper/gradlew assemble
Once you've got the .jar files compiled you can simply drop them into a saved Processing sketch. This will create a code folder. At this stage you can use the libraries in that sketch.
(Tip: Go to Processing > Preferences and enable Code completion with Ctrl+Space to make easier to see the available method and properties (IDEs like eclipse/IntelliJ/NetBeans/etc. do that by default))
I've done a quick test, however the OBJ file JCSG saves can't be parsed by Processing's built-in PShape OBJ loader.
import java.nio.file.Paths;
PShape csgResult;
void setup(){
size(900,900,P3D);
// we use cube and sphere as base geometries
CSG cube = new Cube(2).toCSG();
CSG sphere = new Sphere(1.25).toCSG();
// perform union, difference and intersection
CSG cubePlusSphere = cube.union(sphere);
CSG cubeMinusSphere = cube.difference(sphere);
CSG cubeIntersectSphere = cube.intersect(sphere);
// translate geometries to prevent overlapping
CSG union = cube.
union(sphere.transformed(Transform.unity().translateX(3))).
union(cubePlusSphere.transformed(Transform.unity().translateX(6))).
union(cubeMinusSphere.transformed(Transform.unity().translateX(9))).
union(cubeIntersectSphere.transformed(Transform.unity().translateX(12)));
// save union as stl
try {
FileUtil.write(
Paths.get(sketchPath("sample.obj")),
union.toObjString()
);
} catch (IOException ex) {
ex.printStackTrace();
}
//load shape into Processing
csgResult = loadShape(sketchPath("sample.obj"));
}
void draw(){
background(0);
translate(width * 0.5, height * 0.5,0);
scale(sin(frameCount * 0.1) * 100);
if(csgResult != null){
shape(csgResult);
}
}
I did test and the vertices are there, the faces are missing through:
Feel try to try the STL format and a different Processing library to load, otherwise access the vertices and draw them in Processing directly taking into account units/scales are different between JSCG and Processing:
import java.nio.file.Paths;
CSG union;
void setup(){
size(900,900,P3D);
stroke(255);
//strokeWeight(3);
// we use cube and sphere as base geometries
CSG cube = new Cube(2).toCSG();
CSG sphere = new Sphere(1.25).toCSG();
// perform union, difference and intersection
CSG cubePlusSphere = cube.union(sphere);
CSG cubeMinusSphere = cube.difference(sphere);
CSG cubeIntersectSphere = cube.intersect(sphere);
// translate geometries to prevent overlapping
union = cube.
union(sphere.transformed(Transform.unity().translateX(3))).
union(cubePlusSphere.transformed(Transform.unity().translateX(6))).
union(cubeMinusSphere.transformed(Transform.unity().translateX(9))).
union(cubeIntersectSphere.transformed(Transform.unity().translateX(12)));
}
void drawCSG(CSG mesh,float scale){
beginShape(POINTS);
for(Polygon p : mesh.getPolygons()){
for(Vertex v : p.vertices){
vertex((float)v.pos.getX() * scale,(float)v.pos.getY() * scale,(float)v.pos.getZ() * scale);
}
}
endShape();
}
void draw(){
background(0);
translate(width * 0.5, height * 0.5,0);
rotateY(map(mouseX,0,width,-PI,PI));
rotateX(map(mouseY,0,height,PI,-PI));
drawCSG(union,sin(frameCount * 0.01) * 100);
}
You can download the above sketch (with pre-compiled libraries) here (and the JCSG generated documentation here). Be sure to go through the libraries' documentation/source code for more advanced usage.
Update: For efficiency you can make use of createShape() to create a group of PShape objects once in setup, then simply render in draw() (as opposed to my previous example which traverses all polygons and vertices over and over again):
// the PShape reference which will contain the converted
PShape csgResult;
void setup(){
size(900,900,P3D);
noStroke();
// JCSG sample code:
// we use cube and sphere as base geometries
CSG cube = new Cube(2).toCSG();
CSG sphere = new Sphere(1.25).toCSG();
// perform union, difference and intersection
CSG cubePlusSphere = cube.union(sphere);
CSG cubeMinusSphere = cube.difference(sphere);
CSG cubeIntersectSphere = cube.intersect(sphere);
// translate geometries to prevent overlapping
CSG union = cube.
union(sphere.transformed(Transform.unity().translateX(3))).
union(cubePlusSphere.transformed(Transform.unity().translateX(6))).
union(cubeMinusSphere.transformed(Transform.unity().translateX(9))).
union(cubeIntersectSphere.transformed(Transform.unity().translateX(12)));
// translate merged geometry back by half the total translation to pivot around centre
union = union.transformed(Transform.unity().translateX(-6));
// Convert CSG to PShape -> Note: CSG units are small so we scale them up so the shapes are visible in Processing
csgResult = CSGToPShape(union,45);
}
// re-usable function to convert a CSG mesh to a Processing PShape
PShape CSGToPShape(CSG mesh,float scale){
// allocate a PShape group
PShape csgResult = createShape(GROUP);
// for each CSG polygon (Note: these can have 3,4 or more vertices)
for(Polygon p : mesh.getPolygons()){
// make a child PShape
PShape polyShape = createShape();
// begin setting vertices to it
polyShape.beginShape();
// for each vertex in the polygon
for(Vertex v : p.vertices){
// add each (scaled) polygon vertex
polyShape.vertex((float)v.pos.getX() * scale,(float)v.pos.getY() * scale,(float)v.pos.getZ() * scale);
}
// finish this polygon
polyShape.endShape();
//append the child PShape to the parent
csgResult.addChild(polyShape);
}
return csgResult;
}
void draw(){
background(0);
lights();
translate(width * 0.5, height * 0.5,0);
rotateY(map(mouseX,0,width,-PI,PI));
rotateX(map(mouseY,0,height,PI,-PI));
shape(csgResult);
}
