I'll hide this, since I'll probably ramble again.

I've been fighting with a complex collision detection system for my framework for nearly a week now. It started off simply enough: AABB collision detection. Easy enough.

Until I started adding in modifiable Bounding Boxes and Sprite Origins; the transformations I'm having to apply to these things are making my head want to explode.

Anyway, enough with that. I'll fix it, or I won't. Doesn't matter either way.

But I was spending much time today in deep thought on the subject of collision detection, and also on the subject of Raytracing (I'm constructing a little raytracer slowly. Screenshots whenever I get it to render my data).

One of the 'problems' I face when tracing a Ray from the camera through each point in the view plane is collision with perfect spheres (Spheres defined as a Vector with a Radius as opposed to a set of polygons).

Now how to you not only test for an intersection between a Ray and a Sphere, but also calculate the precise point in 3D space where the collision took place, and generate seconday rays from that point?

Well the latter part of the problem is solved using the Dot Product between the Center Point of the Sphere and the collision point, and determining the deflection off the surface based on that angle.

The middle problem, solving for the precise point of collision, is solved using the (again) Dot Product, this time between the view-plane and the center of the sphere, then using the new data along with the radius and a bit of PI to calculate the surface position.

That's all standard, actually, but it's the broad-phase that I was thinking about, and a way to speed it up quite a bit (Depending on the implementation).

I solved this little problem of mine in 2D, where it also works quite well, although I don't use circular collisions anywhere near as much. (Squared Distance is the best alternative in 2D. In 3D as well, actually).

Anyway, imagine this scene (In 2D, viewed from above):

A circle

A line denoting the viewing plane with it's normal (Perpindicular line) pointing towards the sphere (Doesn't have to be precisely centered. Can be facing away too).

A ray (line) drawn from the center of the view plane along it's normal for a set distance.

Our problem is to test whether or not the ray intersects the sphere at any point, at the highest possible speed.

My little solution takes this form:

Normalize the view-plane's vector and multiply it by the radius of the sphere.

Place the new vector on the center point of the sphere

Perform a Line/Line intersection test between the Ray and the new vector V and -V (Negated).

Anyway, depending on the line intersection test you use, this will either be a little bit faster, or a lot slower (3D math can be fickle).

So it's useless, but the very fact that my mind is trying to think this stuff up now must mean that I'm finally getting my head around that math I've been trying to learn.

That got me thinking about raycasting again, which is a much-easier-to-perform subset of raytracing (Only trace along each column instead of for each pixel).

And that gets me thinking of renderer that scans each column, and scans a certain number of patches along each column for extra geometric detail (If I scanned every four pixels, at 320x240 that'd be a total of 19200 scans per frame. A bit hectic, but it could be optimized to make liberal use of the information already gained by the column (You won't have to trace to the column again, basically)).