core.simd vectors are limited in a couple of annoying ways.
First, if I define:
@property pure nothrow
{
auto x(float4 v) { return v.ptr[0]; }
auto y(float4 v) { return v.ptr[1]; }
auto z(float4 v) { return v.ptr[2]; }
auto w(float4 v) { return v.ptr[3]; }
void x(ref float4 v, float val) { v.ptr[0] = val; }
void y(ref float4 v, float val) { v.ptr[1] = val; }
void z(ref float4 v, float val) { v.ptr[2] = val; }
void w(ref float4 v, float val) { v.ptr[3] = val; }
}
Then use it like:
float4 a, b;
a.x = a.x + b.x;
it's actually somehow faster than directly using:
a.ptr[0] += b.ptr[0];
However, notice that I can't use '+=' in the first case, because
'x' isn't an lvalue. That's really annoying. Moreover, I can't
assign a vector to anything other than a array of constant
expressions. Which means I have to make functions just to assign
vectors in a convenient way.
float rand = ...;
float4 vec = [rand, 1, 1, 1]; // ERROR: expected constant
Now, none of this would be an issue at all if I could wrap
core.simd vectors into custom structs... but doing that complete
negates their performance gain (I'm guessing because of boxing?).
It's a different between 2-10x speed improvements using float4
directly (depending on CPU), and only a few mil secs improvement
when wrapping float4 in a struct.
So, it's not my ideal situation, but I wouldn't mind at all
having to use core.simd vector types directly, and moving things
like dot/cross/normalize/etc to external functions, but if that's
the case then I would _really_ like some basic usability features
added to the vector types.
Mono C#'s Mono.Simd.Vector4f, etc, types have these basic
features, and working with them is much nicer than using D's
core.simd vectors.
