Vector magic...

Is it possible to discover the vectors for all eight corners of a box by defining two diagonal vectors (right-front-lower corner <---> left-rear-upper corner) ?

It seems that you could get the rotation of the diagonal and copy the defined vectors, rotating them 180 deg. about the x or y axis of the center of the diagonal line. But, I haven't been able to find the key here Thanks!

You might check:
http://rpgstats.com/wiki/index.php?title=LlGetBoundingBox

And then you could do simple adds and subtracts of the vector elements to get all the vertices.

Yeah, that's what got me thinking about doing this, but that is restricted to the size of a prim, or linked set. So, I can't use that because the area could be fairly large. Also, the adding/subtracting only works if the area is aligned directly with world coordinates. if it is rotated at all, it doesn't work.

The minimum amount of information you need to fully specify the vertices of a rectangular prism ("box" are: position (3 degrees of freedom), rotation (3 degrees of freedom), and size (3 degrees of freedom). So in all you need 12 numbers to fully specify the corners. Two 3-component vectors can only specify 6 of them.

EDIT: 3+3+3=9, not 12. Be nice if I could count. Blah!

I would suggest, as perhaps the easiest way of keeping track of the corners, the vector location of one corner, a rotation to specify the orientation of the edges, and a third vector for the scale (just a convenient storage mechanism; though you could also think of it as storing the relative offset of the "opposite corner" in the reference frame specified by the rotation).

vector baseCorner;
rotation orientation;
vector dimensions;
...
vector corner1 = baseCorner;
vector corner2 = baseCorner+<dimensions.x, 0.0, 0.0>*orientation;
vector corner3 = baseCorner+<dimensions.x, dimensions.y, 0.0>*orientation;
vector corner4 = baseCorner+<0.0, dimensions.y, 0.0>*orientation;
vector corner5 = baseCorner+<0.0, 0.0, dimensions.z>*orientation;
vector corner6 = baseCorner+<dimensions.x, 0.0, dimensions.z>*orientation;
vector corner7 = baseCorner+<dimensions.x, dimensions.y, dimensions.z>*orientation;
vector corner8 = baseCorner+<0.0, dimensions.y, dimensions.z>*orientation;

(Note that these values correspond to the basic position and size information available through the LSL library, too: llGetPos(), llGetRot(), and llGetScale(). You COULD store the position of the center of the shape rather than one corner, which would match more closely the definition of llGetPos(). Same amount of information though.)

Yeah, that makes sense. I'm hoping to figure out a way to derive the orientation from the diagonal between the opposite corners. I will try using some of the info you presented to work toward that in the a.m. tnx!

Unfortunately orientation can't quite be nailed down that way. Take a rubix cube, put forefingers on opposite corners, hold it steady, and spin it around the line between your fingers using your thumbs. There's just that one degree of rotational freedom not quite covered by the diagonal. With one MORE of the prism's diagonals you can pin down orientation, though scale isn't fully specified unless an assumption is made about its dimensions (like it being a cube rather than a general rectangular prism).

For that, you would also need to know the proportions of the box. If all you have is vectors indicating the opposite corners, and if orientation of the faces is arbitrary, there are an infinite number of boxes whose opposing corners could be located at those two points. All the two vectors really define in that case, by subtracting one form the other and taking the magnitude, is the diagonal distance. e.g., a distance of ~1.732 could be a cube with sides measuring 1 unit each, or it could be a box with sides measuring 1.25, 1, and 0.661 units.

OK, I see! Ha, this vector/rotation stuff is killing me anyway But, I see now that i need more input to nail down the direction of everything. Thanks for the enlightenment!