what i mean by a plane is this:
imagine cutting 3D space into 2 halfs, the flat surface you would use to cut with is the plane in question, for intersections we need one defined by 2 things, a direction it defines as 'up', at which it is perpendicular to, and a point upon which it rests, this point being what it pivots around.
the plane in the pic is finite, but in reality it extends perpendicular to its surface normal(its 'up' direction) forever
due to the fact that you can use this to split space into two halves, you can thus use another to split one of those pieces again into two halves, and thus you can use a collection of planes to carve out convex shapes in any dimension(2D, 3D, 4D, ..., ND)
(note the fact that carving 3D space with planes allows you to make things like infinitely extending objects, as thats important for csg to work)
thus with our plane defined, we can do a bit of math to check if a point is below a plane, thus in turn we can check if said point is below ALL of the planes defining a convex shape, thus we can check if said point is colliding with said shape.
as a result of this ability, we can collision test two convex shapes by using a combination of there verticies and faces to determine a collision, as its mathematically impossible for two convex hulls to be intersecting without one having at least one of its corner verticies being fully within the bounds of the other.
thus we can define colliders as convex meshes comprised of corner verticies and planes, this structure is called a 'brush' and is the basis for csg and bsp in most scenarios, you can have more complicated brushes, but this will work for now
with the above in mind, you can check if two brushes are colliding in 3D, with 'partial collisions' being defined as collisions in which no brush is fully within the other, and 'full collisions' being when one brush is fully within the other, with 100% of its verticies being under 100% of the other brushes planes
with this we can do csg operations by defining one brush as the 'base' and another as the 'operand' whom is effecting the base
csg has 3 primary operations, each of which we can perform with brushes and basic logic
-union, in which the operand adds to the base
-intersect, in which the collision is only valid if it takes plane in a space that overlaps both the base and the operand
-difference(subtraction), in which the base is solid, but the operand defines a special area that is exempt from this collision
with this relationship defined, you can take a third brush called the 'client' and use it to check for a collision against this new csg-brush which is just a base/operand plus a relationship type of union, intersect or difference
for union you would check if the client is in a partial or full intersection with ether the base or operand, so long as at least one is intersecting the client brush, then the entire csg-brush is defined as colliding the client
for intersect the client brush must be in a full or partial intersection with the base AND the operand, if its intersecting one but not the other, then there is not intersection with the csg-brush itself
for difference(the tricky one) you must ensure that the client is intersecting the base brush and is not fully intersecting the operand brush, as a partial collision implies its still colliding with the base, but a full one means its not supposed to be touching the base.
the difference operation can be tricky as there are scenarios in which we would consider it a valid collision but the computer doesn't, like this:
blue: base brush
red: operand brush
green: client brush
as you can see in this scenario it would detect a collision despite the fact that the difference brush should prevent it, due to the fact that the intersection between the client and operand is a partial one, not a full one
to solve this you need to uncap the operand brush as to not restrict it in ways that could break it, mainly by removing faces that aren't intersecting the base brush, which can be done automatically
the collision is now ignored as we want, simply by removing disruptive planes from the operand brush
so ya... hopefully this WAY to detailed explanation helps you/who-ever it may help as 3D collisions and csg are a vary oft requested thing on the topic of 3D
your exact implementation of the theory if just explained will vary must depend on what your need is, and what information relating to the collision you wish to detect, so for now ill leave it at this.
as for carving a bsp map... just be aware that in most cases its not just subtracting, rather its CARVING the cube, partitioning into pieces whoms material depends on what side of each subsequent plane that divides it its on, one side of a plane can have ground, the other can be split again into air and the water below it for example, your not just removing stuff, your partitioning and defining what is what.
and while doing such with a bsp file isn't exactly a-tune to what i just explained involving csg, just know the theory i explained here can be used to carve the 4096x#3 cube into what the file describes.
regardless, i have indulged by nerdy side quite enough i do think, so if all can be said and done, i bid you good-day sir =) *put on top-hat and walks out the door*