The sense of using homogeneous co-ordinates makes the class distinction in position and direction vectors senseless. The w component already _does_ the distinction. For almost all cases w is either 0 (what means you have a direction vector) or else 1 (what means you have a position vector). In fact, every w other than 0 and 1 denote a "de-normalized" position vector that can (and should) be re-normalized by diving by w (yielding in w==1 again). Such de-normalized positions occur sometimes, e.g. in projections, but also by naively applying standard vector math (some eamples follow below).

Now, there are some rules that apply:
a position (w=1) + a direction (w=0) =: a position (w=1)
a position (w=1) - a position (w=1) =: a direction (w=0)
a direction (w=0)+ a direction (w=0) =: a direction (w=0)
a direction (w=0) - a direction (w=0) =: a direction (w=0)

As you can see here, the w component will always be correctly computed by standard vector math. Now look at these cases:

a position (w=1) + a position (w=1) =: what? (w=2)
Here you have to "normalize" the w component by dividing the whole vector by 2. Interpreting the result, you can see that adding 2 position vectors means to compute their barycenter (is it named so? I assume).

norm( a direction ) works as usual, and hence will make a direction vector having unit length.

norm( a position ) divides by the length, so that the w component becomes 1/norm; now, remember to re-normalize the vector, so that w==1, and voila, the vector is the same as before (therefore making a position unit length has no sense at all; think a bit over it, and you'll see its truth; what you actually mean with the "length of a position vector" is its distance from the origin, what actually is the length of a difference and hence direction vector).

Say, homogeneous co-ordinates allow the math to directly show that position and direction vectors are semantically different.

I don't think it ever really makes sense to add two normalized position vectors. For instance, using (P1 + P2) to find the mid-point/barycenter doesn't feel right at all since that's not the correct formula. You would use (P1 + P2)/2. The sum yields a vector with W = 2, which is then divided out by the factor of 1/2 (which incidentally has the same effect of normalization, but only because we're finding the mid-point). But I could just have easily written it as (P1)/2 + (P2)/2, where each point is first multiplied by 1/2 to become de-normalized with W = 1/2, and then two de-normalized vectors are added together to get one with W = 1.

I've actually been thinking a bit about it, and I've come up with a set of rules that seem to unify addition between vectors and positions. They are:
1a) There must always be at least one de-normalized coordinate in the addition.
1b) A coordinate with W != 1 is considered de-normalized.
2) The sum of the W components must be either 0 (for vectors/directions) or 1 (for points).

This seems to take care of all the cases:

Vector + Vector := (two denormalized vectors, result W = 0)
Vector - Vector := (two denormalized vectors, result W = 0)
Vector + Normalized Position := (at least one denormalized vector, result W = 1)
Vector - Normalized Position = Vector + (-Normalized Vector) := (at least one denormalized vector, but result W = -1, thus *undefined*)
Normalized Position + Normalized Position (no denormalized vectors, *undefined*)
Normalized Position - Normalized Position = Normalized Position + (-Normalized Position) := (at least one denormalized vector with W = -1, result has W = 0)
Normalized Position + Vector := (at least one denormalized vector, result W = 1)
Normalized Position - Vector = Normalized Vector + (-Vector) := (at least one denormalized vector, result W = 1)

And the general cases:

Denormalized Position + Denormalized Position := (at least one denormalized vector, defined if result W = 0/1)
Denormalized Position - Denormalized Position = Denormalized Position + (-Denormalized Position) := (at least one denormalized vector, defined if result W = 0/1)
Denormalized Position + (Vector/Normalized Position) := (at least one denormalized vector, defined if result W = 0/1)
Denormalized Position - (Vector/Normalized Position) = Denormalized Position + (-Vector/Normalized Position) := (at least one denormalized vector, defined if result W = 0/1)
(Vector/Normalized Position) + Denormalized Position := (at least one denormalized vector, defined if result W = 0/1)
(Vector/Normalized Position) - Denormalized Position = (Vector/Normalized Position) + (-Denormalized Position) := (at least one denormalized vector, defined if result W = 0/1)

The only issue is that these may not be the best way to implement operations in code, i.e. you wouldn't do (P1)/2 + (P2)/2 because that's two divisions, you'd do (P1 + P2)/2. Also, the above rules only demonstrate the binary operations which would be used in code, however clearly for the rules to apply they need to be extended to all N-ary addition operators.

There may be something I missed, but these feel like a better set of rules to me [smile]

EDIT: So I've been thinking of a few cases where the rules might not make too much sense, for instance during the projection matrix transformation you get a W that isn't necessarily equal to 1 even though matrix transformation is a linear combination of vectors. I suppose you could get around that by pre-diving the matrix by Z, but that just seems like too much work just to get the rules to work out nicely. So maybe they don't apply cleanly in all cases, but just a lot of them.

[Edited by - Zipster on October 1, 2007 5:59:23 PM]

I just wanted to point out that strictly speaking, a 4-vector with homogeneous coordinates whose w component is 0 is *not* the same thing as 3-dimensional vector. The diference is that [1:0:0:0] and [2:0:0:0] are the exact same 4-vector with homogeneous coordinates, but (1,0,0) and (2,0,0) are different 3-dimensional vectors.

A 4-vector with homogeneous coordinates represents a point at infinity.

This doesn't mean that there is anything wrong with Christer Ericson's advice. I have always kept vector and point classes separated and I have never had a problem, but he probably has more experience than I do.