shared_ptr - Delete?

otze

Das Problem ist, das man hier Anfängern shared_ptr und Konsorten um die Ohren haut, bevor sie überhaupt verstanden haben, was das Problem ist.

Sone

Das Problem ist, das man hier Anfängern shared_ptr und Konsorten um die Ohren haut, bevor sie überhaupt verstanden haben, was das Problem ist.

Also müssen sie erst verstehen, dass das Problem ist, dass man hier Anfängern shared_ptr und Konsorten um die Ohren haut, bevor sie überhaupt verstanden haben, was das Problem ist.

Skym0sh0

Im Prinzip ist die Geschichte mit automatisch delete aufrufen relativ überflüssig, wenn keine Exceptions im Spiel sind. Denn dann ist es noch überschaubar, an welchen Stellen Speicher deletet werden muss. Das bedeutet nicht, dass das dann schön ist oder keinerlei Fehler(Memory Leaks) auftreten können, aber in der Theorie würde das reichen.

Sobald aber Exceptions dazukommen geht die Ressourcen-Verwaltung nur noch sinnvoll und übersichtlich mit RAII.

Daher, vllt anfangs mal 2-3 Übungen machen mit new+delete, danach alles in RAII-Klassen einkapseln!

cl90

Ja ich versteh ja auch euren Standpunkt. Nur leider ist es an meiner Uni so das die Profs sich nicht darum scheren woher du die Sprache kennst, du sollst nur Ihre Projekte machen können. Das Man dann nicht die Zeit hat sich ein gutes Buch zur Hand zu nehmen und bei 0 Anzufangen ist leider vorprogrammiert.
Ich bin auch direkt eingestiegen, und hab mich durch Trial and Error "Weiterentwickelt". Und solche Grundlagen fehlen dann leider manchmal.

Die ganzen Pointer/shared_ptr sachen waren übrigents gar nicht das Problem...
Das Problem liegt in der Allokierung der DirectX Ressourcen. Texturen und Meshes... Ich muss mich jetzt erstmal einlesen wie die Strukturen aufgebaut sind damit ich weiß wie ich die wieder löschen kann.

hustbaer

DirectX verwendet COM Objekte.
Löschen tut man diese nicht, man gibt nur "seine" Referenz auf sie frei. Und wenn das die letzte Referenz war, dann löscht sich das Objekt von selbst.

Zum Referenz-Zählen verwendet man ->AddRef() und ->Release(). Bzw. spezialisierte Smart-Pointer Klassen die einem das abnehmen.

tntnet

Skym0sh0 schrieb:

Im Prinzip ist die Geschichte mit automatisch delete aufrufen relativ überflüssig, wenn keine Exceptions im Spiel sind. Denn dann ist es noch überschaubar, an welchen Stellen Speicher deletet werden muss. Das bedeutet nicht, dass das dann schön ist oder keinerlei Fehler(Memory Leaks) auftreten können, aber in der Theorie würde das reichen.

Sobald aber Exceptions dazukommen geht die Ressourcen-Verwaltung nur noch sinnvoll und übersichtlich mit RAII.

Daher, vllt anfangs mal 2-3 Übungen machen mit new+delete, danach alles in RAII-Klassen einkapseln!

Wenn Exceptions im Spiel sind, dann erleichtern RAII und Smartpointer das Leben ungemein. Wenn keine Exceptions verwendet werden, dann erleichtern sie nur ein wenig, aber sie tun es doch. Also warum sollte man auf RAII und Smartpointer verzichten? Wobei ich mich auch frage, warum man auf Exceptions verzichten sollte.

Wobei auch ohne Exceptions gibt es genügend Möglichkeiten, die Freigabe von Resourcen zu übersehen. Also nehme ich es zurück, dass RAII und Smartpointer ohne Exceptions das Leben nur ein wenig erleichtern. Sie tun es auch ohne Exceptions ungemein .

tntnet schrieb:

Wobei auch ohne Exceptions gibt es genügend Möglichkeiten, die Freigabe von Resourcen zu übersehen.

Wer geschickt programmiert, für den ist das auch ohne RAII übersichtlich (ohne Exceptions).

10-Zeilen-Funktionen + Ressourcenmanagement von Verarbeitung trennen = übersichtlicher Code.

Sone

Nur ist das Problem, dass RAII schon vom Design her Fehler vermeidet. Programmierer sind Menschen, das heißt sie machen Fehler. Und das heißt, auch ihr Code tendiert zu Fehlerhaftigkeit. RAII macht es schwerer, Fehler zu machen. Es kann neue hervorrufen, aber eine noch größere Reihe von Fehlern wird damit behoben.

cl90

öhm...
Mag mir das jemand erklären:

void main()	{	// Erzeugt leaks
		CData			data = CData();		
	}
	void main()	{	// Erzeugt keine leaks
		CData	data();		
	}
	void main()	{	// Erzeugt keine leaks
		CData*	data = new CData();
		delete data;
	}

	// jetzt ein Konstruktor einer Klasse:
	DirectX_Device :: DirectX_Device(CData* cdata) 
	{	// Erzeugt leaks.
		m_xfiles.push_back("plate.x");
		m_xfiles.push_back("lowPolySphere.x");
	}
	DirectX_Device :: DirectX_Device(CData* cdata) 
	{	// Erzeugt Keine leaks.
		//m_xfiles.push_back("plate.x");
		//m_xfiles.push_back("lowPolySphere.x");
	}

Das mit "data = CData()" ist mir neu..
Und muss man Vectoren deleten?

Sone

void main() {   // Erzeugt leaks 
        CData           data = CData();     
    }

Das kann gar nichts, denn es ist kein gültiges C++.
Und selbst wenn du den Rückgabetyp zu int änderst, ist diese Variante genauso sicher wie die zweite.

Und muss man Vectoren deleten?

Nein. Deswegen sind sie u.a. so angenehm.

ipsec

cl90 schrieb:

void main()	{	// Erzeugt leaks
		CData			data = CData();		
	}

Das sollte keine Leaks erzeugen. Vermutlich gibt es einen Bug im Copy-Konstruktor von CData . Das würde auch erklären, warum der Fall mit new keine Leaks erzeugt, denn dort wird nur der normale Konstruktor aufgerufen.

Nebenbei: im zweiten Fall wird kein CData -Objekt angelegt, sondern eine Funktion ohne Parameter mit Rückgabewert CData deklariert. Was du vermutlich willst, ist

CData data; // ohne ()

Vermutlich erzeugt das auch keine Leaks, aus dem gleichen Grund wie im new -Fall.

Nathan

ipsec schrieb:

cl90 schrieb:
void main()	{	// Erzeugt leaks
		CData			data = CData();		
	}
Das sollte keine Leaks erzeugen. Vermutlich gibt es einen Bug im Copy-Konstruktor von CData .

Deshalb erzeugt auch das push_back() Leaks, hast die Klasse kein Move und gibt der Copykonstruktor vorher erzeugte Handles oder was auch immer nicht frei, gibts bei jeder Kopie Leaks.

cl90

also:

CData	data;

Erzeugt auch leaks.

Aber ich habe nur einen Konstruktor deklariert. Ich hab mit dem Copy Konstruktor nichts gedreht.

CData sieht so aus:

class CData 
{
	public:
		CData();

		// Sehr viele Funktionen nach Muster get/set
		D3DXVECTOR3*		get_TargetPtr(int leg);	// bsp.

	private:
		// Die Entsprechenden Variablen zu get/set
		int					m_ReadDelay;	//bsp.
};

CData :: CData()
	:	m_UDPSocket(&m_Acceleration, &m_RollPitchYaw),
		m_CIni()	// Erzeugt auch ohne die beiden Klassen Leaks.
					// Ich geh also davon aus das die ok sind.	
{

	// initialisierungen. Alles ohne new
}

Sone

void main() {   // Erzeugt leaks
        CData           data = CData();     
    }

