Fix #6

TODO

• [x] Fill out "evluateHierarchy"
• [x] Add issue for optimizing evaluation #60
• [x] Add support for pass through groups
• [x] Consider providing an option to disable groups #62
• [x] Add support for a target mesh
• [ ] Throw an error if Brush is a child
• [ ] Add "intermediate geometry state" CSG Helper
• [ ] Add examples
  • ~Add draggable windows, door~
  • Drag snapping
  • Toggleable brush visualiation
• [ ] Document triangle issues
• [ ] Harden hierarchy processing
• [ ] Add a more clear "root" class? RootOperation? OperationCombiner?

Hi, Using BufferGeometryUtils.MergeGeometry() on intersected geometries and using that merged geometry with csg operations results with buged faces and missing triangles.

I created this sandbox to demonstrade: https://codesandbox.io/s/throbbing-breeze-f4hj9p?file=/src/App.js In this sandbox you can see that results don't have faces along x axis.

Hi everyone! I'm using the three-mesh-csg inside of the library, that is written in Angular 10. With the recent addition of typescript types it stopped building due to errors in the index.d.ts file of three-bvh-csg. There are two main issues:

1. Generic type 'Array<T>' requires 1 type argument(s). ts(2314) - The "Array" keyword, which is treated as a generic type and requires at least one type argument. I haven't delved deep into the implementation of each particular method, but unless it is specified differently, the fix would be to either add type to the array generic, at least for now, so that typescript will be okay with that, or to add the target type, that the method related to this issue should return.

export class TriangleIntersectionSets {

  addTriangleIntersection( ia: number, tribA: Triangle, ib: number, triB: Triangle ): void;
  getTrianglesAsArray( id?: number ): Array;
  getTriangleIndices(): Array;
  getIntersectionIndices( id: number );
  getIntersectionsAsArray( id?: number, id2: number ): Array;

}

2. A required parameter cannot follow an optional parameter. ts(1016) For the declaration of getIntersectionsAsArray( id?: number, id2: number ): Array the error is concerning the id2 argument, which can't be required. Looking at the implementation of this method, this argument could be also marked as optional.

I see benchmark/lib include THREE-CSGMesh This issue is added before in intersecting a box with a cone results in a slice of the surface of the cone instead of a solid object I did not test cone , only test LatheGeometry.

CSG.toMesh(
    CSG.fromMesh(A).intersect(CSG.fromMesh(B)),
    A.matrix,
    A.material
 );

giladdarshan suggest change Line #73 to

return CSG.fromPolygons(polys.filter(p=>!isNaN(p.plane.normal.x)));

This issue still exists , subtract and union both return partial of the LatheGeometry , intersect returns something close to A-A∩B but not exactly A-A∩B Is this library fixed THREE-CSG when dealing with LatheGeometry/ConeGeometry return incorrect result issue?

Follow on from #28

Looks like there's a triangle not getting split:

Next step: find the triangle that that's clipped from and the other triangles it's intersecting

Possibly a clipping issue. Set both brushes to "torus" and lowest complexity.

	brush2.position.set( - 0.27300968690619787, 0.5329319712626078, 0 );
	brush2.scale.setScalar( 1 );

Possible sources:

• *debugger info (should possibly allow for disabling this in the demo?)
• raycast hit object creation (could be fixed by #3)
• list of intersection ids

• Track the last-known calculation state / position associated with each sub node
• When recomputing traverse the hierarchy (or track ahead of time?) to find which nodes are dirty and bubble it up the hierarchy.
• Also find which nodes are touching to determine what needs to be recomputed?
• Recompute the dirty nodes from the bottom up.
• Unchanged / non-intersecting geometry can just be propagated up.
• Should operations be declared on the children (ie perform this operation to the parent) or on the parent to perform on the children? I'm leaning towards the former.

See how Godot handles this? https://docs.godotengine.org/en/stable/tutorials/3d/csg_tools.html

And RealtimeCSG

• https://realtimecsg.com/manual.html

Related issue: #72

I tried to add some documentation, I hope it's not a mess. It's not easy. The two classes PointsHelper and HalfEdgeHelper are not documented, I'm not sure about how to explain them.

Feel free to cancel the PR if the documentation is not consistent. I understand 😅

Related issue: #65

• I added the typescript configuration and the typescript lint checks in the package.json script.
• I added the index.d.ts file, but I'm not sure about some points.

For example, the Constants type, the HalfEdgeHelper class, I added the code but it is commented because I'm not sure which is the correct type of the halfEdge parameter.

Maybe it's all a mess 😅, please tell me what you think.

Property 'customProgramCacheKey' in type 'GridMaterial' is not assignable to the same property in base type 'MeshPhongMaterial'.
  Type '() => boolean' is not assignable to type '() => string'.
    Type 'boolean' is not assignable to type 'string'

During the process of applying CSG to a mesh flat surfaces become unnecessarily complex. During lulls in user operation it would be good to remesh brushes so they use a minimal number of triangles while still being connected - ie retriangulate flat / coplanar surfaces.

• Find all large, flat surfaces while retaining half edges
• Mark shared vertices as being removeable or not - ie required to define the contour of a shape.
• Remove unnecessary vertices from the new shapes
• Earcut to triangulate the surfaces

I made a demo that allows to interactively "cut off" pieces of a mesh: https://github.com/coolvision/three-bvh-csg/blob/iterative-dev/examples/iterative.js

demo video:

It does subtraction, and the mesh is iteratively updated to the CSG result each time, so that subtractions accumulate. In this case, lots of coplanar triangles are created, and when testing with current three-bvh-csg version, lots of triangles are missing:

I've added a fix for adding coplanar triangles, and in this case it works fine: https://github.com/gkjohnson/three-bvh-csg/commit/718868914c96f11b28bf5b194eca0c9953d0af0f#diff-172f17787715fc8aa7225b6a6716874d91c005133ed9670a86c84ab2081ca063

When I use a cone for the brush instead of a box. there are still missing and non-clipped triangles, albeit less than without the fix, so there is still work to do:

Would some of this be useful? I can add a PR for the fix, and for the demo/example as well, I think it's a useful testcase for improving bunch of corner cases.

This is the error stack. Same two Brush es , sometimes it's ok , sometimes got this error.

buildFunctions.js:785 Uncaught TypeError: Cannot read properties of undefined (reading 'count')
    at countNodes (buildFunctions.js:785:13)
    at countNodes (buildFunctions.js:791:15)
    at buildPackedTree (buildFunctions.js:770:19)
    at new MeshBVH (MeshBVH.js:165:18)
    at Brush.prepareGeometry (Brush.js:68:26)
    at Evaluator.evaluate (Evaluator.js:137:5)
    at csg (animationTest.js:767:39)
    at animationTest.js:778:30

Right now the Operations groups/hierarchy etc have to be completely rerun for for the entire stack each time it’s evaluated.

so really big objects end up having to include all previous brushes/mesh data and be processed each time.

one idea:

let’s say there are 10 operation steps, and you are transforming step #7. You could run a truncated steps 1-6, and save the result. Then use that result each subsequent pass. I think if all something like addition you could also run steps 8-10 and generate a brush for that section as well. This would make a transformation of any size just 3 brushes instead of 10.

plus the results discard unused geometry data so hypothetically run much faster.

Another idea would be to cache by hierarchy.

so for a body for example, a arm/leg etc would cache the results.

This might not be something for the library to do directly persay, But would be a good example on how to use it in production

I’m going to try to make some tests

I'll just skip the set up part ,directly show the pics and codes.

After csg substract , the result also obtain some faces and material of the box.

Console print Trianlges are coplanar which does not support an output edge

function extrudeGeometry() {
	const x = 3;
	const y = 2;
	const z = 20 / 100;
	const wallExtrudeSettings = {
		depth: y,
		steps: 2,
		bevelEnabled: false,
	};
	const aroundWallShape = new THREE.Shape();
	aroundWallShape.moveTo(-x, 0);
	aroundWallShape.lineTo(-x / 2, (x * Math.sqrt(3)) / 2);
	aroundWallShape.lineTo(x / 2, (x * Math.sqrt(3)) / 2);
	aroundWallShape.lineTo(x, 0);
	aroundWallShape.lineTo(x / 2, (-x * Math.sqrt(3)) / 2);
	aroundWallShape.lineTo(-x / 2, (-x * Math.sqrt(3)) / 2);
	aroundWallShape.lineTo(-x, 0);
	const aroundWallhole = new THREE.Path();
	aroundWallhole.moveTo(-(x - (z * 2) / Math.sqrt(3)), 0);
	aroundWallhole.lineTo(
		-(x - (z * 2) / Math.sqrt(3)) / 2,
		((x - (z * 2) / Math.sqrt(3)) * Math.sqrt(3)) / 2
	);
	aroundWallhole.lineTo(
		(x - (z * 2) / Math.sqrt(3)) / 2,
		((x - (z * 2) / Math.sqrt(3)) * Math.sqrt(3)) / 2
	);
	aroundWallhole.lineTo(x - (z * 2) / Math.sqrt(3), 0);
	aroundWallhole.lineTo(
		(x - (z * 2) / Math.sqrt(3)) / 2,
		(-(x - (z * 2) / Math.sqrt(3)) * Math.sqrt(3)) / 2
	);
	aroundWallhole.lineTo(
		-(x - (z * 2) / Math.sqrt(3)) / 2,
		(-(x - (z * 2) / Math.sqrt(3)) * Math.sqrt(3)) / 2
	);
	aroundWallhole.lineTo(-(x - (z * 2) / Math.sqrt(3)), 0);
	aroundWallShape.holes.push(aroundWallhole);
	const aroundWallExtrudeGeometry = new THREE.ExtrudeGeometry(
		aroundWallShape,
		wallExtrudeSettings
	);
	aroundWallExtrudeGeometry.rotateX(Math.PI * 0.5)
	return aroundWallExtrudeGeometry
}
const material = new THREE.MeshLambertMaterial({
	color: 0x00ff00,
	side: THREE.DoubleSide
});
const brush1 = new Brush(extrudeGeometry(), material);
const scale = 1
const boxGeometry = new THREE.BoxGeometry(scale, scale, scale)
boxGeometry.translate(0, -1, 2.5)
const brush2 = new Brush(boxGeometry, new THREE.MeshLambertMaterial({
	color: 0x336666
}));
const csgEvaluator = new Evaluator();
// x+ afterCSG
const result = csgEvaluator.evaluate(brush1, brush2, SUBTRACTION);
result.position.x = 5
scene.add(result)
// x- meshes before CSG 
scene.add(brush1)
brush1.position.x = -5
scene.add(brush2)
brush2.position.x = -5