[directX] Koordinatensystemprobleme

[Cromon]

Hallo zusammen!

Das Portieren meiner Anwendung von OpenGL nach DirectX bereitet mir irgendwie heute erstaunlich viele Schwierigkeiten...

Jetzt hänge ich an dem Punkt an dem ich die Kamerabewegungen übernehmen möchte. Bewegungen vorwärts und rückwärts gehen bereits einwandfrei mit:

	if(GetAsyncKeyState(0x53) & 0x8000)
	{
		Vector3D cam(camVect.x, camVect.y, camVect.z);
		Vector3D tar(tarVect.x, tarVect.y, tarVect.z);
		Vector3D front = tar - cam;
		front.Normalize();
		front *= ((float)now - lastRender) * -0.3f;
		camVect.x += front.x;
		tarVect.x += front.x;
		camVect.y += front.y;
		tarVect.y += front.y;
		camVect.z += front.z;
		tarVect.z += front.z;
	}

Da habe ich mir gedacht, dass ich das bei den seitlichen Bewegungen auch einfach übernehmen kann und habe daher die gleichen Berechnungen wie in OpenGL gemacht mit:

	if(GetAsyncKeyState(0x41) & 0x8000)
	{
			Matrix3D& m = *Matrix3D::CreateRotation(Vector3D(upVect.x, upVect.y, upVect.z), -M_PI / 2.0f);
			Vector3D cam(camVect.x, camVect.y, camVect.z);
			Vector3D tar(tarVect.x, tarVect.y, tarVect.z);
			Vector3D front = tar - cam;
			front.Normalize();
			front = m * front;
			front *= ((float)now - lastRender) * 0.3f;
			delete &m;
			camVect.x += front.x;
			tarVect.x += front.x;
			camVect.y += front.y;
			tarVect.y += front.y;
			camVect.z += front.z;
			tarVect.z += front.z;
	}

Dabei ist die Rotationsmatrix folgendermassen aufgebaut:

class Matrix3D
{
public:
	float a[3][3];
	static Matrix3D* CreateRotation(Vector3D& normal, float radian)
	{
		Matrix3D* m = new Matrix3D();
		// row 1
		m->a[0][0] = cosf(radian) + powf(normal.x, 2.0f) * (1 - cosf(radian));
		m->a[0][1] = normal.x * normal.y * ( 1 - cosf(radian)) - normal.z * sinf(radian);
		m->a[0][2] = normal.x * normal.z * ( 1 - cosf(radian)) + normal.y * sinf(radian);

		// row 2
		m->a[1][0] = normal.y * normal.z * (1 - cosf(radian)) + normal.z * sinf(radian);
		m->a[1][1] = cosf(radian) + powf(normal.y, 2.0f) * (1 - cosf(radian));
		m->a[1][2] = normal.y * normal.z * (1 - cosf(radian)) - normal.x * sinf(radian);

		// row 3
		m->a[2][0] = normal.z * normal.x * (1 - cosf(radian)) - normal.y * sinf(radian);
		m->a[2][1] = normal.z * normal.y * (1 - cosf(radian)) + normal.x * sinf(radian);
		m->a[2][2] = cosf(radian) + powf(normal.z, 2.0f) * (1 - cosf(radian));

		return m;
	}

	Vector3D operator*(Vector3D& in)
	{
		float x = a[0][0] * in.x + a[0][1] * in.y + a[0][2] * in.z;
		float y = a[1][0] * in.x + a[1][1] * in.y + a[1][2] * in.z;
		float z = a[2][0] * in.x + a[2][1] * in.y + a[2][2] * in.z;

		return Vector3D(x, y, z);
	}
};

Bei OpenGL hat das sehr gut funktioniert, allerdings ist es so, dass ich bei DirectX dabei eine Bewegung schräg nach links oben bekomme statt horizontal aus dem linken Bildschirmrand hinaus.

Mein Aufwärsvektor ist folgendermassen: (0, 0, 1)

Ist das nun ein Problem des Koordinantesystems, oder ist ein Fehler in meiner Berechnung? Ich habe bereits alle Aufwärtsvektoren ausprobiert, aber keiner bringt die Bewegung, die ich erwarte.

/edit:
Die Berechnung scheint eigentlich zu stimmen, denn wenn ich eine Rotation um die eigene Achse mache funktioniert alles!

Gruss
Cromon