Dann erzeugt dieser Code-Schnipsel dadurch Leaks, dass der Konstruktor von CData aufgerufen wird...

Eisflamme

Zeig doch Mal mehr von der Klasse.

Ich kann mir vorstellen, dass die Regel der großen 3 (5) nicht eingehalten wurde, d.h. es gibt einen dtor, der irgendwo delete aufruft, jedoch sind operator= und copy-ctor eben nicht definiert. Das führt dann dazu, dass der referenzierte Speicher gelöscht wird.

Oder heißt Leaks, dass irgendwas nicht freigegeben wird? Eigentlich würde das Programm ja dann ziemlich klar crashen, wenn meine Theorie oben stimmen würde.

Kann auch sein, dass einfach das delete zum jeweiligen new fehlt, wenn weder copy-ctor, operator= noch dtor definiert sind, aber in ctor new aufgerufen wird.

Eins von beidem wird's doch wohl sein, komm schon.

cl90

Ok. Also dann werde ich mal mehr Posten damit ihr euch ein größeres Bild machen könnt.

denn CData hat jetzt grade zum leak finden absolut keinen inhalt:

CData :: CData()
	//:	m_UDPSocket(&m_Acceleration, &m_RollPitchYaw),
	//	m_CIni()

{
	/*unsigned int i;

//	Ctrl	///////////////////////////////////////////////////////////////////////////

	m_mouseL		= false;
	m_mouseR		= false;

	m_wheel			= 0.0f;
	m_X				= 400;
	m_Y				= 400;

	m_WASD_Toggle	= 1;
	m_Toggle		= false;

	for(i = 0; i < 256; i++)	m_keystate[i] = false; 

	m_Acceleration	= D3DXVECTOR3(0, 0, 0); 
	m_RollPitchYaw	= D3DXVECTOR3(0, 0, 0);

//	Console	///////////////////////////////////////////////////////////////////////////

	m_wireframe = false;
//	View	///////////////////////////////////////////////////////////////////////////

	m_viewDistance	= 50.0f;
	m_viewRotHori	= 0;
	m_viewRotVert	= 0;

//	Leg		///////////////////////////////////////////////////////////////////////////

	m_Length[0]	= 3.29f;
	m_Length[1]	= 1.5f;
	m_Length[2]	= 6.78f;
	m_Length[3]	= 8.07f;

	D3DXMatrixRotationZ		(&m_matRot90,		D3DXToRadian(-90));
	D3DXMatrixScaling		(&m_matBodySize,	0.1f, 0.1f, 0.1f);
	D3DXMatrixScaling		(&m_matAxisSize,	0.05f, 2.0f, 0.05f);
	D3DXMatrixRotationY		(&m_matTurn,		D3DXToRadian(180));

	D3DXMatrixTranslation	(&m_matTransSO,	   -m_Length[0], 0, 0);
	D3DXMatrixTranslation	(&m_matTransVS,		0, m_Length[1], 0);
	D3DXMatrixTranslation	(&m_matTransOS,		0, m_Length[2], 0);
	D3DXMatrixTranslation	(&m_matTransUS,		0, m_Length[3], 0);

//	General	///////////////////////////////////////////////////////////////////////////

	m_KillThisProcess	= false;
	m_ReadDelay			= 0;*/
}

Das Hauptprogramm sieht in wirklichkeit auch so aus:
CData ist global. (weil ich es auch für Windowproc nutzen wollte.)

// includes

	CData			data = CData();	
	//CData*		data = new CData();
	//CData	data;
	//DirectX_Device	dxdv(&data);

#include "inc/win_api.h"

int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR lpCmdLine,
                   int nCmdShow)
{
	//delete data;

	_CrtDumpMemoryLeaks();

    return EXIT_SUCCESS;
}

Eisflamme

Ist da wirklich alles auskommentiert und das liefert dann immer noch Leaks? (in der CData-Klasse?)

Falls ja, gibt es auch statische Member von CData? Falls nein, würde ich natürlich auch die Klassen prüfen, deren Instanzen Member von CData sind.

Gerne kannst Du auch Mal die CData-Schnittstelle (Header) zeigen, man weiß ja nie.

Eisflamme schrieb:

Oder heißt Leaks, dass irgendwas nicht freigegeben wird?

lol

cl90

Ok ich denke das es nichts mehr bringt irgendwas zu kürzen.
Ich poste jetzt Alles was zum leak finden ausgeführt wird, und insgesammt 19 mal 8Byte leaks erzeugt:

#include "inc/init_configuration.h"
#include "inc/render_frame.h"
#include "inc/hexapod.h"
#include "inc/control.h"
#include "inc/GUI3D.h"
#include "inc/Console.h"
#include "inc/DirectX_Device.h"
#include "inc/CData.h"
#include "inc/_IStrategy.h"
#include "inc/_IStrategyVal.h"

// includes

	CData			data = CData();	
	//CData*		data = new CData();
	//CData	data;
	//DirectX_Device	dxdv(&data);

#include "inc/win_api.h"

int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR lpCmdLine,
                   int nCmdShow)
{
	//delete data;

	_CrtDumpMemoryLeaks();

    return EXIT_SUCCESS;
}

#include "init_configuration.h"
#include "Observer.h"
#include "CInitial.h"
#include "_ConsoleString.h"
#include "_UDPSocket.h"
#include <memory>
#include <vector>
#include <string>

class CData 
{
	public:
		CData();
		//~CData();

//	Control

		bool				get_automatic	();
		bool				get_console		();
		bool				get_COMBlue		();
		bool				get_COMUdp		();
		bool				get_AbsJoystic	();
		bool				get_TR_Move		();
		bool				get_AbsRelTR	();
		bool				get_MouseL		();
		bool				get_MouseR		();
		bool				get_KeyS		(int key);

		bool				get_UDPThread	();

		D3DXVECTOR3*		get_JoystickPtr	();
		D3DXVECTOR3*		get_AbsJoyPtr	();
		D3DXVECTOR3*		get_Acceleration();
		D3DXVECTOR3*		get_RollPitchYaw();
		int					get_active		(bool toggle);
		int					get_cX			();
		int					get_cXi			();
		int					get_cY			();
		int					get_cYi			();
		int					get_WASD_Toggle ();
		int					get_Mode		();
		float				get_wheel		();

		void				set_automatic	(bool value);
		void				set_console		(bool value);
		void				set_COMBlue		(bool value);
		void				set_COMUdp		(bool value);
		void				set_AbsJoystic	(bool value);
		void				set_TR_Move		(bool value);
		void				set_AbsRelTR	(bool value);
		void				set_active		(bool toggle, int value);

		void				set_UDPThread	(bool IsCreated);

		void				set_MouseL		(bool value);
		void				set_MouseR		(bool value);
		void				set_Wheel		(float value);
		void				set_JoystickPtr	(D3DXVECTOR3* vec);
		void				set_AbsJoyPtr	(D3DXVECTOR3* vec);
		void				set_Mode		(int value);
		void				next_WASD		(bool key);

		void				key_Up			(WPARAM wParam);
		void				key_Down		(WPARAM wParam);
		void				set_Mouse		(POINT ptCursor);
		void				refresh_temp_M	();
		void				calc_relative_M	();

//	Console

		bool				get_wireframe	();
		bool*				get_wireframe_ptr();

		void				set_ConsoleAttachPointer(vector<_ConsoleString>* ptr);
		void				append_toConsole		(_ConsoleString line);

//	GUI

		LPD3DXFONT*			get_LPD3font	(int select);
		void				set_LPD3font	(LPD3DXFONT* font, int select);

//	View Light

		float				get_viewRotH			();
		float				get_viewRotV			();
		float				get_viewDist			();
		D3DXVECTOR3*		get_CamPosPtr			();
		D3DXVECTOR3*		get_LookAtPtr			();
		D3DXMATRIX*			get_matViewPtr			();
		D3DXMATRIX*			get_matProjPtr			();

