XNA Code zu C++ Directx10/11 Portieren

adonis

Hallo ich würde gerne meine Camera Klasse die ich in XNA geschrieben habe
zu C++ und DirectX portieren.

Hier meine XNA Camera

public class Camera
    {
        public static Viewport VP { get; set; }
        public static Matrix View { get; set; }
        public static Matrix Projection { get; set; }
        public static Matrix Orientation { get; set; }
        public static Vector3 Position { get; set; }
        public static Vector3 Velocity { get; set; }

        public static Quaternion quaternion { get; set; }
        public static Quaternion RotY { get; set; }
        public static Quaternion RotX { get; set; }
        public static Quaternion Ori { get; set; }
        public static float QRotY { get; set; }
        public static float QRotX { get; set; }

        public static Vector3 Up;

        public Camera()
        {
            Position = new Vector3(0, 0, 0);
            Up = new Vector3(0, 1, 0);
        }

        public static void UpdateCamera()
        {
            Position += Vector3.Transform(Velocity, Matrix.CreateFromQuaternion(quaternion));

            View = Matrix.CreateLookAt(Position + Vector3.Transform(new Vector3(0, +10, -20), Matrix.CreateFromQuaternion(quaternion)),
                    Position + Vector3.Transform(new Vector3(0, -10, 50), Matrix.CreateFromQuaternion(quaternion)),
                    Vector3.Transform(Up, quaternion));
            Projection = Matrix.CreatePerspectiveFieldOfView(
                MathHelper.Pi/3.0f, VP.AspectRatio, 1, 10000);
        }

        public static void Rotate(float AngleY, float AnlgeX)
        {
            RotY = Quaternion.CreateFromAxisAngle(Vector3.Up, MathHelper.ToRadians(AngleY));
            RotX = Quaternion.CreateFromAxisAngle(Vector3.Left, MathHelper.ToRadians(AnlgeX));
            quaternion = RotY * RotX;
            quaternion.Normalize(); 
        }
    }

Ich scheitere derzeit schon beim ersten Vector3.Transform(...),
gibt es solche Funktionalität bei directx/c++ nicht?
Muss ich die ganzen Funktionen selber schreiben, oder gibt es
irgendwo schon eine gute Bibliothek?

Grüße

adonis

Zur Not, was macht Vector3.transform() genau? Ist es einfach nur
ein Vektormatrixprodukt? Dann könnte ich es wohl noch selbst
hinbekommen.

adonis

Mhh ok, versuche ich das mal selber zu schreiben.
so sehen meine Klassen derzeit aus:

Vector3.h

#ifndef __VECTOR3_H__
#define __Vector3_H__
#endif
#pragma once
#include <cmath>
struct Matrix
{
	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;
	static Matrix CreateFromQuaternion()
	{
	}
	static Matrix CreateLookAt()
	{
	}
	static Matrix CreatePerspectiveFieldOfView()
	{
	}
	static Matrix CreateScale()
	{
	}
	static Matrix CreateFromAxisAngle()
	{
	}
	static Matrix CreateFromYawPitchRoll()
	{
	}
};
class Vector3
{
public:
	float x,y,z;
	Vector3(void);
	Vector3(float x, float y, float z);
	float Lenght();
	static void Lenght(Vector3 vector, float* result);
	void Normalize();
	static void Normalize(Vector3 vector, Vector3 *result);
	static void Distance(Vector3 value1, Vector3 value2, float* result);
	static void Transform(Vector3 position, Matrix matrix, Vector3 *result);
	~Vector3(void);
};

Vector3.cpp

#include "Vector3.h"

Vector3::Vector3(void)
{
	x=0;
	y=0;
	z=0;
}
Vector3::Vector3(float x, float y, float z)
{
	this->x = x;
	this->y = y;
	this->z = z;
}
void Vector3::Transform(Vector3 value1, Matrix matrix, Vector3 *result)
{	
	result->x = matrix.m11 * value1.x + matrix.m12 * value1.y + matrix.m13 * value1.z + matrix.m14*1;
	result->y = matrix.m21 * value1.x + matrix.m22 * value1.y + matrix.m23 * value1.z + matrix.m24*1; 
	result->z = matrix.m31 * value1.x + matrix.m32 * value1.y + matrix.m33 * value1.z + matrix.m34*1;	
}
float Vector3::Lenght()
{
	return sqrt(pow(x,2)+pow(y,2)+pow(z,2));
}
void Vector3::Lenght(Vector3 vector, float* result)
{
	*result = sqrt(pow(vector.x,2)+pow(vector.y,2)+pow(vector.z,2));
}
void Vector3::Normalize()
{
	float temp;
	temp = sqrt(pow(x,2)+pow(y,2)+pow(z,2));
	x = x/temp;
	y = y/temp;
	z = z/temp;
}
void Vector3::Normalize(Vector3 vector, Vector3* result)
{
	Vector3 temp;
	float laenge = sqrt(pow(vector.x,2)*pow(vector.y,2)+pow(vector.z,2));
	temp.x = vector.x/laenge;
	temp.y = vector.y/laenge;
	temp.z = vector.z/laenge;
	*result = temp;
}
void Vector3::Distance(Vector3 value1, Vector3 value2, float* result)
{
	Vector3 DistanceVector;
	float Distance = 0;
	DistanceVector.x = value1.x-value2.x;
	DistanceVector.y = value1.y-value2.y;
	DistanceVector.z = value1.z-value2.z;
	Lenght(DistanceVector, &Distance);
	if(Distance < 0)
		Distance *-1;
	*result = Distance;
}
Vector3::~Vector3(void)
{

}

