Unit Boxes3d

Check is box empty. You can think of this function as "compare Box with EmptyBox3d".

But actually it works a little faster, by utilizing the assumption that EmptyBox3d is the only allowed value that breaks Box[0, 0] <= Box[1, 0] rule.

These functions calculate the middle point, average size, max size and particular sizes of given bounding box. When given Box is empty (IsEmptyBox3d), they raise some exception.

This decreases Box[0, 0], Box[0, 1], Box[0, 2] by Expand and increases Box[1, 0], Box[1, 1], Box[1, 2] by Expand. So you get Box with all sizes increased by 2 * Expand.

Box must not be empty. Note that Expand may be negative, but then you must be sure that it doesn't make Box empty.

This decreases Box[0] by Expand, and increases Box[1] by Expand. So you get Box with all sizes increased by 2 * Expand.

Box must not be empty. Note that Expand may be negative, but then you must be sure that it doesn't make Box empty.

Check is the point inside the box. Always false if Box is empty (obviously, no point is inside an empty box).

Calculate bounding box of a set of 3D points. This calculates the smallest possible box enclosing all given points. For VertsCount = 0 this returns EmptyBox3d.

Overloaded version with Transform parameter transforms each point by given matrix.

Overloaded version with GetVertex as a function uses GetVertex to query for indexes from [0 .. VertsCount - 1] range.

As usual, VertsStride = 0 means VertsStride = SizeOf(TVector3Single).

Calculate bounding box of a set of indexed 3D points.

This is much like CalculateBoundingBox, except there are two functions: For each number in [0 .. VertsIndicesCount - 1] range, GetVertIndex returns an index. If this index is >= 0 then it's used to query GetVertex function to get actual vertex position.

Indexes < 0 are ignored, this is sometimes comfortable. E.g. for VRML models, you often have a list of indexes with -1 in between marking end of faces.

Returns smallest box enclosing all vertexes.

Overloaded version with Transform parameter transforms each point by given matrix.

Sum two TBox3d values. This calculates the smallest box that encloses both Box1 and Box2.

Box3dSumTo1st places the result of calculation back in Box1 argument.

This enlarges Box1 so that it contains given Point.

Three box sizes.

Calculates eight corners of the box, placing them in AllPointsˆ[0..7].

Transforms the box by given matrix. More precisely, transforms all 8 box corners, and makes new box enclosing these 8 points.

Since this is axis-aligned box, rotating etc. of the box usually makes larger box (this is the primary disadvantage of axis-aligned boxes, as opposed to oriented boxes).

Move Box. Does nothing if Box is empty.

Move Box, by -Translation. Does nothing if Box is empty.

TryBoxRayClosestIntersection calculates intersection between the ray (returns closest intersection to Ray0) and the box.

The box is treated just like a set of 6 rectangles in 3D. This means that the intersection will always be placed on one of the box sides, even if Ray0 starts inside the box. See TryBoxRayEntrance for the other version.

Returns also IntersectionDistance, which is the distance to the Intersection relative to RayVector (i.e. Intersection is always = Ray0 + IntersectionDistance * RayVector).

TryBoxRayEntrance calculates intersection between the ray (returns closest intersection to Ray0) and the box, treating the box as a filled volume.

This means that if Ray0 is inside the box, TryBoxRayEntrance simply returns Ray0. If Ray0 is outside of the box, the answer is the same as with TryBoxRayClosestIntersection.

Tests for collision between box3d centered around (0, 0, 0) and a plane.

Note that you can't express empty box3d here: all BoxHalfSize items must be >= 0. The case when size = 0 is considered like infintely small box in some dimension (e.g. if all three sizes are = 0 then the box becomes a point).

This is equivalent to FrustumSphereCollisionPossible, but here it takes a box instead of a sphere.

This is like FrustumBox3dCollisionPossible but it returns true when FrustumBox3dCollisionPossible would return fcSomeCollisionPossible or fcInsideFrustum. Otherwise (when FrustumBox3dCollisionPossible would return fcNoCollision) this returns false.

So this returns less detailed result, but is a little faster.

This calculates smallest possible sphere completely enclosing given Box. SphereRadiusSqr = 0 and SphereCenter is undefined if Box is empty.

This is just like Boxes3dCollision, but it takes into account only XY plane. I.e. it works like Box1 and Box2 are infinitely large in the Z coordinate. Or, in other words, this actually checks collision of 2D rectangles obtained by projecting both boxes on plane XY.

This calculates maximum Sqr(distance) of 8 box points to the (0, 0, 0) point. This can be useful when you want to get bounding sphere, centered in (0, 0, 0), around this Box.

Just like Box3dSqrRadius, but this returns correct value (not it's Sqr). Speed note: you pay here one Sqrt operation.

This is like projecting Box on XY plane (that is, we just ignore Z coords of Box points here), and then calculates maximum Sqr(distance) in plane XY of 4 Box corners to point (0, 0).

Just like Box3dXYSqrRadius, but this returns correct value (not it's Sqr). Speed note: you pay here one Sqrt operation.

Check for collision betweeb box and sphere, fast but not entirely correct.

This considers a Box enlarged by SphereRadius in each direction. Then checks whether SphereRadius is inside such enlarged Box. So this check will incorrectly report collision while in fact there's no collision in the case when the Sphere is very near the edge of the Box.

So this check is not 100% correct. But often this is good enough — in games, if you know that the SphereRadius is going to be relatively small compared to the Box, this may be perfectly acceptable. And it's fast.

Check for box <-> sphere collision. This is a little slower than Box3dSphereSimpleCollision, although still damn fast, and it's a precise check.

Axis-aligned box. Rectangular prism with all sides parallel to basic planes X = 0, Y = 0 and Z = 0. This is sometimes called AABB, "axis-aligned bounding box".

This is a handy type, because it's easy to implement many operations on it in a fast manner.

First point always has all the smaller coords, second point has all the larger coords. I.e. always

  Box[0, 0] <= Box[1, 0] and
  Box[0, 1] <= Box[1, 1] and
  Box[0, 2] <= Box[1, 2]

The only exception is the special value EmptyBox3d.

Special value for TBox3d meaning "bounding box doesn't exist". This is used when the object has no points, so bounding box doesn't exist.