		void				set_viewRotH			(float value);
		void				set_viewRotV			(float value);
		void				set_viewDist			(float value);
		void				set_CamPosPtr			(D3DXVECTOR3* vec);
		void				set_CamPos				(D3DXVECTOR3* vec);
		void				set_LookAtPtr			(D3DXVECTOR3* vec);
		void				set_LookAt				(D3DXVECTOR3* vec);
		void				set_matViewPtr			(D3DXMATRIX* mat);
		void				set_matProjPtr			(D3DXMATRIX* mat);

//	Hexapod

		float				get_LAngle_X			();
		float				get_LAngle_Y			();
		float				get_LAngle_Z			();
		float				get_LAngle_S			();
		float				get_LHeight				();
		float				get_LTranX				();
		float				get_LTranZ				();
		void				set_LAngle_X			(float value);
		void				set_LAngle_Y			(float value);
		void				set_LAngle_Z			(float value);
		void				set_LAngle_S			(float value);
		void				set_LHeight				(float value);
		void				set_LTranX				(float value);
		void				set_LTranZ				(float value);

//	Leg	Get/Set

		void				attach_WTarget			(int leg, Observer* obs);
		void				attach_Target			(int leg, Observer* obs);
		void				attach_SvoAngle			(int leg, Observer* obs);

		float				get_SvoAngle			(int leg, int servo);
		float				get_SvoRelativeAngle	(int leg, int servo);
		D3DXVECTOR3*		get_WorldTargetPtr		(int leg);
		D3DXVECTOR3*		get_WTargetTempPtr		(int leg);
		D3DXVECTOR3*		get_TargetPtr			(int leg);
		D3DXVECTOR3*		get_PosVecPtr			(int leg, int pos);
		D3DXMATRIX*			get_matTransformPtr		(int leg, int value);
		D3DXMATRIX*			get_matDirPtr			(int leg);
		D3DXMATRIX*			get_matTransPosPtr		(int leg);
		D3DXMATRIX*			get_matBodySizePtr		();
		D3DXMATRIX*			get_matAxisSizePtr		();
		D3DXMATRIX*			get_matRot90Ptr			();
		D3DXMATRIX*			get_matTurnPtr			();
		D3DXMATRIX*			get_matTransSOPtr		();

		D3DXMATRIX*			get_matTransVSPtr		();
		D3DXMATRIX*			get_matTransOSPtr		();
		D3DXMATRIX*			get_matTransUSPtr		();

		void				set_SvoAngle			(int leg, int servo, float value);
		void				set_SvoAngle			(int leg, float v1, float v2, float v3, float v4);
		void				set_WorldTarget			(int leg, D3DXVECTOR3* vec);
		void				set_WTargetTemp			(int leg, D3DXVECTOR3* vec);
		void				set_Target				(int leg, D3DXVECTOR3* vec);
		void				set_matTransform		(int leg, int value, D3DXMATRIX* mat);
		void				set_matDir				(int leg, D3DXMATRIX* mat);
		void				set_matTransPos			(int leg, D3DXMATRIX* mat);
		void				set_matBodySize			(D3DXMATRIX*	mat);
		void				set_matAxisSize			(D3DXMATRIX*	mat);

//	General

		void				attach_BegScene			(Observer* obs);
		void				call_SceneCtrl			();
		void				call_SceneGUI			();

		void				RestartProcess			();
		bool				KillThisProcess			();

		_CInitial*			get_INI					();
		_UDPSocket*			get_UDP					();

		int					get_ReadDelay			();
		void				set_ReadDelay			(int value);		

//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////

	private:

// Ctrl	Data

		int					m_active[2];

		bool				m_automatic;
		bool				m_console;
		bool				m_COMBlue;
		bool				m_COMUdp;
		bool				m_AbsJoystic;
		bool				m_TR_Move;
		bool				m_AbsRelTR;

		bool				m_UDPthreadIsCreated;

		int					m_WASD_Toggle;
		int					m_Mode;
		bool				m_Toggle;

		int					m_X,	m_Y;
		int					m_Xi,	m_Yi;
		float				m_wheel, m_tempW;
		int					m_tempX, m_tempY;
		D3DXVECTOR3			m_Joystick;
		D3DXVECTOR3			m_AbsJoystick;
		D3DXVECTOR3			m_Acceleration;
		D3DXVECTOR3			m_RollPitchYaw;

		bool				m_mouseL, m_mouseR;
		bool				m_keystate[256];

// Console

		bool								m_wireframe;
		vector<_ConsoleString>*				m_pConsoleText;

// GUI  Data

		LPD3DXFONT*			m_LPD3font_Display;
		LPD3DXFONT*			m_LPD3font_Console;

//	View Light

		float				m_viewRotHori;
		float				m_viewRotVert;
		float				m_viewDistance;

		D3DXVECTOR3*		m_CamPos;
		D3DXVECTOR3*		m_LookAt;

		D3DXMATRIX*			m_matView;
		D3DXMATRIX*			m_matProjection;

// Hexa Data

		float				m_LHeight;
		float				m_LTranX;
		float				m_LTranZ;
		float				m_LAngle_X;
		float				m_LAngle_Y;
		float				m_LAngle_Z;
		float				m_LAngle_S;

// Leg	Data
		std::vector<Observer*>	m_obsWTarget[6];
		std::vector<Observer*>	m_obsTarget[6];
		std::vector<Observer*>	m_obsSvoAngle[6];

		float				m_Length[4];
		float				m_SvoAngle[6][4];
		float				m_SvoRelativeAngle[6][4];
		D3DXVECTOR3			m_WorldTarget[6];
		D3DXVECTOR3			m_WTargetTemp[6];
		D3DXVECTOR3			m_Target[6];
		D3DXVECTOR3			m_PosVec[6][5];

		D3DXMATRIX			m_matTransform[6][6];
		D3DXMATRIX			m_matDir[6];
		D3DXMATRIX			m_matTransPos[6];
		D3DXMATRIX			m_matBodySize;
		D3DXMATRIX			m_matAxisSize;
		D3DXMATRIX			m_matRot90, m_matTurn, m_matTransSO;
		D3DXMATRIX			m_matTransVS, m_matTransOS, m_matTransUS;

//	General

		vector<Observer*>	m_obsBeginScene;
		bool				m_KillThisProcess;

		//_CInitial			m_CIni;
		//_UDPSocket			m_UDPSocket;

		int					m_ReadDelay;
		int					m_InputDelay;

};

#include "../inc/CData.h"
#include <fstream>
#include <string>

CData :: CData()
	//:	m_UDPSocket(&m_Acceleration, &m_RollPitchYaw),
	//	m_CIni()

{
	/*unsigned int i;

//	Ctrl	///////////////////////////////////////////////////////////////////////////

	m_mouseL		= false;
	m_mouseR		= false;

	m_wheel			= 0.0f;
	m_X				= 400;
	m_Y				= 400;

	m_WASD_Toggle	= 1;
	m_Toggle		= false;

	for(i = 0; i < 256; i++)	m_keystate[i] = false; 

	m_Acceleration	= D3DXVECTOR3(0, 0, 0); 
	m_RollPitchYaw	= D3DXVECTOR3(0, 0, 0);

//	Console	///////////////////////////////////////////////////////////////////////////

	m_wireframe = false;
//	View	///////////////////////////////////////////////////////////////////////////

	m_viewDistance	= 50.0f;
	m_viewRotHori	= 0;
	m_viewRotVert	= 0;

//	Leg		///////////////////////////////////////////////////////////////////////////

	m_Length[0]	= 3.29f;
	m_Length[1]	= 1.5f;
	m_Length[2]	= 6.78f;
	m_Length[3]	= 8.07f;

	D3DXMatrixRotationZ		(&m_matRot90,		D3DXToRadian(-90));
	D3DXMatrixScaling		(&m_matBodySize,	0.1f, 0.1f, 0.1f);
	D3DXMatrixScaling		(&m_matAxisSize,	0.05f, 2.0f, 0.05f);
	D3DXMatrixRotationY		(&m_matTurn,		D3DXToRadian(180));

	D3DXMatrixTranslation	(&m_matTransSO,	   -m_Length[0], 0, 0);
	D3DXMatrixTranslation	(&m_matTransVS,		0, m_Length[1], 0);
	D3DXMatrixTranslation	(&m_matTransOS,		0, m_Length[2], 0);
	D3DXMatrixTranslation	(&m_matTransUS,		0, m_Length[3], 0);

//	General	///////////////////////////////////////////////////////////////////////////

	m_KillThisProcess	= false;
	m_ReadDelay			= 0;*/
}

