3. Verschiedene Compilererror

Verschiedene Compilererror

  • ?

    Hallo,

    ich versuche gerade einen Anfang für eine Spiele-Engine zu programmieren und stoße dabei auf die verschiedensten Fehler, die ich leider nicht ganz verstehe. Ich hoffe ihr könnt mir etwas weiterhelfen. (Falls dieses Thema im Spiele-/Grafikprogrammierung-Forum sein sollte tut es mir leid, ich dachte nur, dass mein Problem eher zum Allgemeinen gehört.) Nun folgt ziemlich viel Code:

    icVector3D.h

    /*
*
*
*
*
*
*
*
*
*
*
*
*/
#pragma once

/***********************************************************************/

class IONCORE_API icVector3D
{
public:
	// Variablen
	union
	{
		struct
		{
			float x; 
			float y;
			float z;								// Positionskoordinaten
		};

		struct
		{
			float u;
			float v;
			float w;								// Texturkoordinaten
		};
	};

	////////////////////////////////////
	//			KONSTRUKTOREN
	////////////////////////////////////

	icVector3D ();

	icVector3D (const float _x, const float _y, const float _z)
		: x(_x), y(_y), z(_z)
	{}

	icVector3D (const icVector3D& v)
		: x(v.x), y(v.y), z(v.z)
	{}

	icVector3D (const float* f)
		: x(f[0]), y(f[1]), z(f[2])
	{}

	icVector3D (const D3DVECTOR& v)
		: x(v.x), y(v.y), z(v.z)
	{}

	////////////////////////////////////
	//			OPERATOREN
	///////////////////////////////////

	// Zuweisungsoperatoren

	icVector3D& operator= (const icVector3D& v)
	{
		x = v.x;
		y = v.y;
		z = v.z;

		return *this;
	}

	icVector3D& operator+= (const icVector3D& v)
	{
		x += v.x;
		y += v.y;
		z += v.z;

		return *this;
	}

	icVector3D& operator*= (const icVector3D& v)
	{
		x *= v.x;
		y *= v.y;
		z *= v.z;

		return *this;
	}

	// Mit Skalar
	icVector3D& operator*= (const float f)
	{
		x *= f;
		y *= f;
		z *= f;

		return *this;
	}

	icVector3D& operator/= (const icVector3D& v)
	{
		x /= v.x;
		y /= v.y;
		z /= v.z;

		return *this;
	}

	icVector3D& operator/= (const float f)
	{
		x /= f;
		y /= f;
		z /= f;

		return *this;
	}

	// Casting-Operatoren

	operator D3DVECTOR& ()
	{
		return *((D3DVECTOR*)(this));
	}
};

// Arithmetische Operatoren

inline icVector3D operator+ (const icVector3D& a, const icVector3D& b)
{
	return icVector3D (a.x + b.x, a.y + b.y, a.z + b.z);
}

inline icVector3D operator- (const icVector3D& a, const icVector3D& b)
{
	return icVector3D (a.x - b.x, a.y - b.y, a.z - b.z);
}

/*inline icVector3D operator- (const icVecotor3D& v)
{
	return icVector3D (-v.x, -v.y, -v.z);
}*/

inline icVector3D operator* (const icVector3D& a, const icVector3D& b)
{
	return icVector3D (a.x * b.x, a.y * b.y, a.z * b.z);
}

// Multiplikation mit einem Skalar Nr. 1
inline icVector3D operator* (const icVector3D& v, const float f)
{
	return icVector3D (v.x * f, v.y * f, v.z * f);
}

// 2te Version, weil das Kommunikativgesetz gilt
inline icVector3D operator* (const float f, const icVector3D& v)
{
	return icVector3D (v.x * f, v.y * f, v.z * f);
}

// Division mit einem Skalar
inline icVector3D operator/ (const icVector3D& v, const float f)
{
	return icVector3D (v.x / f, v.y / f, v.z / f);
}

inline icVector3D operator/ (const icVector3D& a, const icVector3D& b)
{
	return icVector3D (a.x / b.x, a.y / b.y, a.z / b.z);
}

// Vergleichsoperatoren

inline bool operator== (const icVector3D& a, const icVector3D& b)
{
	return ((a.x == b.x) && (a.y == b.y) && (a.z == b.z));
}

inline bool operator!= (const icVector3D& a, const icVector3D& b)
{
	return ((a.x != b.x) && (a.y != b.y) && (a.z != b.z));
}

///////////////////////////////////
//			FUNKTIONEN
//////////////////////////////////

// Laenge eines Vektoren
inline float icVector3DLength (const icVector3D& v)
{
	return sqrtf (v.x * v.x + v.y * v.y + v.z * v.z);
}

// ...ohne Wurzel, zum Vergleichen (geht schneller!)
inline float icVector3DLengthSq (const icVector3D& v)
{
	return v.x * v.x + v.y * v.y + v.z * v.z;
}

// Normalisieren eines Vektoren
inline icVector3D icVector3DNormalize (const icVector3D& v)
{
	return v / icVector3DLength (v);
}

// ...EXTENDED: Verhindert Division durch 0 (Präzision geht min. verloren)
inline icVector3D icVector3DNormalizeEx (const icVector3D& v)
{
	return v / (float)(sqrtf (v.x * v.x + v.y * v.y + v.z * v.z) + 0.0001);
}

// Punktprodukt eines Vektoren
inline float icVector3DDotP (const icVector3D& a, const icVector3D& b)
{
	return a.x * b.x + a.y * b.y + a.z * b.z;
}

