Swizzle-like functionality about mathgl HOT 3 CLOSED

An alternate implementation is to introduce a type Vecf []float32. Swizzle operators would return a Vecf of the correct len (but always with a cap of 4). To use these values as actual vectors, you'd have to call an As method,

func (v Vecf) AsVec2() Vec2f {
    v = v[:2] // Slice to right length
    return Vec2f{v[0], v[1]}
}

Swizzles on Vecf types would always return the correct array:

func (v Vecf) XYY() Vec3f {
   v = v[:4]
   return Vec3f{v[0], v[1], v[1]}
}

This is analogous to glm swizzle operators returning reference types that need to be cast to be used.

Personally, I like the array method better, but I can't deny that the slice method has some nice properties. It also makes Set methods able to increase the size of vectors, which is impossible with the above method without introducing some idiosyncratic copying semantics. Above if I wanted

func (vec *Vec2f) SetXYZ(src Vec3f)

I really don't have anywhere to go. Either the information from the "Z" will be lost, or it will return a totally new Vec3 and won't set the method receiver at all, OR it will return the new Vec3 AND set the receiver. None of these are intuitive.

Alternatively, we could introduce the Vecf type, but only use it when size promotion is required.

from mathgl.

I've decided to not implement swizzle functions for now. They just pollute the namespace too much. If someone really needs to reorder or downslice a Vec3 in a certain way, it's not difficult to write the function themselves. I see no reason to apply code gen for a bunch of inane functions like vec.WYZY()

I will, however, provide aliases for direct element access vec.X() vec.Y() as aliases for vec[0], vec[1], etc. This is already done for the Quat type. My benchmarks show that access in this way is about the same speed as direct array access (Go probably inlines it). I'm only going to provide XYZW style, not RST(U?) or RGBA.

from mathgl.

Sounds good.

from mathgl.