//	Control	///////////////////////////////////////////////////////////////////////////
bool		CData	::		get_automatic	()
{	
	return m_automatic;						
}
bool		CData	::		get_console		()
{	
	return m_console;						
}
bool		CData	::		get_COMBlue		()
{	
	return m_COMBlue;						
}
bool		CData	::		get_COMUdp()
{
	return m_COMUdp;
}
bool		CData	::		get_AbsJoystic	()
{
	return m_AbsJoystic;
}
bool		CData	::		get_TR_Move		()
{
	return m_TR_Move;
}
bool		CData	::		get_AbsRelTR	()
{
	return m_AbsRelTR;
}
bool		CData	::		get_MouseL		()
{	
	return m_mouseL;						
}
bool		CData	::		get_MouseR		()
{	
	return m_mouseR;						
}
D3DXVECTOR3* CData	::		get_JoystickPtr	()
{	
	return &m_Joystick;						
}
D3DXVECTOR3* CData	::		get_AbsJoyPtr	()
{
	return &m_AbsJoystick;
}
D3DXVECTOR3* CData	::		get_Acceleration()
{
	return &m_Acceleration;
}
D3DXVECTOR3* CData	::		get_RollPitchYaw()
{
	return &m_RollPitchYaw;
}
bool		CData	::		get_KeyS		(int key)
{	
	if(key >= 0 && key < 256)	return m_keystate[key];
	else						return false; 
}
bool		CData	::		get_UDPThread	()
{
	return m_UDPthreadIsCreated;
}

int			CData	::		get_active		(bool toggle)
{	
	if(toggle)	return m_active[1];
	else		return m_active[0];			
}
int			CData	::		get_cX			()
{	
	return m_X;								
}
int			CData	::		get_cXi			()
{	
	return m_Xi;							
}
int			CData	::		get_cY			()
{	
	return m_Y;								
}
int			CData	::		get_cYi			()
{	
	return m_Yi;							
}
int			CData	::		get_Mode		()
{
	return m_Mode;
}
int			CData	::		get_WASD_Toggle	()
{
	return m_WASD_Toggle;
}
float		CData	::		get_wheel		()
{	
	return m_wheel;							
}
void		CData	::		set_automatic	(bool value)
{	
	m_automatic = value;					
}
void		CData	::		set_console		(bool value)
{	
	m_console	= value;					
}
void		CData	::		set_COMBlue		(bool value)
{	
	m_COMBlue	= value;					
}
void		CData	::		set_COMUdp		(bool value)
{
	m_COMUdp	= value;
	if(!value)	
	{
		//m_UDPSocket.Reset();
		//m_UDPthreadIsCreated = false;
	}
}
void		CData	::		set_AbsJoystic	(bool value)
{
	m_AbsJoystic = value;
}
void		CData	::		set_TR_Move		(bool value)
{
	m_TR_Move = value;
}
void		CData	::		set_AbsRelTR	(bool value)
{
	m_AbsRelTR = value;
}
void		CData	::		set_active		(bool toggle, int value)
{	
	m_active[toggle] = value;				
}

void		CData	::		set_UDPThread	(bool IsCreated)
{
	m_UDPthreadIsCreated = IsCreated;
}