// Kreuzprodukt eines Vektoren
inline icVector3D icVector3DCrossP (const icVector3D& a, const icVector3D& b)
{
	return icVector3D (a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
}

// Errechnung des Winkels zwischen zwei Vektoren
inline float icVector3DAngle (const icVector3D& a, const icVector3D& b)
{
	return acosf ((a.x * b.x + a.y * b.y + a.z * b.z) / sqrtf ((a.x * a.x + a.y * a.y + a.z * a.z) * (b.x * b.x + b.y * b.y + b.z * b.z)));
}

// Lineare Interpolation zwischen zwei Vektoren
inline icVector3D icVector3DInterpolateCoords (const icVector3D& a, const icVector3D& b, const float p)
{
	return a + p * (b - a);
}

// Normalisiert Interpolieren
inline icVector3D icVector3DInterpolateNormal (const icVector3D& a, const icVector3D& b, const float p)
{
	return icVector3DNormalizeEx (a + p * (b - a));
}

// Größt möglichen Vektor ermitteln
inline icVector3D icVector3DMax (const icVector3D& a, const icVector3D& b)
{
	return icVector3D (IC_MAX (a.x, b.x), IC_MAX (a.y, b.y), IC_MAX (a.z, b.z));
}

// Kleinst möglichen Vektor ermitteln
inline icVector3D icVector3DMin (const icVector3D& a, const icVector3D& b)
{
	return icVector3D (IC_MIN (a.x, b.x), IC_MIN (a.y, b.y), IC_MIN (a.z, b.z));
}

    Die dazugehörige .cpp-Datei ist leer, da alles schon per inline-Funktionen implementiert wurde.

    icMatrix.h

    /*
*
*
*
*
*
*
*
*
*
*
*
*/
#pragma once

// Verwendete Symbole vordefinieren
class icVector3D;
IONCORE_API icMatrix icMatrixInvert (const icMatrix& m);

/************************************************************************/
// Die Matrixklasse

class IONCORE_API icMatrix
{
public:
	union
	{
		struct
		{
			float m11, m12, m13, m14,
				  m21, m22, m23, m24,
				  m31, m32, m33, m34,
				  m41, m42, m43, m44;
		};

		float m[4][4];
	};
	// Casting Operatoren

	operator D3DXMATRIX ()
	{
		return D3DXMATRIX (m11, m12, m13, m14,
						   m21, m22, m23, m24,
						   m31, m32, m33, m34,
						   m41, m42, m43, m44);
	}

	///////////////////////////////////////////
	//				KONSTRUKTOREN
	///////////////////////////////////////////

	icMatrix ();

	icMatrix (float _m11, float _m12, float _m13, float _m14,
			  float _m21, float _m22, float _m23, float _m24,
			  float _m31, float _m32, float _m33, float _m34,
			  float _m41, float _m42, float _m43, float _m44)
			  : m11(_m11), m12(_m12), m13(_m13), m14(_m14),
				m21(_m21), m22(_m22), m23(_m23), m24(_m24),
				m31(_m31), m32(_m32), m33(_m33), m34(_m34),
				m41(_m41), m42(_m42), m43(_m43), m44(_m44)
	{}

	icMatrix (const icMatrix& a)
			  : m11(a.m11), m12(a.m12), m13(a.m13), m14(a.m14),
				m21(a.m21), m22(a.m22), m23(a.m23), m24(a.m24),
				m31(a.m31), m32(a.m32), m33(a.m33), m34(a.m34),
				m41(a.m41), m42(a.m42), m43(a.m43), m44(a.m44)
	{}

	icMatrix (const D3DXMATRIX& m)
			  : m11(m._11), m12(m._12), m13(m._13), m14(m._14),
				m21(m._21), m22(m._22), m23(m._23), m24(m._24),
				m31(m._31), m32(m._32), m33(m._33), m34(m._34),
				m41(m._41), m42(m._42), m43(m._43), m44(m._44)
	{}

	///////////////////////////////////////////
	//				OPERATOREN
	///////////////////////////////////////////

	// Zugriffsoperatoren

	float operator () (int row, int column) const
	{
		return m[row - 1][column - 1];
	}

	// Zuweisungsoperatoren

	icMatrix& operator= (const icMatrix& a)
	{
		m11 = a.m11; m12 = a.m12; m13 = a.m13; m14 = a.m14;
		m21 = a.m21; m22 = a.m22; m23 = a.m23; m24 = a.m24;
		m31 = a.m31; m32 = a.m32; m33 = a.m33; m34 = a.m34;
		m41 = a.m41; m42 = a.m42; m43 = a.m43; m44 = a.m44;

		return *this;
	}

	icMatrix& operator+= (const icMatrix& a)
	{
		m11 += a.m11; m12 += a.m12; m13 += a.m13; m14 += a.m14;
		m21 += a.m21; m22 += a.m22; m23 += a.m23; m24 += a.m24;
		m31 += a.m31; m32 += a.m32; m33 += a.m33; m34 += a.m34;
		m41 += a.m41; m42 += a.m42; m43 += a.m43; m44 += a.m44;

		return *this;
	}

	icMatrix& operator-= (const icMatrix& a)
	{
		m11 -= a.m11; m12 -= a.m12; m13 -= a.m13; m14 -= a.m14;
		m21 -= a.m21; m22 -= a.m22; m23 -= a.m23; m24 -= a.m24;
		m31 -= a.m31; m32 -= a.m32; m33 -= a.m33; m34 -= a.m34;
		m41 -= a.m41; m42 -= a.m42; m43 -= a.m43; m44 -= a.m44;

		return *this;
	}

	icMatrix& operator*= (const icMatrix& a)
	{
		return *this = icMatrix(a.m11 * m11 + a.m21 * m12 + a.m31 * m13 + a.m41 * m14,
								a.m12 * m11 + a.m22 * m12 + a.m32 * m13 + a.m42 * m14,
								a.m13 * m11 + a.m23 * m12 + a.m33 * m13 + a.m43 * m14,
								a.m14 * m11 + a.m24 * m12 + a.m34 * m13 + a.m44 * m14,
								a.m11 * m21 + a.m21 * m22 + a.m31 * m23 + a.m41 * m24,
								a.m12 * m21 + a.m22 * m22 + a.m32 * m23 + a.m42 * m24,
								a.m13 * m21 + a.m23 * m22 + a.m33 * m23 + a.m43 * m24,
								a.m14 * m21 + a.m24 * m22 + a.m34 * m23 + a.m44 * m24,
								a.m11 * m31 + a.m21 * m32 + a.m31 * m33 + a.m41 * m34,
								a.m12 * m31 + a.m22 * m32 + a.m32 * m33 + a.m42 * m34,
								a.m13 * m31 + a.m23 * m32 + a.m33 * m33 + a.m43 * m34,
								a.m14 * m31 + a.m24 * m32 + a.m34 * m33 + a.m44 * m34,
								a.m11 * m41 + a.m21 * m42 + a.m31 * m43 + a.m41 * m44,
								a.m12 * m41 + a.m22 * m42 + a.m32 * m43 + a.m42 * m44,
								a.m13 * m41 + a.m23 * m42 + a.m33 * m43 + a.m43 * m44,
								a.m14 * m41 + a.m24 * m42 + a.m34 * m43 + a.m44 * m44);
	}

	icMatrix& operator/= (const icMatrix& a)
	{
		return *this *= icMatrixInvert(a);
	}

	icMatrix& operator/= (const float f)
	{
		m11 /= f; m12 /= f; m13 /= f; m14 /= f;
		m21 /= f; m22 /= f; m23 /= f; m24 /= f;
		m31 /= f; m32 /= f; m33 /= f; m34 /= f;
		m41 /= f; m42 /= f; m43 /= f; m44 /= f;

		return *this;
	}
};

// Arithmetische Operatoren

inline icMatrix operator+ (const icMatrix& a, const icMatrix& b)
{
	return icMatrix (a.m11 + b.m11, a.m12 + b.m12, a.m13 + b.m13, a.m14 + b.m14,
					 a.m21 + b.m21, a.m22 + b.m22, a.m23 + b.m23, a.m24 + b.m24,
					 a.m31 + b.m31, a.m32 + b.m32, a.m33 + b.m33, a.m34 + b.m34,
					 a.m41 + b.m41, a.m42 + b.m42, a.m43 + b.m43, a.m44 + b.m44);
}

inline icMatrix operator- (const icMatrix& a, const icMatrix& b)
{
	return icMatrix (a.m11 - b.m11, a.m12 - b.m12, a.m13 - b.m13, a.m14 - b.m14,
					 a.m21 - b.m21, a.m22 - b.m22, a.m23 - b.m23, a.m24 - b.m24,
					 a.m31 - b.m31, a.m32 - b.m32, a.m33 - b.m33, a.m34 - b.m34,
					 a.m41 - b.m41, a.m42 - b.m42, a.m43 - b.m43, a.m44 - b.m44);
}

inline icMatrix operator* (const icMatrix& a, const icMatrix& b)
{
	return icMatrix (b.m11 * a.m11 + b.m21 * a.m12 + b.m31 * a.m13 + b.m41 * a.m14,
					 b.m12 * a.m11 + b.m22 * a.m12 + b.m32 * a.m13 + b.m42 * a.m14,
					 b.m13 * a.m11 + b.m23 * a.m12 + b.m33 * a.m13 + b.m43 * a.m14,
					 b.m14 * a.m11 + b.m24 * a.m12 + b.m34 * a.m13 + b.m44 * a.m14,
					 b.m11 * a.m21 + b.m21 * a.m22 + b.m31 * a.m23 + b.m41 * a.m24,
					 b.m12 * a.m21 + b.m22 * a.m22 + b.m32 * a.m23 + b.m42 * a.m24,
					 b.m13 * a.m21 + b.m23 * a.m22 + b.m33 * a.m23 + b.m43 * a.m24,
					 b.m14 * a.m21 + b.m24 * a.m22 + b.m34 * a.m23 + b.m44 * a.m24,
					 b.m11 * a.m31 + b.m21 * a.m32 + b.m31 * a.m33 + b.m41 * a.m34,
					 b.m12 * a.m31 + b.m22 * a.m32 + b.m32 * a.m33 + b.m42 * a.m34,
					 b.m13 * a.m31 + b.m23 * a.m32 + b.m33 * a.m33 + b.m43 * a.m34,
					 b.m14 * a.m31 + b.m24 * a.m32 + b.m34 * a.m33 + b.m44 * a.m34,
					 b.m11 * a.m41 + b.m21 * a.m42 + b.m31 * a.m43 + b.m41 * a.m44,
					 b.m12 * a.m41 + b.m22 * a.m42 + b.m32 * a.m43 + b.m42 * a.m44,
					 b.m13 * a.m41 + b.m23 * a.m42 + b.m33 * a.m43 + b.m43 * a.m44,
					 b.m14 * a.m41 + b.m24 * a.m42 + b.m34 * a.m43 + b.m44 * a.m44);
}

// Mit Skalar
inline icMatrix operator* (const icMatrix& a, const float f)
{
	return icMatrix (a.m11 * f, a.m12 * f, a.m13 * f, a.m14 * f,
					 a.m21 * f, a.m22 * f, a.m23 * f, a.m24 * f,
					 a.m31 * f, a.m32 * f, a.m33 * f, a.m34 * f,
					 a.m41 * f, a.m42 * f, a.m43 * f, a.m44 * f);
}

// ...wegen Kommunikativgesetz
inline icMatrix operator* (const float f, const icMatrix& a)
{
	return icMatrix (a.m11 * f, a.m12 * f, a.m13 * f, a.m14 * f,
					 a.m21 * f, a.m22 * f, a.m23 * f, a.m24 * f,
					 a.m31 * f, a.m32 * f, a.m33 * f, a.m34 * f,
					 a.m41 * f, a.m42 * f, a.m43 * f, a.m44 * f);
}

inline icMatrix operator/ (const icMatrix& a, const float f)
{
	return icMatrix (a.m11 / f, a.m12 / f, a.m13 / f, a.m14 / f,
					 a.m21 / f, a.m22 / f, a.m23 / f, a.m24 / f,
					 a.m31 / f, a.m32 / f, a.m33 / f, a.m34 / f,
					 a.m41 / f, a.m42 / f, a.m43 / f, a.m44 / f);
}

inline icMatrix operator/ (const icMatrix& a, const icMatrix& b)
{
	return a * icMatrixInvert(b);
}

// Vergleichsoperatoren

inline bool operator== (const icMatrix& a, const icMatrix& b)
{
	return ((a.m11 == b.11) && (a.m12 == b.12) && (a.m13 == b.13) && (a.m14 == b.14) &&
			(a.m21 == b.21) && (a.m22 == b.22) && (a.m23 == b.23) && (a.m24 == b.24) &&
			(a.m31 == b.31) && (a.m32 == b.32) && (a.m33 == b.33) && (a.m24 == b.34) &&
			(a.m41 == b.41) && (a.m42 == b.42) && (a.m43 == b.43) && (a.m44 == b.44));
}

inline bool operator!= (const icMatrix& a, const icMatrix& b)
{
	return ((a.m11 != b.11) && (a.m12 != b.12) && (a.m13 != b.13) && (a.m14 != b.14) &&
			(a.m21 != b.21) && (a.m22 != b.22) && (a.m23 != b.23) && (a.m24 != b.24) &&
			(a.m31 != b.31) && (a.m32 != b.32) && (a.m33 != b.33) && (a.m24 != b.34) &&
			(a.m41 != b.41) && (a.m42 != b.42) && (a.m43 != b.43) && (a.m44 != b.44));
}

/////////////////////////////////////
//			FUNKTIONEN
/////////////////////////////////////

/****************************************************************************/
inline icMatrix icMatrixIdentity ()								// Identitätsmatrix liefern
{
	return icMatrix (1.0, 0.0, 0.0, 0.0,
					 0.0, 1.0, 0.0, 0.0,
					 0.0, 0.0, 1.0, 0.0,
					 0.0, 0.0, 0.0, 1.0);
}

IONCORE_API icMatrix icMatrixTranslation  (const icVector3D& v);																				// Translation
IONCORE_API icMatrix icMatrixRotationX	  (const float f);																						// Rotation um X-Achse
IONCORE_API icMatrix icMatrixRotationY	  (const float f);																						// Rotation um Y-Achse
IONCORE_API icMatrix icMatrixRotationZ	  (const float f);																						// Rotation um Z-Achse
IONCORE_API icMatrix icMatrixRotation	  (const float x, const float y, const float z);														// Rotation um alle drei Achsen
IONCORE_API icMatrix icMatrixRotation	  (const icVector3D& v);																				// Rotation um alle drei Achsen
IONCORE_API icMatrix icMatrixRotationAxis (const icVector3D& v, const float f);																	// Rotation um beliebige Achse
IONCORE_API icMatrix icMatrixScale		  (const icVector3D& v);																				// Skalieren
IONCORE_API icMatrix icMatrixAxes		  (const icVector3D& XAxis, const icVector3D& YAxis, const icVector3D& ZAxis);							// Achsenmatrix
IONCORE_API float	 icMatrixDet		  (const icMatrix& m);																					// Determinante
IONCORE_API icMatrix icMatrixInvert		  (const icMatrix& m);																					// Matrix invertieren
IONCORE_API icMatrix icMatrixTranspose	  (const icMatrix& m);																					// Matrix transponieren
IONCORE_API icMatrix icMatrixProjection	  (const float FOV, const float Aspect, const float NearPlane, const float FarPlane);					// Projektionsmatrix
IONCORE_API icMatrix icMatrixCamera		  (const icVector3D& Pos, const icVector3D& LookAt, const icVector3D& Up = icVector3D(0.0,1.0,0.0);		// Kameramatrix
/****************************************************************************/

    icMatrix.cpp

    /*
*
*
*
*
*
*
*
*
*
*
*
*/
#include <IonCore.h>

/***********************************************************************/
//////////////////////////////////////
//			FUNKTIONEN
//////////////////////////////////////

// Translation
IONCORE_API icMatrix icMatrixTranslation (const icVector3D& v)
{
	return icMatrix (1.0, 0.0, 0.0, 0.0,
					 0.0, 1.0, 0.0, 0.0,
					 0.0, 0.0, 1.0, 0.0,
					 v.x, v.y, v.z, 1.0);
}

// Rotation um X-Achse
IONCORE_API icMatrix icMatrixRotationX (const float f)
{
	return icMatrix (1.0, 0.0, 0.0, 0.0,
					 0.0, cosf(f), sinf(f), 0.0,
					 0.0, -sin(f), cos(f), 0.0,
					 0.0, 0.0, 0.0, 1.0);
}

// Rotation um Y-Achse
IONCORE_API icMatrix icMatrixRotationY (const float f)
{
	return icMatrix (cosf(f), 0.0, -sinf(f), 0.0,
					 0.0, 1.0, 0.0, 0.0,
					 sinf(f), 0.0, cosf(f), 0.0,
					 0.0, 0.0, 0.0, 1.0);
}

// Rotation um Z-Achse
IONCORE_API icMatrix icMatrixRotationZ (const float f)
{
	return icMatrix (cosf(f), sinf(f), 0.0, 0.0,
					 -sinf(f), cosf(f), 0.0, 0.0,
					 0.0, 0.0, 1.0, 0.0,
					 0.0, 0.0, 0.0, 1.0);
}

// Rotation um alle drei Achsen
IONCORE_API icMatrix icMatrixRotation	  (const float x, const float y, const float z)
{
	return icMatrixRotationZ(z) * icMatrixRotationX(x) * icMatrixRotationY(y);
}

// Rotation um alle drei Achsen
IONCORE_API icMatrix icMatrixRotation	  (const icVector3D& v)
{
	return icMatrixRotationZ(v.z) * icMatrixRotationX(v.x) * icMatrixRotationY(v.y);
}

// Rotation um beliebige Achse
IONCORE_API icMatrix icMatrixRotationAxis (const icVector3D& v, const float f)
{
	const float Sin			= sinf(-f);
	const float Cos			= cosf(-f);
	const float CosMinusOne	= 1 - Cos;
	const icVector3D Axis (icVector3DNormalize(v));			// Achsenvektor normalisieren

	return icMatrix(Axis.x * Axis.x * CosMinusOne + Cos,
					Axis.x * Axis.y * CosMinusOne - Axis.z * Sin,
					Axis.x * Axis.z * CosMinusOne + Axis.y * Sin,
					0.0,
					Axis.x * Axis.y * CosMinusOne + Axis.z * Sin,
					Axis.y * Axis.y * CosMinusOne + Cos,
					Axis.y * Axis.z * CosMinusOne - Axis.x * Sin,
					0.0,
					Axis.x * Axis.z * CosMinusOne - Axis.y * Sin,
					Axis.y * Axis.z * CosMinusOne + Axis.x * Sin,
					Axis.z * Axis.z * CosMinusOne + Cos,
					0.0,
					0.0,
					0.0,
					0.0,
					1.0);
}

// Skalieren
IONCORE_API icMatrix icMatrixScale (const icVector3D& v)
{
	return icMatrix(v.x, 0.0, 0.0, 0.0,
					0.0, v.y, 0.0, 0.0,
					0.0, 0.0, v.z, 0.0,
					0.0, 0.0, 0.0, 1.0);
}

// Achsenmatrix
IONCORE_API icMatrix icMatrixAxes (const icVector3D& XAxis, const icVector3D& YAxis, const icVector3D& ZAxis)
{
	return icMatrix (XAxis.x, XAxis.y, XAxis.z, 0.0,
					 YAxis.x, YAxis.y, YAxis.z, 0.0,
					 ZAxis.x, ZAxis.y, ZAxis.z, 0.0,
					 0.0,	  0.0,	   0.0,		1.0);
}

// Derterminante
IONCORE_API float icMatrixDet (const icMatrix& m)
{
	return m.m11 * (m.m22 * m.m33 - m.m23 * m.m32) -
           m.m12 * (m.m21 * m.m33 - m.m23 * m.m31) +
           m.m13 * (m.m21 * m.m32 - m.m22 * m.m31);
}

// Matrix invertieren
IONCORE_API icMatrix icMatrixInvert (const icMatrix& m)
{
	float InvDet = icMatrixDet(m);

	if (InvDet == 0.0)
		return icMatrixIdentity();
	InvDet = 1.0 / InvDet;

	// Invertierte Matrix berechnen
	icMatrix Result;
	Result.m11 =  InvDet * (m.m22 * m.m33 - m.m23 * m.m32);
	Result.m12 = -InvDet * (m.m12 * m.m33 - m.m13 * m.m32);
	Result.m13 =  InvDet * (m.m12 * m.m23 - m.m13 * m.m22);
	Result.m14 =  0.0f;
	Result.m21 = -InvDet * (m.m21 * m.m33 - m.m23 * m.m31);
	Result.m22 =  InvDet * (m.m11 * m.m33 - m.m13 * m.m31);
	Result.m23 = -InvDet * (m.m11 * m.m23 - m.m13 * m.m21);
	Result.m24 =  0.0f;
	Result.m31 =  InvDet * (m.m21 * m.m32 - m.m22 * m.m31);
	Result.m32 = -InvDet * (m.m11 * m.m32 - m.m12 * m.m31);
	Result.m33 =  InvDet * (m.m11 * m.m22 - m.m12 * m.m21);
	Result.m34 =  0.0f;
	Result.m41 = -(m.m41 * Result.m11 + m.m42 * Result.m21 + m.m43 * Result.m31);
	Result.m42 = -(m.m41 * Result.m12 + m.m42 * Result.m22 + m.m43 * Result.m32);
	Result.m43 = -(m.m41 * Result.m13 + m.m42 * Result.m23 + m.m43 * Result.m33);
	Result.m44 =  1.0f;

	return Result;
}

// Matrix transponieren
IONCORE_API icMatrix icMatrixTranspose (const icMatrix& m)
{
	return icMatrix (m.m11, m.m21, m.m31, m.m41,
					 m.m12, m.m22, m.m32, m.m42,
					 m.m13, m.m23, m.m33, m.m43,
					 m.m14, m.m24, m.m34, m.m44);
}

// Projektionsmatrix
IONCORE_API icMatrix icMatrixProjection (const float FOV, const float Aspect, const float NearPlane, const float FarPlane)
{
	const float s = 1.0 / tanf(FOV * 0.5);
	const float Q = FarPlane / (FarPlane - NearPlane);

	return icMatrix (s/Aspect, 0.0, 0.0, 0.0,
					 0.0, s, 0.0, 0.0,
					 0.0, 0.0, Q, 1.0,
					 0.0, 0.0, -Q*NearPlane, 0.0);
}

// Kameramatrix
IONCORE_API icMatrix icMatrixCamera (const icVector3D& Pos, const icVector3D& LookAt, const icVector3D& Up = icVector3D(0.0,1.0,0.0))
{
	// Z-Achse berechenen
	icVector3D ZAxis (icVector3DNormalize (LookAt - Pos));

	// X-Achse: Kreuzprodukt aus Y- und Z-Achse
	icVector3D XAxis (icVector3DCrossP(Up, ZAxis));

	// Y-Achse: Kreuzprodukt aus X- und Z-Achse
	icVector3D YAxis (icVector3DCrossP(XAxis, ZAxis));

	// Translations- mit Rotationsmatrix multiplizieren
	return icMatrixTranslation (-Pos) *
		   icMatrix (XAxis.x, YAxis.x, ZAxis.x, 0.0,
					 XAxis.y, YAxis.y, ZAxis.y, 0.0,
					 XAxis.z, YAxis.z, ZAxis.z, 0.0,
					 0.0	, 0.0	 , 0.0	  , 1.0);
}

    **
    IonCore.h**

    /*
*
*
*
*
*
*
*
*
*
*
*
*/
#pragma once

#ifdef IONCORE_EXPORT
#define IONCORE_API __declspec(dllexport)
#else
#define IONCORE_API __declspec(dllimport)
#endif

#ifdef _DEBUG
#define D3D_DEBUG_INFO
#endif

#pragma warning(disable:4995 4996)

// In allen Headern benötigte Bibliotheken
#include <Windows.h>
#include <StdIO.h>
#include <Math.h>
#include <D3D9.h>
#include <D3DX9.h>

// Allgemeine Makros
#define IC_MAX(a, b)	 ((a) > (b) ? (a) : (b))						// Maximaler Wert
#define IC_MIN(a, b)	 ((a) < (b) ? (a) : (b))						// Minimaler Wert
#define IC_PI			 (3.1415926535897932384626433832795)			// Pi
#define IC_DEG_TO_RAD(x) ((x) * 0.0174532925199432957692369076848)		// Grad -> Bogenmaß
#define IC_RAD_TO_DEG(x) ((x) * 57.295779513082320876798154814105)		// Bogenmaß -> Grad

#define IC_SAFE_DELETE(x)		{if(x) {delete (x); (x) = NULL;}}		// Sicheres Löschen
#define IC_SAFE_DELETE_ARRAY(x)	{if(x) {delete[] (x); (x) = NULL;}}		// Sicheres Array Löschen
#define IC_SAFE_RELEASE(x)		{if(x) {(x)->Release(); (x) = NULL;}}	// Sicheres COM-Objekte Löschen

/*******************************************************************/
// Allegmeiner Rückgabewert

enum icResult
{
	IC_OK			= 0,		// Erfolg
	IC_ERROR		= 1,		// Fehler
	IC_CANCELED		= 2,		// Abgebrochen
	IC_NOT_FOUND	= 3,		// Nicht gefunden
	IC_STOP			= 4			// Stopp (Vorgang abbrechen)
};

/*****************************************************************************/
// Header der Engine einbinden

#include "icVector3D.h"
#include "icMatrix.h"

    VC++ Ausgabe:

    1>------ Erstellen gestartet: Projekt: IonCore, Konfiguration: Debug Win32 ------
1>Kompilieren...
1>icMatrix.cpp
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(18) : error C2146: Syntaxfehler: Fehlendes ';' vor Bezeichner 'icMatrixInvert'
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(18) : error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(18) : error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(18) : error C2143: Syntaxfehler: Es fehlt ',' vor '&'
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(18) : error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(143) : error C2664: 'icMatrixInvert': Konvertierung des Parameters 1 von 'const icMatrix' in 'const int' nicht möglich
1>        Kein benutzerdefinierter Konvertierungsoperator verfügbar, der diese Konvertierung durchführen kann, oder der Operator kann nicht aufgerufen werden
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(159) : error C2143: Syntaxfehler: Es fehlt ';' vor '+'
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(159) : error C2433: 'icMatrix': 'inline' bei der Deklaration von Daten nicht zulässig
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(159) : error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(159) : error C2086: 'int icMatrix': Neudefinition
1>        d:\spieleprogrammierung\ioncore\include\icmatrix.h(18): Siehe Deklaration von 'icMatrix'
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(159) : error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(159) : error C2143: Syntaxfehler: Es fehlt ',' vor '&'
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(160) : error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(160) : error C2803: Operator '+' muss mindestens einen formalen Parameter vom Typ Klasse haben
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(161) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(161) : error C2228: Links von ".m11" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(161) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(161) : error C2228: Links von ".m11" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(161) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(161) : error C2228: Links von ".m12" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(161) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(161) : error C2228: Links von ".m12" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(161) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(161) : error C2228: Links von ".m13" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(161) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(161) : error C2228: Links von ".m13" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(161) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(161) : error C2228: Links von ".m14" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(161) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(161) : error C2228: Links von ".m14" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(162) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(162) : error C2228: Links von ".m21" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(162) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(162) : error C2228: Links von ".m21" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(162) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(162) : error C2228: Links von ".m22" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(162) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(162) : error C2228: Links von ".m22" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(162) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(162) : error C2228: Links von ".m23" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(162) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(162) : error C2228: Links von ".m23" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(162) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(162) : error C2228: Links von ".m24" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(162) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(162) : error C2228: Links von ".m24" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(163) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(163) : error C2228: Links von ".m31" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(163) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(163) : error C2228: Links von ".m31" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(163) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(163) : error C2228: Links von ".m32" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(163) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(163) : error C2228: Links von ".m32" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(163) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(163) : error C2228: Links von ".m33" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(163) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(163) : error C2228: Links von ".m33" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(163) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(163) : error C2228: Links von ".m34" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(163) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(163) : error C2228: Links von ".m34" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(164) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(164) : error C2228: Links von ".m41" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(164) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(164) : error C2228: Links von ".m41" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(164) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(164) : error C2228: Links von ".m42" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(164) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(164) : error C2228: Links von ".m42" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(164) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(164) : error C2228: Links von ".m43" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(164) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(164) : error C2228: Links von ".m43" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(164) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(164) : error C2228: Links von ".m44" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(164) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(164) : error C2228: Links von ".m44" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(164) : error C2064: Ausdruck ergibt keine Funktion, die 16 Argumente übernimmt
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(167) : error C2143: Syntaxfehler: Es fehlt ';' vor '-'
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(167) : error C2433: 'icMatrix': 'inline' bei der Deklaration von Daten nicht zulässig
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(167) : error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(167) : error C2086: 'int icMatrix': Neudefinition
1>        d:\spieleprogrammierung\ioncore\include\icmatrix.h(18): Siehe Deklaration von 'icMatrix'
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(167) : error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(167) : error C2143: Syntaxfehler: Es fehlt ',' vor '&'
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(168) : error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(168) : error C2803: Operator '-' muss mindestens einen formalen Parameter vom Typ Klasse haben
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(169) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(169) : error C2228: Links von ".m11" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(169) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(169) : error C2228: Links von ".m11" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(169) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(169) : error C2228: Links von ".m12" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(169) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(169) : error C2228: Links von ".m12" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(169) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(169) : error C2228: Links von ".m13" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(169) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(169) : error C2228: Links von ".m13" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(169) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(169) : error C2228: Links von ".m14" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(169) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(169) : error C2228: Links von ".m14" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(170) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(170) : error C2228: Links von ".m21" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(170) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(170) : error C2228: Links von ".m21" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(170) : error C2065: 'a': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(170) : error C2228: Links von ".m22" muss sich eine Klasse/Struktur/Union befinden.
1>        Typ ist ''unknown-type''
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(170) : error C2065: 'b': nichtdeklarierter Bezeichner
1>d:\spieleprogrammierung\ioncore\include\icmatrix.h(170) : fatal error C1003: Mehr als 100 Fehler gefunden; Kompilierung wird abgebrochen.
1>Das Buildprotokoll wurde unter "file://d:\Spieleprogrammierung\IonCore\IonCore\IonCore\Debug\BuildLog.htm" gespeichert.
1>IonCore - 111 Fehler, 0 Warnung(en)
========== Erstellen: 0 erfolgreich, Fehler bei 1, 0 aktuell, 0 übersprungen ==========

    Es tut mir eid, dass ich euch so mit Code überfallen muss, aber ich sehe den Ursprung der Fehler einfach nicht. Ich vermute, dass irgendwo ein Fehler ist und, dass der sich dann auf den Rest auswirkt.

    0
  • D

    Schau doch mal in der Zeile nach, wo die Meldung hinzeigt.. Steht ja, wo er den Fehler gefunden hat.
    Da scheint ein Typ nicht bekannt zu sein. Du wirst also ein Header vergessen haben einzubinden.

    btw:
    Eine Engine schreiben zu wollen ohne genug Erfahrung in der allgemeinen Programmierung ist zum scheitern verurteilt.. Im übrigen ist die Implementierung von Matrizen Klassen auch keine gute Idee das selber zu machen.. warum und wieso kannst du im Spieleunterforum nachfragen.

    0
  • ?

    Okay, ich denke ich habe den Fehler gefunden. Zwar kann ich ihn noch nicht lösen, aber vielleicht könnt ihr mir dabei etwas helfen... Also ich habe mal versucht die Datei icMatrix.cpp aus dem Projekt zu entfernen und: Keine Fehler, alles läuft perfekt! Folglich liegt es der Fehler nicht in der Headerdetei icMatrix.h. Dann habe ich die Datei icMatrix.cpp, wieder hinzugefügt und den ganzen Code auskommentiert, bis auf #include <IonCore.h> und: Alle Fehler wie oben werden wieder angezeigt. Das heißt also, dass deine Vermutung anscheinend richtig ist: Eine Headerdatei ist nicht eingebunden. Ich habe vorher natürlich über Extras -> Optionen... -> Projekte und Projektmappen -> VC++-Verzeichnisse unter Includedateien den Pfad der Datei IonCore.h angegeben. Habe ich vielleicht etwas vergessen?

    P.S: Ich verstehe deine Kritik und weiß sie auch zu schätzen, aber ich versuche nicht eine ganze Engine (wie bei Profis) zu programmieren, sondern nur ein paar Basisklassen und Funktionen einzubetten. Wenn du sagst, dass die Implementierung von Matrizen nicht sinnvoll ist, dann werde ich mich später nochmal im Spielprogrammierung-Forum informieren, das Problem liegt trotzdem nicht in der Matrixklasse (oder den Funktionen), sondern wahrscheinlich an der Headerdatei die nicht gefunden wird oder so. Deshalb ist es ja erstmal egal was ich reinpacke in die Engine, der Fehler wird überall so sein.

    0
  • ?

    Okay, ich will ja nicht drängen, aber hat keiner irgendeine Idee, was ich falsch gemacht haben könnte?

    0
  • ?

    1.) #pragma once ist Visual Studio spezifisch und scheisse. Das macht deinen Code inportabel. Vielleicht in dem Fall nicht so schlimm, ich mags trotzdem nicht. Nutze include-guards.

    2.) In icMatrix.h verwendest du in Zeile 18 icMatrix bevor die Klasse definiert wird. Schreib die Funktionsdeklaration unter die Klasse.

    0
  • ?

    icMatrix.h, Zeile 18:
    IONCORE_API icMatrix icMatrixInvert (const icMatrix& m);

    Was der Compiler zu dem Zeitpunkt nicht kennt:
    IONCORE_AP und icMatrix .

    Und dass die Fehler nicht auftreten, wenn icMatrix.cpp aus dem Projekt raus ist, sollte auch klar sein: Dann wird deine icMatrix.h wohl nirgendwo anders verwendet, d.h. vom Compiler auch niemals geparst => Er kann sich also gar nicht beklagen.

    0
  • N

    Scorcher24 schrieb:

    1.) #pragma once ist Visual Studio spezifisch

    Nein.

    Scorcher24 schrieb:

    Vielleicht in dem Fall nicht so schlimm, ich mags trotzdem nicht. Nutze include-guards.

    Wenn man nicht alle Compiler unterstützen will, kann man das ruhig machen, auch wenn du es nicht magst. Man muss sich nämlich keine Makros ausdenken und gegebenenfalls ändern, hat weniger zu schreiben und der Präprozessorvorgang läuft möglicherweise schneller ab. Auch wenn das keine enormen Vorteile sind.

    Viel schlimmer finde ich z.B., dass alles inline ist, dass merkwürdige Operatoren wie / auf Vektoren definiert werden, dass Code nicht wiederverwendet wird und dass durch Zeiger-Umbiegen undefiniertes Verhalten entsteht. Der Grund für solchen Code besteht wahrscheinlich in diversen Performancemythen.

    0
  • D

    Nexus schrieb:

    Scorcher24 schrieb:

    Vielleicht in dem Fall nicht so schlimm, ich mags trotzdem nicht. Nutze include-guards.

    Wenn man nicht alle Compiler unterstützen will, kann man das ruhig machen, auch wenn du es nicht magst. Man muss sich nämlich keine Makros ausdenken und gegebenenfalls ändern, hat weniger zu schreiben und der Präprozessorvorgang läuft möglicherweise schneller ab. Auch wenn das keine enormen Vorteile sind.

    Wenn man beide Vorteile will, dann macht man eben beides. Wenn der Compiler das pragma nicht unterstützt (ursprünglich war es afaik nur VS-spezifisch), dann wird es einfach ignoriert und die include guards greifen.
    Makros denke ich mir nie selber aus. Die werden von einem kleinen Addin, dass ich für VS gemacht habe automatisch generiert (wie auch das ganze Standard Zeugs, wie include guards und passende .cpp), wenn ich eine Datei (.h) anlege.

    0
  • N

    drakon schrieb:

    Wenn man beide Vorteile will, dann macht man eben beides.

    Das hingegen vereint wirklich nur Nachteile, es sei denn, man ist auf die Präprozessorgeschwindigkeit angewiesen. Ansonsten gibt es mehr zu schreiben, mit Dateinamen konsistent zu halten, und auf anderen Compilern hat man lästige Warnungen (es sei denn, man führt noch weitere #ifdef s ein, was aber definitiv hässlich wird).

    0
  • D

    Also Headerguards selbst zu schreiben ist unsinnig. Die kann man sich schön generieren lassen und dann mit einem Zeitstempel drin und man hat nie Probleme mit Konsistenz (wer zwingt denn einen den mit dem Dateinamen zu identifizieren? Projektname und Zeitstempel sollten ausreichend sein). Und dass es Warnungen gibt wüsste ich jetzt nicht und wenn schon kann man, wenn die einen stören ja bestimmt irgendwo ausschalten. Und selbst wenn nicht habe ich lieber ein paar Warnungen, als etwas, dass nicht kompiliert.

    Ob ich jetzt mit oder ohne Headguards/pragma die Dateien erzeuge spielt für mich keine Rolle, aber funktionieren tut es dann überall und dort, wo es geht auch noch ein wenig schneller.

    Aber ich weiss auch nicht, warum wir hier über solchen Nonsens diskutieren müssen.

    0
  • N

    drakon schrieb:

    Also Headerguards selbst zu schreiben ist unsinnig.

    Wäre dies so, würden das nicht etliche C++-Bibliotheken tun.

    drakon schrieb:

    Aber ich weiss auch nicht, warum wir hier über solchen Nonsens diskutieren müssen.

    Ich hab Scorcher24 lediglich darauf hingewiesen, dass #pragma once manchmal gerechtfertigt sei. Es hat dich niemand gezwungen, darauf zu antworten.

    0
  • D

    Nexus schrieb:

    drakon schrieb:

    Also Headerguards selbst zu schreiben ist unsinnig.

    Wäre dies so, würden das nicht etliche C++-Bibliotheken tun.

    Woher weisst du wie die ihre Headerguards erstellen?

    Nexus schrieb:

    drakon schrieb:

    Aber ich weiss auch nicht, warum wir hier über solchen Nonsens diskutieren müssen.

    Ich hab Scorcher24 lediglich darauf hingewiesen, dass #pragma once manchmal gerechtfertigt sei. Es hat dich niemand gezwungen, darauf zu antworten.

    Ich habe ergänzt, dass man beides machen kann und du hast gesagt, dass es nur Nachteile hat und dann lediglich Tipparbeit und Warnungen genannt und dass das keine wirklichen Punkte sind habe ich ja bereits gesagt.

    Ob die Vorteile(kompiliert überall und dort wo es geht auch noch schneller) die Nachteile(ev. (abschaltbare) Warnungen) überwiegen muss jeder selbst entscheiden. Die einzelnen Versionen haben jeweils Nachteile, welche die vereinte Variante nicht hat (kompiliert nicht überall, resp. langsamer).

    0
  • N

    drakon schrieb:

    Woher weisst du wie die ihre Headerguards erstellen?

    Sie enthalten zumindest keine Timestamps und sind semantisch nach den Inhalten der Datei benannt. Ob gar kein Tool verwendet wird, oder ein Snippet, zu dem man nur noch den Makro-Namen eingibt o.Ä., kann ich nicht sagen.

    drakon schrieb:

    Ich habe ergänzt, dass man beides machen kann und du hast gesagt, dass es nur Nachteile hat

    ...sofern man nicht auf den Geschwindigkeitsgewinn durch #pragma once angewiesen ist.

    drakon schrieb:

    und dann lediglich Tipparbeit und Warnungen genannt und dass das keine wirklichen Punkte sind habe ich ja bereits gesagt.

    Ja, die Unwichtigkeit habe sogar ich schon mit "Auch wenn das keine enormen Vorteile sind" im ersten Post angedeutet. 😉

    Aber stimmt schon, gross zu diskutieren lohnt sich nicht. Zumal wir das wahrscheinlich recht ähnlich sehen, aber wohl ein wenig aneinander vorbeigeredet haben...

    0
  • ?

    Danke, das war der Grund! Da war nur noch ein Problem: In der Klasse habe ich inline einen Operator /= definiert, jetzt habe ich den Operator nur in der Klasse icMatrix deklariert und ihn in icMatrix.cpp definiert, sprich:

    icMatrix& operator/= (const icMatrix& a);

    und

    icMatrix::operator/= (const icMatrix& a)
{
	return *this *= icMatrixInvert(a);
}

    Beim erstellen kommen (zum Glück) nur noch 3 Fehler und eine Warnung:

    1>------ Erstellen gestartet: Projekt: IonCore, Konfiguration: Debug Win32 ------
1>Kompilieren...
1>icMatrix.cpp
1>d:\spieleprogrammierung\ioncore\src\icmatrix.cpp(23) : error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: "default-int" wird von C++ nicht unterstützt.
1>d:\spieleprogrammierung\ioncore\src\icmatrix.cpp(23) : error C2556: 'int icMatrix::operator /=(const icMatrix &)': Überladene Funktion unterscheidet sich nur hinsichtlich des Rückgabetyps von 'icMatrix &icMatrix::operator /=(const icMatrix &)'
1>        d:\spieleprogrammierung\ioncore\include\icmatrix.h(140): Siehe Deklaration von 'icMatrix::operator /='
1>d:\spieleprogrammierung\ioncore\src\icmatrix.cpp(23) : error C2040: 'icMatrix::operator /=': 'int (const icMatrix &)' unterscheidet sich von 'icMatrix &(const icMatrix &)' in Bezug auf die Anzahl vorgenommener Dereferenzierungen
1>d:\spieleprogrammierung\ioncore\src\icmatrix.cpp(175) : warning C4244: 'Argument': Konvertierung von 'double' in 'float', möglicher Datenverlust
1>Das Buildprotokoll wurde unter "file://d:\Spieleprogrammierung\IonCore\Debug\BuildLog.htm" gespeichert.
1>IonCore - 3 Fehler, 1 Warnung(en)
========== Erstellen: 0 erfolgreich, Fehler bei 1, 0 aktuell, 0 übersprungen ==========

    Alle Fehler verweisen direkt auf die Definition des Operators /= und das Warning auf

    const float s = (float) (1.0 / tanf(FOV * 0.5));

    in der Funktion icMatrixProjection . Vielleicht könnt ihr mich ein bisschen über diese Fehler aufklären, den ersten habe ich nämlich ungewöhnlich oft und ich weiß nicht, was das Problem ist. Zwar habe ich mich darüber informiert, aber ich sehe den Fehler nicht.

    0
  • ?

    Ok, ich habe jetzt noch einiges selber gelöst. Ich darf ja nicht einfach

    icMatrix::operator/= (const icMatrix& a)
{
    return *this *= icMatrixInvert(a);
}

    schreiben, sondern muss flogendes schreiben:

    icMatrix& icMatrix::operator/= (const icMatrix& a)
{
	return *this *= icMatrixInvert(a);
}

    Kein Wunder, warum die Fehler kamen. Nun bleibt nur noch die Warnung, ist diese brechtigt? Oder wie soll ich mit ihr umgehen? Ignorieren?

    0
  • P

    Irgendwer schrieb:

    Nun bleibt nur noch die Warnung, ist diese brechtigt? Oder wie soll ich mit ihr umgehen? Ignorieren?

    Warnungen sind immer berechtigt. Float hat eine geringere Genauigkeit als double. Warum auch immer du float benutzt, der Compiler merkt, dass du an einer Stelle einen double stillschweigend in einen float konvertierst und warnt dich vor eben dem Genauigkeitsverlust.
    Mal abgesehn von der Tatsache, dass es wirklich keinen Sinn macht, mit deinen Kenntnissen schon sowas komplexes wie eine Spiele-Engine anzufangen (da kommt nur Murks raus, da du offensichtlich die nötige Erfahrung nicht besitzt), schau dir mal im Magazin den Artikel zur Operatorüberladung an. Nachdem du den Ratschlag, keine unintuitiven Operatoren anzubieten, beherzigt und die Häfte deiner Operatoren wieder rausgenommen hast, bleibt immernoch einiges zu tun.

    0
Anmelden zum Antworten