Hi folks,

Some time ago, maybe last year, I read a post here at gamedev containing a very cool matrix implemenation in C++ (or a link to that implementation). The cool stuff was accessing both row and column vectors without changing the "simple" memory layout (e.g. a 4x4 matrix needed only 16 * sizeof(float)). IIRC it used function pointers or functors internally.

There was a lengthy discussion with some guys trying to be smarter... but their proposals required additional data members.

My problem: I can't find that post or thread anymore. If your memory or searching skills are better than mine... can you give me a hint?

Thanks,

cdoubleplusgood

Something like this?

[source]
#include <iostream>

struct Vector4
{
Vector4() {}
Vector4(float a, float b, float c, float d) : x(a), y(b), z(c), w(d) {}
float x;
float y;
float z;
float w;
};


struct ConstVector4Column
{
ConstVector4Column(const float* pp)
: mp(pp) {}
const float* mp;
operator Vector4 () const
{
return Vector4( mp[0], mp[4], mp[8], mp[12] );
}
};

struct Vector4Column : public ConstVector4Column
{
Vector4Column(float* pp)
: ConstVector4Column(pp) {}
const Vector4& operator = (const Vector4& v)
{
float* p = const_cast<float*>(mp);
p[0] = v.x;
p[4] = v.y;
p[8] = v.z;
p[12] = v.w;
return v;
}
};

struct Matrix
{
Vector4 x;
Vector4 y;
Vector4 z;
Vector4 w;

Vector4& operator[] (size_t i) { return (&x); }
const Vector4& operator[] (size_t i) const { return (&x); }

Vector4Column operator() (size_t i) { return Vector4Column( (&x.x) + i ); }
ConstVector4Column operator() (size_t i) const { return ConstVector4Column( (&x.x) + i ); }
};

std::ostream& operator << (std::ostream& os, const Vector4& v)
{
return os << v.x << " " << v.y << " " << v.z << " " << v.w << std::endl;
}

int main()
{
Matrix m;
m.x = Vector4(1.0f,2.0f,3.0f,4.0f);
m.y = Vector4(5.0f,6.0f,7.0f,8.0f);
m.z = Vector4(9.0f,10.0f,11.0f,12.0f);
m.w = Vector4(13.0f,14.0f,15.0f,16.0f);

std::cout << m[0] << std::endl;
std::cout << m[1] << std::endl;
std::cout << m[2] << std::endl;
std::cout << m[3] << std::endl;

std::cout << m(0) << std::endl;
std::cout << m(1) << std::endl;
std::cout << m(2) << std::endl;
std::cout << m(3) << std::endl;

return 1;
}

[/source]

Um, no, doesn't ring a bell.

But your code is an option. Thanks.