void		CData	::		set_MouseL		(bool value)
{	
	m_mouseL = value;						
}
void		CData	::		set_MouseR		(bool value)
{	
	m_mouseR = value;						
}
void		CData	::		set_Wheel		(float value)
{	
	m_wheel	 = value;						
}
void		CData	::		set_JoystickPtr	(D3DXVECTOR3* vec)
{	
	m_Joystick = *vec;						
}
void		CData	::		set_AbsJoyPtr	(D3DXVECTOR3* vec)
{
	m_AbsJoystick = *vec;
}
void		CData	::		set_Mode		(int value)
{
	m_Mode = value;
}
void		CData	::		next_WASD		(bool key)
{
	if(key)
	{
		if(m_Toggle == false)
		{
			m_Toggle = true;
			m_WASD_Toggle += 1;
			if(m_WASD_Toggle >= 4) m_WASD_Toggle = 1;
		}
	}
	else
	{
		m_Toggle = false;
	}
}
void		CData	::		key_Down		(WPARAM wParam)
{
	switch(wParam)
	{
		case 0x01:	m_keystate[CL_LBUTTON]		= TRUE;		break;
		case 0x02:	m_keystate[CL_RBUTTON]		= TRUE;		break;
		case 0x03:	m_keystate[CL_CANCEL]		= TRUE;		break;
		case 0x04:	m_keystate[CL_MBUTTON]		= TRUE;		break;
		case 0x05:	m_keystate[CL_XBUTTON1]		= TRUE;		break;
		case 0x06:	m_keystate[CL_XBUTTON2]		= TRUE;		break;
		//0x07		undefined
		case 0x08:	m_keystate[CL_BACKSPACE]	= TRUE;		break;
		case 0x09:	m_keystate[CL_TAB]			= TRUE;		break;
		//0x0A-0B	undefined
		case 0x0C:	m_keystate[CL_CLEAR]		= TRUE;		break;
		case 0x0D:	m_keystate[CL_RETURN]		= TRUE;		break;
		//0x0E-ßF	undefined
		case 0x10:	m_keystate[CL_SHIFT]		= TRUE;		break;
		case 0x11:	m_keystate[CL_CTRL]			= TRUE;		break;
		case 0x12:	m_keystate[CL_ALT]			= TRUE;		break;
		case 0x13:	m_keystate[CL_PAUSE]		= TRUE;		break;
		case 0x14:	m_keystate[CL_CAPS]			= TRUE;		break;
		case 0x15:	m_keystate[CL_KANA]			= TRUE;		break;
		// 17-19	IME	
		case 0x1B:	PostQuitMessage(0);						break;
		// 1C-1E	IME
		case 0x20:	m_keystate[CL_SPACE]		= TRUE;		break;
		case 0x21:	m_keystate[CL_PRIOR]		= TRUE;		break;
		case 0x22:	m_keystate[CL_NEXT]			= TRUE;		break;
		case 0x23:	m_keystate[CL_END]			= TRUE;		break;
		case 0x24:	m_keystate[CL_HOME]			= TRUE;		break;
		case 0x25:	m_keystate[CL_LEFT]			= TRUE;		break;
		case 0x26:	m_keystate[CL_UP]			= TRUE;		break;
		case 0x27:	m_keystate[CL_RIGHT]		= TRUE;		break;
		case 0x28:	m_keystate[CL_DOWN]			= TRUE;		break;
		case 0x29:	m_keystate[CL_SELECT]		= TRUE;		break;
		case 0x2A:	m_keystate[CL_PRINT]		= TRUE;		break;
		case 0x2B:	m_keystate[CL_EXECUTE]		= TRUE;		break;
		case 0x2C:	m_keystate[CL_SNAPSHOT]		= TRUE;		break;
		case 0x2D:	m_keystate[CL_INS]			= TRUE;		break;
		case 0x2E:	m_keystate[CL_DEL]			= TRUE;		break;
		case 0x2F:	m_keystate[CL_HELP]			= TRUE;		break;
		case 0x30:	m_keystate[CL_0]			= TRUE;		break;
		case 0x31:	m_keystate[CL_1]			= TRUE;		break;
		case 0x32:	m_keystate[CL_2]			= TRUE;		break;
		case 0x33:	m_keystate[CL_3]			= TRUE;		break;
		case 0x34:	m_keystate[CL_4]			= TRUE;		break;
		case 0x35:	m_keystate[CL_5]			= TRUE;		break;
		case 0x36:	m_keystate[CL_6]			= TRUE;		break;
		case 0x37:	m_keystate[CL_7]			= TRUE;		break;
		case 0x38:	m_keystate[CL_8]			= TRUE;		break;
		case 0x39:	m_keystate[CL_9]			= TRUE;		break;
		//0x3A - 40 undefined
		case 0x41:	m_keystate[CL_A]			= TRUE;		break;
		case 0x42:	m_keystate[CL_B]			= TRUE;		break;
		case 0x43:	m_keystate[CL_C]			= TRUE;		break;
		case 0x44:	m_keystate[CL_D]			= TRUE;		break;
		case 0x45:	m_keystate[CL_E]			= TRUE;		break;
		case 0x46:	m_keystate[CL_F]			= TRUE;		break;
		case 0x47:	m_keystate[CL_G]			= TRUE;		break;
		case 0x48:	m_keystate[CL_H]			= TRUE;		break;
		case 0x49:	m_keystate[CL_I]			= TRUE;		break;
		case 0x4A:	m_keystate[CL_J]			= TRUE;		break;
		case 0x4B:	m_keystate[CL_K]			= TRUE;		break;
		case 0x4C:	m_keystate[CL_L]			= TRUE;		break;
		case 0x4D:	m_keystate[CL_M]			= TRUE;		break;
		case 0x4E:	m_keystate[CL_N]			= TRUE;		break;
		case 0x4F:	m_keystate[CL_O]			= TRUE;		break;
		case 0x50:	m_keystate[CL_P]			= TRUE;		break;
		case 0x51:	m_keystate[CL_Q]			= TRUE;		break;
		case 0x52:	m_keystate[CL_R]			= TRUE;		break;
		case 0x53:	m_keystate[CL_S]			= TRUE;		break;
		case 0x54:	m_keystate[CL_T]			= TRUE;		break;
		case 0x55:	m_keystate[CL_U]			= TRUE;		break;
		case 0x56:	m_keystate[CL_V]			= TRUE;		break;
		case 0x57:	m_keystate[CL_W]			= TRUE;		break;
		case 0x58:	m_keystate[CL_X]			= TRUE;		break;
		case 0x59:	m_keystate[CL_Y]			= TRUE;		break;
		case 0x5A:	m_keystate[CL_Z]			= TRUE;		break;
		case 0x5B:	m_keystate[CL_LWIN]			= TRUE;		break;
		case 0x5C:	m_keystate[CL_RWIN]			= TRUE;		break;
		case 0x5D:	m_keystate[CL_APPS]			= TRUE;		break;
		//0x5E		reserved
		case 0x5F:	m_keystate[CL_SLEEP]		= TRUE;		break;
		case 0x60:	m_keystate[CL_NUM0]			= TRUE;		break;
		case 0x61:	m_keystate[CL_NUM1]			= TRUE;		break;
		case 0x62:	m_keystate[CL_NUM2]			= TRUE;		break;
		case 0x63:	m_keystate[CL_NUM3]			= TRUE;		break;
		case 0x64:	m_keystate[CL_NUM4]			= TRUE;		break;
		case 0x65:	m_keystate[CL_NUM5]			= TRUE;		break;
		case 0x66:	m_keystate[CL_NUM6]			= TRUE;		break;
		case 0x67:	m_keystate[CL_NUM7]			= TRUE;		break;
		case 0x68:	m_keystate[CL_NUM8]			= TRUE;		break;
		case 0x69:	m_keystate[CL_NUM9]			= TRUE;		break;
		case 0x6A:	m_keystate[CL_MULTIPLY]		= TRUE;		break;
		case 0x6B:	m_keystate[CL_ADD]			= TRUE;		break;
		case 0x6C:	m_keystate[CL_SEP]			= TRUE;		break;
		case 0x6D:	m_keystate[CL_SUB]			= TRUE;		break;
		case 0x6E:	m_keystate[CL_DECIMAL]		= TRUE;		break;
		case 0x6F:	m_keystate[CL_DIVIDE]		= TRUE;		break;
		case 0x70:	m_keystate[CL_F1]			= TRUE;		break;
		case 0x71:	m_keystate[CL_F2]			= TRUE;		break;
		case 0x72:	m_keystate[CL_F3]			= TRUE;		break;
		case 0x73:	m_keystate[CL_F4]			= TRUE;		break;
		case 0x74:	m_keystate[CL_F5]			= TRUE;		break;
		case 0x75:	m_keystate[CL_F6]			= TRUE;		break;
		case 0x76:	m_keystate[CL_F7]			= TRUE;		break;
		case 0x77:	m_keystate[CL_F8]			= TRUE;		break;
		case 0x78:	m_keystate[CL_F9]			= TRUE;		break;
		case 0x79:	m_keystate[CL_F10]			= TRUE;		break;
		case 0x7A:	m_keystate[CL_F11]			= TRUE;		break;
		case 0x7B:	m_keystate[CL_F12]			= TRUE;		break;
		case 0x7C:	m_keystate[CL_F13]			= TRUE;		break;
		case 0x7D:	m_keystate[CL_F14]			= TRUE;		break;
		case 0x7E:	m_keystate[CL_F15]			= TRUE;		break;
		case 0x7F:	m_keystate[CL_F16]			= TRUE;		break;
		case 0x80:	m_keystate[CL_F17]			= TRUE;		break;
		case 0x81:	m_keystate[CL_F18]			= TRUE;		break;
		case 0x82:	m_keystate[CL_F19]			= TRUE;		break;
		case 0x83:	m_keystate[CL_F20]			= TRUE;		break;
		case 0x84:	m_keystate[CL_F21]			= TRUE;		break;
		case 0x85:	m_keystate[CL_F22]			= TRUE;		break;
		case 0x86:	m_keystate[CL_F23]			= TRUE;		break;
		case 0x87:	m_keystate[CL_F24]			= TRUE;		break;
		//0x88-8F	Unassigned
		case 0x90:	m_keystate[CL_NUMLOCK]		= TRUE;		break;
		case 0x91:	m_keystate[CL_NUMLOCK]		= TRUE;		break;
		//0x92-96	OEM specific
		//0x97-9F	Unassigned
		case 0xA0:	m_keystate[CL_LSHIFT]		= TRUE;		break;
		case 0xA1:	m_keystate[CL_RSHIFT]		= TRUE;		break;
		case 0xA2:	m_keystate[CL_LCTRL]		= TRUE;		break;
		case 0xA3:	m_keystate[CL_RCTRL]		= TRUE;		break;
		case 0xA4:	m_keystate[CL_LMENU]		= TRUE;		break;
		case 0xA5:	m_keystate[CL_RMENU]		= TRUE;		break;
		// Browser Keys
		case 0xBA:	m_keystate[CL_OEM_1]		= TRUE;		break;	//	
		case 0xBB:	m_keystate[CL_OEM_PLUS]		= TRUE;		break;	
		case 0xBC:	m_keystate[CL_OEM_COMMA]	= TRUE;		break;
		case 0xBD:	m_keystate[CL_OEM_MINUS]	= TRUE;		break;
		case 0xBE:	m_keystate[CL_OEM_PERIOD]	= TRUE;		break;	
		case 0xBF:	m_keystate[CL_OEM_2]		= TRUE;		break;	//	
		case 0xC0:	m_keystate[CL_OEM_3]		= TRUE;		break;	//	
		// 0xC1-D7	Reserved
		// 0xD8-DA	Unassigned
		case 0xDB:	m_keystate[CL_OEM_4]		= TRUE;		break;	//	
		case 0xDC:	m_keystate[CL_OEM_5]		= TRUE;		break;
		case 0xDD:	m_keystate[CL_OEM_6]		= TRUE;		break;
		case 0xDE:	m_keystate[CL_OEM_7]		= TRUE;		break;
		case 0xDF:	m_keystate[CL_OEM_8]		= TRUE;		break;
		// ...	}
	}
}
void		CData	::		key_Up			(WPARAM wParam)
{
	switch(wParam)
	{
		case 0x01:	m_keystate[CL_LBUTTON]		= FALSE;		break;
		case 0x02:	m_keystate[CL_RBUTTON]		= FALSE;		break;
		case 0x03:	m_keystate[CL_CANCEL]		= FALSE;		break;
		case 0x04:	m_keystate[CL_MBUTTON]		= FALSE;		break;
		case 0x05:	m_keystate[CL_XBUTTON1]		= FALSE;		break;
		case 0x06:	m_keystate[CL_XBUTTON2]		= FALSE;		break;
		//0x07		undefined
		case 0x08:	m_keystate[CL_BACKSPACE]	= FALSE;		break;
		case 0x09:	m_keystate[CL_TAB]			= FALSE;		break;
		//0x0A-0B	undefined
		case 0x0C:	m_keystate[CL_CLEAR]		= FALSE;		break;
		case 0x0D:	m_keystate[CL_RETURN]		= FALSE;		break;
		//0x0E-ßF	undefined
		case 0x10:	m_keystate[CL_SHIFT]		= FALSE;		break;
		case 0x11:	m_keystate[CL_CTRL]			= FALSE;		break;
		case 0x12:	m_keystate[CL_ALT]			= FALSE;		break;
		case 0x13:	m_keystate[CL_PAUSE]		= FALSE;		break;
		case 0x14:	m_keystate[CL_CAPS]			= FALSE;		break;
		case 0x15:	m_keystate[CL_KANA]			= FALSE;		break;
		// 17-19	IME	
		case 0x1B:	PostQuitMessage(0);							break;
		// 1C-1E	IME
		case 0x20:	m_keystate[CL_SPACE]		= FALSE;		break;
		case 0x21:	m_keystate[CL_PRIOR]		= FALSE;		break;
		case 0x22:	m_keystate[CL_NEXT]			= FALSE;		break;
		case 0x23:	m_keystate[CL_END]			= FALSE;		break;
		case 0x24:	m_keystate[CL_HOME]			= FALSE;		break;
		case 0x25:	m_keystate[CL_LEFT]			= FALSE;		break;
		case 0x26:	m_keystate[CL_UP]			= FALSE;		break;
		case 0x27:	m_keystate[CL_RIGHT]		= FALSE;		break;
		case 0x28:	m_keystate[CL_DOWN]			= FALSE;		break;
		case 0x29:	m_keystate[CL_SELECT]		= FALSE;		break;
		case 0x2A:	m_keystate[CL_PRINT]		= FALSE;		break;
		case 0x2B:	m_keystate[CL_EXECUTE]		= FALSE;		break;
		case 0x2C:	m_keystate[CL_SNAPSHOT]		= FALSE;		break;
		case 0x2D:	m_keystate[CL_INS]			= FALSE;		break;
		case 0x2E:	m_keystate[CL_DEL]			= FALSE;		break;
		case 0x2F:	m_keystate[CL_HELP]			= FALSE;		break;
		case 0x30:	m_keystate[CL_0]			= FALSE;		break;
		case 0x31:	m_keystate[CL_1]			= FALSE;		break;
		case 0x32:	m_keystate[CL_2]			= FALSE;		break;
		case 0x33:	m_keystate[CL_3]			= FALSE;		break;
		case 0x34:	m_keystate[CL_4]			= FALSE;		break;
		case 0x35:	m_keystate[CL_5]			= FALSE;		break;
		case 0x36:	m_keystate[CL_6]			= FALSE;		break;
		case 0x37:	m_keystate[CL_7]			= FALSE;		break;
		case 0x38:	m_keystate[CL_8]			= FALSE;		break;
		case 0x39:	m_keystate[CL_9]			= FALSE;		break;
		//0x3A - 40 undefined
		case 0x41:	m_keystate[CL_A]			= FALSE;		break;
		case 0x42:	m_keystate[CL_B]			= FALSE;		break;
		case 0x43:	m_keystate[CL_C]			= FALSE;		break;
		case 0x44:	m_keystate[CL_D]			= FALSE;		break;
		case 0x45:	m_keystate[CL_E]			= FALSE;		break;
		case 0x46:	m_keystate[CL_F]			= FALSE;		break;
		case 0x47:	m_keystate[CL_G]			= FALSE;		break;
		case 0x48:	m_keystate[CL_H]			= FALSE;		break;
		case 0x49:	m_keystate[CL_I]			= FALSE;		break;
		case 0x4A:	m_keystate[CL_J]			= FALSE;		break;
		case 0x4B:	m_keystate[CL_K]			= FALSE;		break;
		case 0x4C:	m_keystate[CL_L]			= FALSE;		break;
		case 0x4D:	m_keystate[CL_M]			= FALSE;		break;
		case 0x4E:	m_keystate[CL_N]			= FALSE;		break;
		case 0x4F:	m_keystate[CL_O]			= FALSE;		break;
		case 0x50:	m_keystate[CL_P]			= FALSE;		break;
		case 0x51:	m_keystate[CL_Q]			= FALSE;		break;
		case 0x52:	m_keystate[CL_R]			= FALSE;		break;
		case 0x53:	m_keystate[CL_S]			= FALSE;		break;
		case 0x54:	m_keystate[CL_T]			= FALSE;		break;
		case 0x55:	m_keystate[CL_U]			= FALSE;		break;
		case 0x56:	m_keystate[CL_V]			= FALSE;		break;
		case 0x57:	m_keystate[CL_W]			= FALSE;		break;
		case 0x58:	m_keystate[CL_X]			= FALSE;		break;
		case 0x59:	m_keystate[CL_Y]			= FALSE;		break;
		case 0x5A:	m_keystate[CL_Z]			= FALSE;		break;
		case 0x5B:	m_keystate[CL_LWIN]			= FALSE;		break;
		case 0x5C:	m_keystate[CL_RWIN]			= FALSE;		break;
		case 0x5D:	m_keystate[CL_APPS]			= FALSE;		break;
		//0x5E		reserved
		case 0x5F:	m_keystate[CL_SLEEP]		= FALSE;		break;
		case 0x60:	m_keystate[CL_NUM0]			= FALSE;		break;
		case 0x61:	m_keystate[CL_NUM1]			= FALSE;		break;
		case 0x62:	m_keystate[CL_NUM2]			= FALSE;		break;
		case 0x63:	m_keystate[CL_NUM3]			= FALSE;		break;
		case 0x64:	m_keystate[CL_NUM4]			= FALSE;		break;
		case 0x65:	m_keystate[CL_NUM5]			= FALSE;		break;
		case 0x66:	m_keystate[CL_NUM6]			= FALSE;		break;
		case 0x67:	m_keystate[CL_NUM7]			= FALSE;		break;
		case 0x68:	m_keystate[CL_NUM8]			= FALSE;		break;
		case 0x69:	m_keystate[CL_NUM9]			= FALSE;		break;
		case 0x6A:	m_keystate[CL_MULTIPLY]		= FALSE;		break;
		case 0x6B:	m_keystate[CL_ADD]			= FALSE;		break;
		case 0x6C:	m_keystate[CL_SEP]			= FALSE;		break;
		case 0x6D:	m_keystate[CL_SUB]			= FALSE;		break;
		case 0x6E:	m_keystate[CL_DECIMAL]		= FALSE;		break;
		case 0x6F:	m_keystate[CL_DIVIDE]		= FALSE;		break;
		case 0x70:	m_keystate[CL_F1]			= FALSE;		break;
		case 0x71:	m_keystate[CL_F2]			= FALSE;		break;
		case 0x72:	m_keystate[CL_F3]			= FALSE;		break;
		case 0x73:	m_keystate[CL_F4]			= FALSE;		break;
		case 0x74:	m_keystate[CL_F5]			= FALSE;		break;
		case 0x75:	m_keystate[CL_F6]			= FALSE;		break;
		case 0x76:	m_keystate[CL_F7]			= FALSE;		break;
		case 0x77:	m_keystate[CL_F8]			= FALSE;		break;
		case 0x78:	m_keystate[CL_F9]			= FALSE;		break;
		case 0x79:	m_keystate[CL_F10]			= FALSE;		break;
		case 0x7A:	m_keystate[CL_F11]			= FALSE;		break;
		case 0x7B:	m_keystate[CL_F12]			= FALSE;		break;
		case 0x7C:	m_keystate[CL_F13]			= FALSE;		break;
		case 0x7D:	m_keystate[CL_F14]			= FALSE;		break;
		case 0x7E:	m_keystate[CL_F15]			= FALSE;		break;
		case 0x7F:	m_keystate[CL_F16]			= FALSE;		break;
		case 0x80:	m_keystate[CL_F17]			= FALSE;		break;
		case 0x81:	m_keystate[CL_F18]			= FALSE;		break;
		case 0x82:	m_keystate[CL_F19]			= FALSE;		break;
		case 0x83:	m_keystate[CL_F20]			= FALSE;		break;
		case 0x84:	m_keystate[CL_F21]			= FALSE;		break;
		case 0x85:	m_keystate[CL_F22]			= FALSE;		break;
		case 0x86:	m_keystate[CL_F23]			= FALSE;		break;
		case 0x87:	m_keystate[CL_F24]			= FALSE;		break;
		//0x88-8F	Unassigned
		case 0x90:	m_keystate[CL_NUMLOCK]		= FALSE;		break;
		case 0x91:	m_keystate[CL_NUMLOCK]		= FALSE;		break;
		//0x92-96	OEM specific
		//0x97-9F	Unassigned
		case 0xA0:	m_keystate[CL_LSHIFT]		= FALSE;		break;
		case 0xA1:	m_keystate[CL_RSHIFT]		= FALSE;		break;
		case 0xA2:	m_keystate[CL_LCTRL]		= FALSE;		break;
		case 0xA3:	m_keystate[CL_RCTRL]		= FALSE;		break;
		case 0xA4:	m_keystate[CL_LMENU]		= FALSE;		break;
		case 0xA5:	m_keystate[CL_RMENU]		= FALSE;		break;
		// Browser Keys
		case 0xBA:	m_keystate[CL_OEM_1]		= FALSE;		break;		
		case 0xBB:	m_keystate[CL_OEM_PLUS]		= FALSE;		break;	
		case 0xBC:	m_keystate[CL_OEM_COMMA]	= FALSE;		break;
		case 0xBD:	m_keystate[CL_OEM_MINUS]	= FALSE;		break;
		case 0xBE:	m_keystate[CL_OEM_PERIOD]	= FALSE;		break;	
		case 0xBF:	m_keystate[CL_OEM_2]		= FALSE;		break;		
		case 0xC0:	m_keystate[CL_OEM_3]		= FALSE;		break;		
		// 0xC1-D7	Reserved
		// 0xD8-DA	Unassigned
		case 0xDB:	m_keystate[CL_OEM_4]		= FALSE;		break;	
		case 0xDC:	m_keystate[CL_OEM_5]		= FALSE;		break;
		case 0xDD:	m_keystate[CL_OEM_6]		= FALSE;		break;
		case 0xDE:	m_keystate[CL_OEM_7]		= FALSE;		break;
		case 0xDF:	m_keystate[CL_OEM_8]		= FALSE;		break;
		// ...
	}
}
void		CData	::		set_Mouse		(POINT ptCursor)
{
	m_X			= ptCursor.x;
	m_Y			= ptCursor.y;
}
void		CData	::		refresh_temp_M	()
{
	m_tempX		= m_X;
	m_tempY		= m_Y;
	m_tempW		= m_wheel;
}
void		CData	::		calc_relative_M	()
{
	m_Xi		= m_X-m_tempX;
	m_Yi		= m_Y-m_tempY;
	m_wheel	   -= m_tempW;
}