Für Verbesserungsvorschläge und Fehlerhinweise wäre ich dankbar.
Wenn die Klasse fertig ist, kann ich sie gerne zur Verfügung stellen.

Grüße

PS: Mehr Funktionen sind in Planung

adonis schrieb:

Mhh ok, versuche ich das mal selber zu schreiben.
so sehen meine Klassen derzeit aus:

Vector3.h

#ifndef __VECTOR3_H__
#define __Vector3_H__
#endif
#pragma once
#include <cmath>
struct Matrix
{
	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;
	static Matrix CreateFromQuaternion()
	{
	}
	static Matrix CreateLookAt()
	{
	}
	static Matrix CreatePerspectiveFieldOfView()
	{
	}
	static Matrix CreateScale()
	{
	}
	static Matrix CreateFromAxisAngle()
	{
	}
	static Matrix CreateFromYawPitchRoll()
	{
	}
};
class Vector3
{
public:
	float x,y,z;
	Vector3(void);
	Vector3(float x, float y, float z);
	float Lenght();
	static void Lenght(Vector3 vector, float* result);
	void Normalize();
	static void Normalize(Vector3 vector, Vector3 *result);
	static void Distance(Vector3 value1, Vector3 value2, float* result);
	static void Transform(Vector3 position, Matrix matrix, Vector3 *result);
	~Vector3(void);
};

Vector3.cpp

#include "Vector3.h"

Vector3::Vector3(void)
{
	x=0;
	y=0;
	z=0;
}
Vector3::Vector3(float x, float y, float z)
{
	this->x = x;
	this->y = y;
	this->z = z;
}
void Vector3::Transform(Vector3 value1, Matrix matrix, Vector3 *result)
{	
	result->x = matrix.m11 * value1.x + matrix.m12 * value1.y + matrix.m13 * value1.z + matrix.m14*1;
	result->y = matrix.m21 * value1.x + matrix.m22 * value1.y + matrix.m23 * value1.z + matrix.m24*1; 
	result->z = matrix.m31 * value1.x + matrix.m32 * value1.y + matrix.m33 * value1.z + matrix.m34*1;	
}
float Vector3::Lenght()
{
	return sqrt(pow(x,2)+pow(y,2)+pow(z,2));
}
void Vector3::Lenght(Vector3 vector, float* result)
{
	*result = sqrt(pow(vector.x,2)+pow(vector.y,2)+pow(vector.z,2));
}
void Vector3::Normalize()
{
	float temp;
	temp = sqrt(pow(x,2)+pow(y,2)+pow(z,2));
	x = x/temp;
	y = y/temp;
	z = z/temp;
}
void Vector3::Normalize(Vector3 vector, Vector3* result)
{
	Vector3 temp;
	float laenge = sqrt(pow(vector.x,2)*pow(vector.y,2)+pow(vector.z,2));
	temp.x = vector.x/laenge;
	temp.y = vector.y/laenge;
	temp.z = vector.z/laenge;
	*result = temp;
}
void Vector3::Distance(Vector3 value1, Vector3 value2, float* result)
{
	Vector3 DistanceVector;
	float Distance = 0;
	DistanceVector.x = value1.x-value2.x;
	DistanceVector.y = value1.y-value2.y;
	DistanceVector.z = value1.z-value2.z;
	Lenght(DistanceVector, &Distance);
	if(Distance < 0)
		Distance *-1;
	*result = Distance;
}
Vector3::~Vector3(void)
{
	
}

Für Verbesserungsvorschläge und Fehlerhinweise wäre ich dankbar.

Mein Tipp wäre das nicht selbst zu schreiben sondern eine Library zu suchen die das macht oder die Directx Vector/Matrix Klassen zu nutzen: (http://msdn.microsoft.com/en-us/library/windows/desktop/bb172981(v=vs.85).aspx)

In der matrix würde ich die werte in einen dicht gepackten Array stecken.

Wenn du mal eine Richtig tolle Vector/Matrix Library anschauen willst kannst du dir mal glm anschauen.
Da gehen so Dinge wie:

vec2 v = vec3(1.0, 2.0, 3.0).xz;
=> v == vec2(1.0, 3.0)

Wird dir aber bei DX wahrscheinlich nicht helfen, weil Matrizen usw. für OpenGL aufgesetzt werden und sich da einige koordinatensystem etwas unterscheiden. Außerdem werden die Matrizen bei Opengl Zeilenweise und bei DX Spaltenweise gespeichert (oder andersrum).