vector mathematics problem

It's been a long while since I've picked at vector algebra/calculus, so please excuse me if the solution is rather simple. I have a set of bounding boxes (stored in ordered pairs in a list), and I need to know if a line drawn between two given points passes through any of those bounding boxes

This is a raytracing problem. See:

http://en.wikipedia.org/wiki/Ray_tracing

If your bounding boxes are aligned with the global x, y, and z axes the equations become pretty simple, but you'll still need to test for intersection with each of the six faces of the box. To do that you'll cast the ray to the planes of the sides that are perpendicular to say the x axis, then test the y and z location of the intersection point to see if it is in the bounds given by the other faces. Then repeat for y and z.

Maybe this can help: https://wiki.secondlife.com/wiki/Geometric

Could you settle for the distance box(center) to line? That would be pretty much more simple

Well, here's how you find the intersection between a ray (starting at 'origin' with a unit tangent vector of 'dir') and a bounding box aligned with the global x, y, and z axes (box defined by minXYZ.x <= x <= maxXYZ.x, minXYZ.y <= y <= maxXYZ.y, minXYZ.z <= z <= maxXYZ). Here I assume you won't be interested in intersections "behind" the origin point. This returns the distance to the nearest intersection, or a negative number if there is no intersection. (Hasn't yet been compiled; may need minor syntax fixes.)

float EPSILON = 0.000001;
float distanceToBox(vector origin, vector dir, vector minXYZ, vector maxXYZ)
{
   float minDist = -1.0;
   float dist;
   vector point;

   if (llFabs(dir.x) > EPSILON)
   {
      dist = (minXYZ.x-origin.x)/dir.x;
      if (dist >= 0.0)
      {
         point = origin+dist*dir;
         if (point.y >= minXYZ.y && point.y <= maxXYZ.y &&
             point.z >= minXYZ.z && point.z <= maxXYZ.z)
         {
            minDist = dist;
         }
      }

      dist = (maxXYZ.x-origin.x)/dir.x;
      if (dist >= 0.0)
      {
         point = origin+dist*dir;
         if (point.y >= minXYZ.y && point.y <= maxXYZ.y &&
             point.z >= minXYZ.z && point.z <= maxXYZ.z)
         {
            if (minDist < 0.0 || minDist > dist)
            {
               minDist = dist;
            }
         }
      }
   }

   if (llFabs(dir.y) > EPSILON)
   {
      dist = (minXYZ.y-origin.y)/dir.y;
      if (dist >= 0.0)
      {
         point = origin+dist*dir;
         if (point.x >= minXYZ.x && point.x <= maxXYZ.x &&
             point.z >= minXYZ.z && point.z <= maxXYZ.z)
         {
            if (minDist < 0.0 || minDist > dist)
            {
               minDist = dist;
            }
         }
      }

      dist = (maxXYZ.y-origin.y)/dir.y;
      if (dist >= 0.0)
      {
         point = origin+dist*dir;
         if (point.x >= minXYZ.x && point.x <= maxXYZ.x &&
             point.z >= minXYZ.z && point.z <= maxXYZ.z)
         {
            if (minDist < 0.0 || minDist > dist)
            {
               minDist = dist;
            }
         }
      }
   }

   if (llFabs(dir.z) > EPSILON)
   {
      dist = (minXYZ.z-origin.z)/dir.z;
      if (dist >= 0.0)
      {
         point = origin+dist*dir;
         if (point.x >= minXYZ.x && point.x <= maxXYZ.x &&
             point.y >= minXYZ.y && point.y <= maxXYZ.y)
         {
            if (minDist < 0.0 || minDist > dist)
            {
               minDist = dist;
            }
         }
      }

      dist = (maxXYZ.z-origin.z)/dir.z;
      if (dist >= 0.0)
      {
         point = origin+dist*dir;
         if (point.x >= minXYZ.x && point.x <= maxXYZ.x &&
             point.y >= minXYZ.y && point.y <= maxXYZ.y)
         {
            if (minDist < 0.0 || minDist > dist)
            {
               minDist = dist;
            }
         }
      }
   }

   return minDist;
}

thanks to all who've replied. The script posted will be a great starting point, but I will have to extrapolate it to function with objects that are rotated.

Okay. Here is a modified version. This time, boxCenter is the center of the box in global coordinates, boxSize is the total size of the box on its local axes (like what llGetScale() would give you), and boxRot is the rotation of the box relative to the global coordinate system.

(Not yet compiled; may require some syntax fixes.)

float EPSILON = 0.000001;
float distanceToBox(vector origin, vector dir, vector boxCenter, vector boxSize, rotation boxRot)
{
   vector originBoxCoords = (origin-boxCenter)/boxRot;
   vector dirBoxCoords = dir/boxRot;
   vector boxExtents = 0.5*boxSize;

   float minDist = -1.0;
   float dist;
   vector point;

   if (llFabs(dirBoxCoords.x) > EPSILON)
   {
      dist = (-boxExtents.x-originBoxCoords.x)/dirBoxCoords.x;
      if (dist >= 0.0)
      {
         point = originBoxCoords+dist*dirBoxCoords;
         if (point.y >= -boxExtents.y && point.y <= boxExtents.y &&
             point.z >= -boxExtents.z && point.z <= boxExtents.z)
         {
            minDist = dist;
         }
      }

      dist = (boxExtents.x-originBoxCoords.x)/dirBoxCoords.x;
      if (dist >= 0.0)
      {
         point = originBoxCoords+dist*dirBoxCoords;
         if (point.y >= -boxExtents.y && point.y <= boxExtents.y &&
             point.z >= -boxExtents.z && point.z <= boxExtents.z)
         {
            if (minDist < 0.0 || minDist > dist)
            {
               minDist = dist;
            }
         }
      }
   }

   if (llFabs(dirBoxCoords.y) > EPSILON)
   {
      dist = (-boxExtents.y-originBoxCoords.y)/dirBoxCoords.y;
      if (dist >= 0.0)
      {
         point = originBoxCoords+dist*dirBoxCoords;
         if (point.x >= -boxExtents.x && point.x <= boxExtents.x &&
             point.z >= -boxExtents.z && point.z <= boxExtents.z)
         {
            if (minDist < 0.0 || minDist > dist)
            {
               minDist = dist;
            }
         }
      }

      dist = (boxExtents.y-originBoxCoords.y)/dirBoxCoords.y;
      if (dist >= 0.0)
      {
         point = originBoxCoords+dist*dirBoxCoords;
         if (point.x >= -boxExtents.x && point.x <= boxExtents.x &&
             point.z >= -boxExtents.z && point.z <= boxExtents.z)
         {
            if (minDist < 0.0 || minDist > dist)
            {
               minDist = dist;
            }
         }
      }
   }

   if (llFabs(dirBoxCoords.z) > EPSILON)
   {
      dist = (-boxExtents.z-originBoxCoords.z)/dirBoxCoords.z;
      if (dist >= 0.0)
      {
         point = originBoxCoords+dist*dirBoxCoords;
         if (point.x >= -boxExtents.x && point.x <= boxExtents.x &&
             point.y >= -boxExtents.y && point.y <= boxExtents.y)
         {
            if (minDist < 0.0 || minDist > dist)
            {
               minDist = dist;
            }
         }
      }

      dist = (boxExtents.z-originBoxCoords.z)/dirBoxCoords.z;
      if (dist >= 0.0)
      {
         point = originBoxCoords+dist*dirBoxCoords;
         if (point.x >= -boxExtents.x && point.x <= boxExtents.x &&
             point.y >= -boxExtents.y && point.y <= boxExtents.y)
         {
            if (minDist < 0.0 || minDist > dist)
            {
               minDist = dist;
            }
         }
      }
   }

   return minDist;
}

Amazing bit of work. I'm trying to find the inverse, outside looking in at a distance up to 30 meters? So, define the box location and size and then shoot rays from an external vector. I've written something like what i need using the SL physics engine but as you would understand that has proven to be a less than ideal solution (not to mention incredibly slow).
This script seems to be assuming your ray source exists within the defined box and then returns the distances to the walls from the inside? Or is there a depth modifier I'm overlooking?

Actually the code should find ANY intersection between the ray and the box as long as the intersection is in front of the origin point (meaning if your eye was at the origin, it would find intersections you are looking at, but not ones behind your head). It should always find such an intersection when you are inside the box. It may or may not find a suitable intersection when the origin is outside the box, depending on where the origin is and the direction the ray is pointing relative to the box.

I'll experiment more, only had half an hour to play with it before i had to DJ an event tonight. Here's the scenario i'm trying to render...

The point of origin exists outside of the box on an xy grid, it fires off the rays toward standard spaced blocks (0.25x0.25 meters is the spacing). i fire a ray toward one of the grid points and need to find out if it passes through box (target) and if so, where. I might have something odd in my rotation math, should the beam direction be entered in radians or degrees?

The beam direction should be a unit vector. A ray is generally described as an origin point and a vector pointing in the direction of travel. For example, an origin of <1,1,1> and a direction of <0,0,-1> would be a ray starting at one along each of the three axes and pointing straight down in the direction of the negative z-axis. All points <1,1,z> with z<1 will be on this ray.

To find the point at which the intersection occurs, just take the distance along the ray (as returned by the ray tracing function I posted above) and plug it back into the equation of the ray: origin+distance*direction.

Thank you for all your help, after posting I started thinking (yes i actually am capable of such a thing) and realized how to make it work. Thank you for a very handy little snip of code, and for letting me say neener neener to those who told me a raytrace function was impossible in LSL.

Hey Hewee, mind if I add that under the Geometric Library? Would be a superb addition since I haven't made any box functions yet. Credit goes to you of course.

Go for it.