//	Console	///////////////////////////////////////////////////////////////////////////

bool		CData	::		get_wireframe()
{
	return m_wireframe;
}
bool*		CData	::		get_wireframe_ptr()
{
	return &m_wireframe;
}
void		CData	::		set_ConsoleAttachPointer(vector<_ConsoleString>* ptr)
{
	m_pConsoleText = ptr;
}
void		CData	::		append_toConsole(_ConsoleString line)
{
	m_pConsoleText->push_back(line);
}

//	GUI		///////////////////////////////////////////////////////////////////////////

LPD3DXFONT*	CData	::		get_LPD3font	(int select)
{	
	switch(select)
	{	
		case 1:
			return m_LPD3font_Display;	
			break;
		case 2:
			return m_LPD3font_Console;
			break;
		default:
			return m_LPD3font_Display;
			break;
	}
}
void		CData	::		set_LPD3font	(LPD3DXFONT* font, int select)
{	
	switch(select)
	{	
		case 1:
			m_LPD3font_Display = font;	
			break;
		case 2:
			m_LPD3font_Console = font;	
			break;
	}					
}

//	View	///////////////////////////////////////////////////////////////////////////

float		CData	::		get_viewRotH	()
{	
	return m_viewRotHori;					
}
float		CData	::		get_viewRotV	()
{	
	return m_viewRotVert;					
}
float		CData	::		get_viewDist	()
{	
	return m_viewDistance;					
}
D3DXVECTOR3* CData	::		get_CamPosPtr	()
{	
	return m_CamPos;						
}
D3DXVECTOR3* CData	::		get_LookAtPtr	()
{	
	return m_LookAt;						
}
D3DXMATRIX*	CData	::		get_matViewPtr	()
{	
	return m_matView;						
}
D3DXMATRIX*	CData	::		get_matProjPtr	()
{	
	return m_matProjection;					
}
void		CData	::		set_viewRotH	(float value)
{	
	m_viewRotHori = value;					
}
void		CData	::		set_viewRotV	(float value)
{	
	m_viewRotVert = value;					
}
void		CData	::		set_viewDist	(float value)
{	
	m_viewDistance = value;					
}
void		CData	::		set_CamPosPtr	(D3DXVECTOR3* vec)
{	
	m_CamPos = vec;							
}
void		CData	::		set_CamPos		(D3DXVECTOR3* vec)
{	
	*m_CamPos = *vec;						
}
void		CData	::		set_LookAtPtr	(D3DXVECTOR3* vec)
{	
	m_LookAt = vec;							
}
void		CData	::		set_LookAt		(D3DXVECTOR3* vec)
{	
	*m_LookAt = *vec;						
}
void		CData	::		set_matViewPtr	(D3DXMATRIX* mat)
{	
	m_matView = mat;						
}
void		CData	::		set_matProjPtr	(D3DXMATRIX* mat)
{	
	m_matProjection = mat;					
}

//	Hexapod	///////////////////////////////////////////////////////////////////////////

float		CData	::		get_LAngle_X	()
{
	return m_LAngle_X;
}
float		CData	::		get_LAngle_Y	()
{
	return m_LAngle_Y;
}
float		CData	::		get_LAngle_Z	()
{
	return m_LAngle_Z;
}
float		CData	::		get_LAngle_S	()
{
	return m_LAngle_S;
}
float		CData	::		get_LHeight		()
{
	return m_LHeight;
}
float		CData	::		get_LTranX		()
{
	return m_LTranX;
}
float		CData	::		get_LTranZ		()
{
	return m_LTranZ;
}
void		CData	::		set_LAngle_X	(float value)
{
	m_LAngle_X = value;
}
void		CData	::		set_LAngle_Y	(float value)
{
	m_LAngle_Y = value;
}
void		CData	::		set_LAngle_Z	(float value)
{
	m_LAngle_Z = value;
}
void		CData	::		set_LAngle_S	(float value)
{
	m_LAngle_S = value;
}
void		CData	::		set_LHeight		(float value)
{
	m_LHeight = value;
}
void		CData	::		set_LTranX		(float value)
{
	m_LTranX = value;
}
void		CData	::		set_LTranZ		(float value)
{
	m_LTranZ = value;
}

//	Leg		///////////////////////////////////////////////////////////////////////////
void		CData	::		attach_WTarget	(int leg, Observer* obs)
{	
	m_obsWTarget[leg].push_back(obs);		
}
void		CData	::		attach_Target	(int leg, Observer* obs)
{	
	m_obsTarget[leg].push_back(obs);		
}
void		CData	::		attach_SvoAngle	(int leg, Observer* obs)
{	
	m_obsSvoAngle[leg].push_back(obs);		
}

float		CData	::		get_SvoAngle		(int leg, int servo)
{	
	return m_SvoAngle[leg][servo];			
}
float		CData	::		get_SvoRelativeAngle(int leg, int servo)
{
	return m_SvoRelativeAngle[leg][servo];
}
D3DXVECTOR3* CData	::		get_WorldTargetPtr	(int leg)
{	
	return &m_WorldTarget[leg];					
}
D3DXVECTOR3* CData	::		get_WTargetTempPtr	(int leg)
{
	return &m_WTargetTemp[leg];
}
D3DXVECTOR3* CData	::		get_TargetPtr		(int leg)
{	
	return &m_Target[leg];						
}
D3DXVECTOR3* CData	::		get_PosVecPtr		(int leg, int pos)
{	
	return &m_PosVec[leg][pos];					
}
D3DXMATRIX*	CData	::		get_matTransformPtr	(int leg, int value)
{	
	return &m_matTransform[leg][value];			
}
D3DXMATRIX*	CData	::		get_matDirPtr		(int leg)
{	
	return &m_matDir[leg];						
}
D3DXMATRIX*	CData	::		get_matTransPosPtr	(int leg)
{	
	return &m_matTransPos[leg];					
}
D3DXMATRIX*	CData	::		get_matBodySizePtr	()
{	
	return &m_matBodySize;						
}
D3DXMATRIX*	CData	::		get_matAxisSizePtr	()
{	
	return &m_matAxisSize;					
}
D3DXMATRIX*	CData	::		get_matRot90Ptr		()
{	
	return &m_matRot90;							
}
D3DXMATRIX*	CData	::		get_matTurnPtr		()
{	
	return &m_matTurn;							
}
D3DXMATRIX*	CData	::		get_matTransSOPtr	()
{	
	return &m_matTransSO;						
}
D3DXMATRIX*	CData	::		get_matTransVSPtr	()
{	
	return &m_matTransVS;						
}
D3DXMATRIX*	CData	::		get_matTransOSPtr	()
{	
	return &m_matTransOS;						
}
D3DXMATRIX*	CData	::		get_matTransUSPtr	()
{	
	return &m_matTransUS;						
}

void		CData	::		set_SvoAngle		(int leg, int servo, float value)
{
	m_SvoRelativeAngle[leg][servo] = abs(m_SvoAngle[leg][servo] - value)*180/3.14159f;
	m_SvoAngle[leg][servo] = value;
	for(unsigned int i = 0; i < m_obsSvoAngle[leg].size() ; i++) m_obsSvoAngle[leg][i]->notify_SvoAng();
}
void		CData	::		set_SvoAngle		(int leg, float v1, float v2, float v3, float v4)
{
	m_SvoRelativeAngle[leg][0] = abs(m_SvoAngle[leg][0] - v1)*180/3.14159f;
	m_SvoRelativeAngle[leg][1] = abs(m_SvoAngle[leg][1] - v2)*180/3.14159f;
	m_SvoRelativeAngle[leg][2] = abs(m_SvoAngle[leg][2] - v3)*180/3.14159f;
	m_SvoRelativeAngle[leg][3] = abs(m_SvoAngle[leg][3] - v4)*180/3.14159f;

	m_SvoAngle[leg][0] = v1;
	m_SvoAngle[leg][1] = v2;
	m_SvoAngle[leg][2] = v3;
	m_SvoAngle[leg][3] = v4;
	for(unsigned int i = 0; i < m_obsSvoAngle[leg].size() ; i++) m_obsSvoAngle[leg][i]->notify_SvoAng();
}
void		CData	::		set_WorldTarget	(int leg, D3DXVECTOR3* vec)
{
	m_WorldTarget[leg] = *vec;
	for(unsigned int i = 0; i < m_obsWTarget[leg].size() ; i++) 
	{
		//m_obsWTarget[leg][i]->notify_WTarget();
		m_obsWTarget[leg].at(i)->notify_WTarget();
	}
}
void		CData	::		set_WTargetTemp (int leg, D3DXVECTOR3* vec)
{
	m_WTargetTemp[leg] = *vec;
}
void		CData	::		set_Target		(int leg, D3DXVECTOR3* vec)
{
	m_Target[leg] = *vec;
	for(unsigned int i = 0; i < m_obsTarget[leg].size() ; i++) m_obsTarget[leg][i]->notify_Target();
}
void		CData	::		set_matTransform(int leg, int value, D3DXMATRIX* mat)
{
	m_matTransform[leg][value] = *mat;
	int posval = value;
	if(value != 2)
	{
		if(value > 2) posval -= 1;
		m_PosVec[leg][posval] = D3DXVECTOR3(m_matTransform[leg][value]._41, m_matTransform[leg][value]._42, m_matTransform[leg][value]._43);
	}
}
void		CData	::		set_matDir		(int leg, D3DXMATRIX* mat)
{	
	m_matDir[leg] = *mat;					
}
void		CData	::		set_matTransPos	(int leg, D3DXMATRIX* mat)
{	
	m_matTransPos[leg] = *mat;				
}
void		CData	::		set_matBodySize	(D3DXMATRIX*	mat)
{	
	m_matBodySize = *mat;					
}
void		CData	::		set_matAxisSize	(D3DXMATRIX*	mat)
{	
	m_matAxisSize = *mat;					
}

//	General	///////////////////////////////////////////////////////////////////////////

void		CData	::		attach_BegScene(Observer* obs)
{	
	m_obsBeginScene.push_back(obs);			
}

void		CData	::		RestartProcess()
{
	HMODULE hmod = GetModuleHandle(NULL);//GetCurrentModule();
	TCHAR exePath[1024];
	GetModuleFileName(NULL, exePath, 1024);

	STARTUPINFO			startupInfo = {0};
	PROCESS_INFORMATION processInformation;

	CreateProcess(	exePath, NULL, NULL, NULL, FALSE, 
					NORMAL_PRIORITY_CLASS, NULL, NULL, 
					&startupInfo, &processInformation);

	m_KillThisProcess = true;
}
bool		CData	::	KillThisProcess()
{
	return m_KillThisProcess;
}

void		CData	::		call_SceneCtrl	()
{
	m_obsBeginScene[0]->notify_BegScene();
}
void		CData	::		call_SceneGUI	()
{
	m_obsBeginScene[1]->notify_BegScene();
}
_CInitial*	CData	::	get_INI	()
{	
	return new _CInitial();							
}
_UDPSocket*	CData	::	get_UDP	()
{
	return new _UDPSocket(&m_Acceleration, &m_RollPitchYaw);
}
int			CData	::		get_ReadDelay	()
{	
	return m_ReadDelay;						
}
void		CData	::		set_ReadDelay	(int value)
{	
	m_ReadDelay = value;					
}

Sone

Ich glaube so etwas nennt man monolithische Klasse...