HUD aus Array erzeugen

[_Black_Hawk_]

hallo alle zusammen!

ich bin neu hier in dem forum, kenn mich nicht ganz so gut aus in C# (ich wills so nebenbei in meiner freizeit lernen) und hab da eine kleine große frage :

zu erst mal was ich machen möchte:

Ich will in C# ein Programm machen, dass mir in einer GUI aus vielen gegebenen Punkten mit Material-ID und Farbcode eine first-person-ansicht erstellt. (wird später vll mal sowas wie cs 1.6:D)

Die Karte besteht aus einem Array mit 4 Dimensionen Karte[299][299][199][1],

die ersten drei dimensionen sind die Punktkoordinaten X, Y, Z; und die 4. dimension: [0] => ist die Material-ID (ich hab erstmal 0 für luft, und 1 für erde)

[1] => ist der farbcode.

Mein Problem ist nun: mein Programm stürtzt ab

ich glaube auch zu wissen an welcher stelle: an der stelle wo in der if-schleife das array "Karte" ausgewertet wird!

aber wiso? ich bekomme auch keine warnung vom compiler!

Hier poste ich mal den Code, was ich bis jez gemacht hab:

#include <windows.h>

#include <math.h>

#include <stdio.h>

//wie gesagt das Kartenarray

int Karte[299][299][199][1];

//die Koordinaten, wo quasi das "Auge" sitzt

int Xa = 50; int Ya = 50; int Za = 30;

//in welche richtung das Auge schaut

float Alpha = 30; float Beta = 90;

//welche sichtweite das Auge, bzw. der monitor hat

float Gamma = 35; float Phi = 45;

//die Programmauflösung

int PIXW = 800; int PIXH = 600;

int SichtW = 300;

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

LPCSTR lpszAppName = "Testprogramm";

LPCSTR lpszTitle = "Testprogramm";

int APIENTRY WinMain(HINSTANCE hInstance,

HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)

{

HWND hWnd;

MSG msg;

WNDCLASSEX wc;

wc.cbSize = sizeof(WNDCLASSEX);

wc.style = CS_HREDRAW | CS_VREDRAW;

wc.lpfnWndProc = WndProc;

wc.cbClsExtra = 0;

wc.cbWndExtra = 0;

wc.hInstance = hInstance;

wc.hCursor = LoadCursor(NULL,IDC_ARROW);

wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);

wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);

wc.lpszClassName = lpszAppName;

wc.lpszMenuName = lpszAppName;

wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

if( RegisterClassEx(&wc) == 0)

return 0;

hWnd = CreateWindowEx(

0,

lpszAppName,

lpszTitle,

WS_OVERLAPPEDWINDOW,

0,

0,

CW_USEDEFAULT,

CW_USEDEFAULT,

NULL,

NULL,

hInstance,

NULL);

if( hWnd == NULL)

return 0;

ShowWindow(hWnd, iCmdShow);

UpdateWindow(hWnd);

while (GetMessage(&msg, NULL, 0, 0) > 0)

{

TranslateMessage(&msg);

DispatchMessage(&msg);

}

return msg.wParam;

}

LRESULT CALLBACK WndProc(HWND hWnd, UINT umsg, WPARAM wParam, LPARAM lParam)

{

HDC hDC;

switch (umsg)

{

case WM_RBUTTONDOWN:

//hier gehts eigentlich richtig los:

{

float WV1;

float WV2;

float WV3;

float WV4;

float WV5;

float WV6;

float TangensAlpha;

float TangensBeta;

int Xtuw;

int Ytuw;

int Ztuw;

WV1 = PIXW/2;

WV2 = PIXH/2;

WV3 = Phi/PIXW;

WV4 = Gamma/PIXH;

hDC = GetDC(hWnd);

for(int PIXHw = 1; PIXHw < PIXH; PIXHw ++)

{

TangensAlpha = tan(WV4*(PIXHw-WV2));

WV5 = Za-TangensAlpha*Xa;

for(int PIXWw = 1; PIXWw < PIXW; PIXWw ++)

{

TangensBeta = tan(WV3*(PIXWw-WV1));

WV6 = Ya-TangensBeta*Xa;

for(float X = 1 ; X < SichtW; X++)

{

float Y;

float Z;

Y = TangensBeta*X+WV6;

Z = TangensAlpha*X+WV5;

Ytuw = (int)Y;

Ztuw = (int)Z;

Xtuw = (int)X;

if(Karte[Xtuw][Ytuw][Ztuw][0] != 0)

{

SetPixel(hDC, PIXWw, PIXHw, Karte[Xtuw][Ytuw][Ztuw][1]);

X = SichtW;

}

else if(X == SichtW)

{

SetPixel(hDC, PIXWw, PIXHw, RGB(0, 0, 0));

}

}

}

}

ReleaseDC(hWnd, hDC);

}

break;

case WM_DESTROY:

{

PostQuitMessage(0);

return 0;

}

}

return DefWindowProc(hWnd, umsg, wParam, lParam);

}

ich bedanke mich schon mal im vorraus für hilfe:)

[Klotzkopp]

Willst du jetzt C oder C#? Du schreibst mehrfach von C#, aber dein Code ist C. Das sind zwei völlig unterschiedliche Programmiersprachen.

[_Black_Hawk_]

C natürlich :upps

[Klotzkopp]

Die Karte besteht aus einem Array mit 4 Dimensionen Karte[299][299][199][1],

Damit hast du ein Array mit 299 * 299 * 299 * 1 Elementen.

Die jeweil höchsten erlaubten Indizes sind also 298, 298, 298 und 0.

Sprich: Jede Dimension deines Arrays ist um 1 zu klein.

[_Black_Hawk_]

mhm intressant! das heißt: ein array int Test[2] hat "in sich" tatsächlich 2 integer-variablen:

Variable1 = Test[0];

Variable2 = Test[1];

oder?

ich werds mal im code berichtigen und sehen was passiert...

ich hab die befürchtung das meine methode für die berechnung sehr ineffizent ist ... mal sehen

[_Black_Hawk_]

ich habs berichtigt, aber der fehler ist immer noch der gleiche: "wollen sie einen Problembericht senden? ... ... ...":rolleyes:,

kann es sein dass es wegen der typumwandlung von "float Y" in "int Ytuw" probleme gibt?

und nebenbei: die graphik wird bei mir nicht von der grafikkarte berechnet, sondern größtenteils vom prozessor, oder?

[Klotzkopp]

ich habs berichtigt, aber der fehler ist immer noch der gleiche: "wollen sie einen Problembericht senden? ... ... ...":rolleyes:,

Dann solltest du prüfen, ob deine berechneten Array-Indizes wirklich im gültigen Bereich liegen.

Ich hab das mal mit dem Debugger geprüft (hättest du auch selbst tun können), und schon beim ersten Durchlauf ist Ztuw -268. Hast du daran gedacht, dass die Winkelfunktionen ihre Argumente in Bogenmaß erwarten?

und nebenbei: die graphik wird bei mir nicht von der grafikkarte berechnet, sondern größtenteils vom prozessor, oder?

Eher ausschließlich als größtenteils.

[_Black_Hawk_]

naja das mit der berechnung der pixel is mir jez mal sch...egal, weil das hab ich mir selbst überlegt und bin grad voll stolz drauf (<<wird sich wahrscheinlich legen, wenn ich für den bildaufbau 10s warten muss :D:D)

mhm das mit dem bogenmaß hab ich berücksichtigt, aber es könnte wirklich sein dass ich in einen ungültigen bereich gekommen bin!

gibt es eig eine einfache art, wie man die variablen in der GUI ausgeben kann?

sowas wie eine dialogbox oder ähnlich wär toll!

[Klotzkopp]

gibt es eig eine einfache art, wie man die variablen in der GUI ausgeben kann?

sowas wie eine dialogbox oder ähnlich wär toll!

Es gibt die MessageBox-Funktion. Aber warum benutzt du nicht den Debugger?

[_Black_Hawk_]

ich weis ehrlich gesagt nicht was du mit debugger meinst, jedenfalls hab ich das mit der messagebox ausprobiert.

diese kann aber nur strings ausgeben, und alle versuche meine integer in einen string umzuwandeln schlug fehl.

ich hab provisorisch eine consoleapplication gemacht, die das gleiche rechnet ...

und siehe da, ich hatte einen fehler in meiner berechnung (hab ihn gleich ausgebessert)

jezt muss ich nur noch eine if abfrage machen, die verhindert dass ich in undefinierte bereiche komme....

wenn ich das gemacht habe, poste ich nochmal den code (ich versuchs mal ein bisschen übersichtlicher zu posten XD),und ich hoffe ich kann mich übers we dafür aufraffen XDDD

[Klotzkopp]

ich weis ehrlich gesagt nicht was du mit debugger meinst

Ein Debugger ist ein Programm, mit dem du dein Programm Schritt für Schritt durchgehen kannst und dir alle Variableninhalte ansehen kannst.

diese kann aber nur strings ausgeben, und alle versuche meine integer in einen string umzuwandeln schlug fehl.

Hättest du jetzt ein wenig Code gezeigt, hätte man dir da weiterhelfen können.

[_Black_Hawk_]

Ich bin jezt weiter!!! *freu*

ich hab jez einiges übersichtlicher gemacht, der bildaufbau ist schneller als ich dachte, hier ist der code:

allerdings stürtzt mein programm immernoch ab

@klotzkopp: kannst du mir einen debugger empfehlen?

#include <windows.h>

#include <math.h>

#include <stdio.h>

//#include "bulletcraft.h"

//#include "bulletcraftGL.h"


#define PI 3.14159 // Konstante PI


int Karte[300][300][200][2];




LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);


LPCSTR lpszAppName = "Bulletcraft";

LPCSTR lpszTitle   = "Bulletcraft";


int APIENTRY WinMain(HINSTANCE hInstance,

HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)

{


	HWND       hWnd;

	MSG        msg;

	WNDCLASSEX   wc;


 	wc.cbSize        =  sizeof(WNDCLASSEX);

 	wc.style         =  CS_HREDRAW | CS_VREDRAW;

 	wc.lpfnWndProc   =  WndProc;

	wc.cbClsExtra    =  0;

 	wc.cbWndExtra    =  0;

 	wc.hInstance     =  hInstance;

 	wc.hCursor       =  LoadCursor(NULL,IDC_ARROW);

 	wc.hIcon         =  LoadIcon(NULL, IDI_APPLICATION);

 	wc.hbrBackground =  (HBRUSH)GetStockObject(WHITE_BRUSH);

 	wc.lpszClassName =  lpszAppName;

 	wc.lpszMenuName  =  lpszAppName;

 	wc.hIconSm       =  LoadIcon(NULL, IDI_APPLICATION);


	if( RegisterClassEx(&wc) == 0)

	return 0;


	hWnd = CreateWindowEx(

		0,

		lpszAppName,

		lpszTitle,

		WS_OVERLAPPEDWINDOW,

		0,

		0,

		CW_USEDEFAULT,

		CW_USEDEFAULT,

		NULL,

		NULL,

		hInstance,

		NULL);


	if( hWnd == NULL)

	return 0;


	ShowWindow(hWnd, iCmdShow);

	UpdateWindow(hWnd);


	while (GetMessage(&msg, NULL, 0, 0) > 0)

	{

		TranslateMessage(&msg);

		DispatchMessage(&msg);

	}

	return msg.wParam;

}


LRESULT CALLBACK WndProc(HWND hWnd, UINT umsg, WPARAM wParam, LPARAM lParam)

{

	HDC hDC;

	switch (umsg)

	{

		case WM_RBUTTONDOWN:


		//provisorische Karte

		{

			for(int i = 0; i < 300; ++i)

			{

				for(int o = 0; o < 300; ++o)

				{

					Karte[i][o][0][0]=1;

					Karte[i][o][0][1]=1;

				}

			}

			for(int z = 1; z < 200; ++z)

			{

				for(int q = 0; q < 300; ++q)

				{

					for(int w = 0; w < 300; ++w)

					{

						Karte[q][w][z][0]=0;

						Karte[q][w][z][1]=0;

					}

				}

			}


			//Initialisierung der Variablen


			// Koordinaten von Auge

			int Xa; int Ya; int Za;

			//Winkelmaß in das das Auge sieht

			float Alpha; float Beta;

			//Auf einzelne Pixel bezogene Sichtwinkel (in Schleife verwendet)

			float AlphaPix; float BetaPix;

			float RadAlphaPix; float RadBetaPix;

			//Sichtweite (Schleifendurchläufe)

			int SichtW;

			//Auf einzelne Pixel bezogene X- und Y-Werte vom HUD

			int XPix; int YPix;

			//HUD-Auflösung

			int PIXH; int PIXW;

			//HUD-Sichtwinkel

			float Gamma; float Phi;

			//Koordinaten in Abhängigkeit von X

			int X; float Y; float Z;

			//Typumgewandelte Koordinaten

			int Ytuw; int Ztuw;


			//übergabe von Testwerten

			PIXH = 300; PIXW = 400;

			Xa = 50; Ya = 50; Za = 50;

			Alpha = 98;

			Beta = 10;

			SichtW = 50;

			Gamma = 45; Phi = 30;



			//Berechnung und ausgabe der Pixel

			hDC = GetDC(hWnd);

			YPix = 1;

			for(; YPix < PIXH; ++YPix)

			{

				XPix = 1;

				for(; XPix < PIXW; ++XPix)

				{

					X = 1;

					for(; X < SichtW; ++X)

					{


						// Berechnung der funktionen

						BetaPix = (Gamma/PIXW)*(XPix-PIXW/2)+Beta;

						AlphaPix = (Phi/PIXH)*(YPix-PIXH/2)+Alpha;


						//Berechnung der Bogenmaße

						RadAlphaPix = AlphaPix*(PI/180);

						RadBetaPix = BetaPix*(PI/180);


						Y = tan(RadBetaPix)*X+(Ya-tan(RadBetaPix)*Xa)+0.5;

						Z = tan(RadAlphaPix)*X+(Za-tan(RadAlphaPix)*Xa)+0.5;


						//Typumwandlung

						Ytuw = (int) Y;

						Ztuw = (int) Z;


						//Prüfung auf undefinierte Bereiche und Sichtweite

						if(Ztuw > 200 | Ztuw < 0 | Ytuw > 300 | Ytuw < 0 | X >300 | X < 0 | X >= SichtW)

						{

							X = SichtW;

							SetPixel(hDC, XPix, YPix, RGB(0, 255, 0));

						}


						//Prüfung ob auf den berechneten Koordinaten ein Block ist

						if(Karte[X][Ytuw][Ztuw][0] != 0)

						{

							//###################################

							//SetPixel(hDC, XPix, YPix, Karte[X][Ytuw][Ztuw][1]);

							SetPixel(hDC, XPix, YPix, RGB(255, 0, 0));

							//###################################

							X = SichtW;

						}			

					}

				}

			}

			ReleaseDC(hWnd, hDC);

		}


		break;




		case WM_DESTROY:

		{

			PostQuitMessage(0);

			return 0;

		}

	}

	return DefWindowProc(hWnd, umsg, wParam, lParam);

}

[Klotzkopp]

allerdings stürtzt mein programm immernoch ab

Du prüfst zwar auf gültige Werte, machst aber im Fehlerfall nur etwas Zusätzliches (den grünen Pixel). Die nachfolgende Block-Prüfung machst du in jedem Fall, auch mit ungültigen Werten.

@klotzkopp: kannst du mir einen debugger empfehlen?

Möglicherweise ist bei deiner Entwicklungsumgebung schon einer dabei. Was benutzt du denn?

[_Black_Hawk_]

ich benutz pelles C

ich hab mal ein bisschen drauf rumgeklickt:

wenn ich da auf "fehlersuche starten" geh, führt der das programm aus, und sagt mir alles was es macht.

leider kann ich nur mit dem scrollrad nach unten scrollen, was es bei 600 zeilen etwas mühsam ist:schlaf:.

ich hab das if in ein else if geändert: und siehe da es funzt ... jez muss ich "nur noch" die sichtwinkel von der maus, und die Augenkoordinaten von der tastatur verändern lassen

Bearbeitet 21. Januar 2011 von _Black_Hawk_

[_Black_Hawk_]

ich seh lauter hübsche streifenmuster, aber nicht den boden von der karte :D

[_Black_Hawk_]

ich hab mein kleines testprogramm jez fertig,

ich poste den code, falls es i-wen intressiert

(erst auf '1' drücken, dann die maus bewegen:cool:)

#include <windows.h>

#include <math.h>

#include <stdio.h>

#include <string.h>

//#include "bulletcraft.h"

//#include "bulletcraftGL.h"


#define PI 3.14159 // Konstante PI

#define PI180 (PI/180)



//Initialisierung der Variablen


//HDC

HDC hDC;

// Koordinaten von Auge

int Xa; int Ya; int Za;

//Winkelmaß in das das Auge sieht

float Alpha; float Beta;

//Auf einzelne Pixel bezogene Sichtwinkel (in Schleife verwendet)

float AlphaPix; float BetaPix;

float RadAlphaPix; float RadBetaPix;

//Sichtweite (Schleifendurchläufe)

int SichtW;

//Auf einzelne Pixel bezogene X- und Y-Werte vom HUD

int XPix; int YPix;

//HUD-Auflösung

int PIXH; int PIXW;

//HUD-Sichtwinkel

float Gamma; float Phi;

//Koordinaten in Abhängigkeit von X

int X; float Y; float Z;

//Typumgewandelte Koordinaten

int Ytuw; int Ztuw;

//Karte als array

int Karte[300][300][200][2];

//Kartengröße

int KarteX; int KarteY; int KarteZ;



//Starten der GUI

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);


LPCSTR lpszAppName = "Bulletcraft";

LPCSTR lpszTitle   = "Bulletcraft";


int APIENTRY WinMain(HINSTANCE hInstance,

HINSTANCE hPrevInstance, PSTR szCmdLine, int iCmdShow)

{


	HWND       hWnd;

	MSG        msg;

	WNDCLASSEX   wc;


 	wc.cbSize        =  sizeof(WNDCLASSEX);

 	wc.style         =  CS_HREDRAW | CS_VREDRAW;

 	wc.lpfnWndProc   =  WndProc;

	wc.cbClsExtra    =  0;

 	wc.cbWndExtra    =  0;

 	wc.hInstance     =  hInstance;

 	wc.hCursor       =  LoadCursor(NULL,IDC_ARROW);

 	wc.hIcon         =  LoadIcon(NULL, IDI_APPLICATION);

 	wc.hbrBackground =  (HBRUSH)GetStockObject(WHITE_BRUSH);

 	wc.lpszClassName =  lpszAppName;

 	wc.lpszMenuName  =  lpszAppName;

 	wc.hIconSm       =  LoadIcon(NULL, IDI_APPLICATION);


	if( RegisterClassEx(&wc) == 0)

	return 0;


	hWnd = CreateWindowEx(

		0,

		lpszAppName,

		lpszTitle,

		WS_OVERLAPPEDWINDOW,

		0,

		0,

		CW_USEDEFAULT,

		CW_USEDEFAULT,

		NULL,

		NULL,

		hInstance,

		NULL);


	if( hWnd == NULL)

	return 0;


	ShowWindow(hWnd, iCmdShow);

	UpdateWindow(hWnd);


	while (GetMessage(&msg, NULL, 0, 0) > 0)

	{

		TranslateMessage(&msg);

		DispatchMessage(&msg);

	}

	return msg.wParam;

}



LRESULT CALLBACK WndProc(HWND hWnd, UINT umsg, WPARAM wParam, LPARAM lParam)

{


	switch (umsg)

	{

		//hier werden die tastatureingaben ausgewertet

		case WM_CHAR:


		{


			switch( wParam )

			{

				case 's' :

				{

					Alpha = Alpha-5;

				}

				break;

				case 'w':

				{

					Alpha = Alpha+5;

				}

				break;

				case 'a':

				{

					Beta = Beta-10;

				}

				break;

				case 'd':

				{

					Beta = Beta+10;

				}

				break;

				case '1':

				{

					//übergabe von Testwerten

					PIXH = 200; PIXW = 400;

					Xa = 0; Ya = 15; Za = 5;

					Alpha = 90;

					Beta = 0;

					SichtW = 20;

					Gamma = 180; Phi = 90;

					KarteX = 30; KarteY = 30; KarteZ = 20;


					//provisorische Karte

					for(int i = 0; i < KarteX; ++i)

					{

						for(int o = 0; o < KarteY; ++o)

						{

							Karte[i][o][0][0]=1;

							Karte[i][o][0][1]=100;

						}

					}

					for(int z = 1; z < KarteZ; ++z)

					{

						for(int q = 0; q < KarteX; ++q)

						{

							for(int w = 0; w < KarteY; ++w)

							{

								Karte[q][w][z][0]=0;

								Karte[q][w][z][1]=0;

							}

						}

					}

					for(int d = 0; d < 15; ++d)

					{

						for(int x = 15; x < 20; ++x)

						{

							for(int y = 15; y < 20; ++y)

							{

								Karte[x][y][d][0]=1;

								Karte[x][y][d][1]=1;

							}

						}

					}

				}

				break;

			}

		}


		break;


		case WM_MOUSEMOVE:

		{

			int MX = LOWORD( lParam );

			int MY = HIWORD( lParam );



			//Berechnung und ausgabe der Pixel

			hDC = GetDC(hWnd);


			float WV1;

			float WV2;

			float PhiPIXH = Phi/PIXH;

			float GammaPIXW = Gamma/PIXW;


			YPix = 1;

			for(; YPix < PIXH; ++YPix)

			{


				AlphaPix = (PhiPIXH)*(YPix-PIXH/2)+Alpha;

				RadAlphaPix = AlphaPix*(PI180);

				WV2 = (Za-tan(RadAlphaPix)*Xa)+0.5;


				XPix = 1;

				for(; XPix < PIXW; ++XPix)

				{


					BetaPix = (GammaPIXW)*(XPix-PIXW/2)+Beta;

					RadBetaPix = BetaPix*(PI180);

					WV1 = (Ya-tan(RadBetaPix)*Xa)+0.5;


					X = 1;

					for(; X < SichtW; ++X)

					{


						Y = tan(RadBetaPix)*X+WV1;

						Z = tan(RadAlphaPix)*X+WV2;


						//Typumwandlung

						Ytuw = (int) Y;

						Ztuw = (int) Z;


						//Prüfung auf undefinierte Bereiche und Sichtweite

						if(Ztuw > KarteZ | Ztuw < 0 | Ytuw > KarteY | Ytuw < 0 | X >KarteX | X < 0 | X > SichtW-2)

						{

							X = SichtW;

							SetPixel(hDC, XPix+50, (-YPix+PIXH+50), RGB(0, 200, 250));


						}


						//Prüfung ob auf den berechneten Koordinaten ein Block ist

						else if(Karte[X][Ytuw][Ztuw][0] != 0)

						{

							//###################################

							SetPixel(hDC, XPix+50, (-YPix+PIXH+50), Karte[X][Ytuw][Ztuw][1]);

							//SetPixel(hDC, XPix, YPix, RGB(155, 150, 0));

							//###################################

							X = SichtW;

						}			

					}

				}

			}


			//schreibt in den Hud die sichtwinkel

			char message[46];

			sprintf (message, "Vertikal: %f     Horizontal: %f", Alpha, Beta);

			PAINTSTRUCT ps;

			TextOut(hDC, 10, 10, message, 45);

			EndPaint(hWnd, &ps);

			ReleaseDC(hWnd, hDC);



			return 0;

		}


		break;




		case WM_DESTROY:

		{

			PostQuitMessage(0);

			return 0;

		}

	}

	return DefWindowProc(hWnd, umsg, wParam, lParam);

}

^^ ich hab ihn ein bisschen optimiert, sodass der pc nicht jedesmal in der letzten for schleife die gesammte sin-rechnung machen muss, aber der bildaufbau ist einfach zu langsam...

ich hab schon überlegt ob ich das bild nich größer zerre (heißt das skaliere?), aber das schaut nicht so schön aus, deswegen verwerf ich die idee mal schnell wieder.

ich hab mir eine andere Lösung überlegt:

wenn ich auf dem bildschirm eine fläche darstellen möchte, dann berechne ich die pixel nicht mehr vom "auge" aus, sondern ich nimm jeden eckpunkt der fläche, und rechne aus, wo dieser punkt auf dem bildschirm liegen würde.

anhand dieser punkte müsste man da "relativ einfach" eine textur reinskalieren können. das geht dann glaub ich schneller!

Weis eig wer wie das z.B. OpenGL oder Direct3D macht?, also ich mein jez nur vom prinzip her

@klotzkopp: mal ein danke an die antworten, sonst wär mein experiment wohl nicht so schnell fertig geworden XD

Bearbeitet 26. Januar 2011 von _Black_Hawk_

[Klotzkopp]

ich hab mir eine andere Lösung überlegt:

wenn ich auf dem bildschirm eine fläche darstellen möchte, dann berechne ich die pixel nicht mehr vom "auge" aus, sondern ich nimm jeden eckpunkt der fläche, und rechne aus, wo dieser punkt auf dem bildschirm liegen würde.

anhand dieser punkte müsste man da "relativ einfach" eine textur reinskalieren können. das geht dann glaub ich schneller!

Beide Ansätze haben ihre Vor- und Nachteile. Dein Programm ist im Prinzip ein sehr einfacher Voxel-Raytracer. Raytracer sind sehr gut darin, Reflexionen und Schatten realistisch darzustellen. Allerdings ist die erforderliche Rechenleistung normalerweise sehr hoch.

Der von den Objekten ausgehende Ansatz ist der verbreitetere, wenn Szenen in Echtzeit gerendert werden sollen, und wird von Grafikbibliotheken wie OpenGL und Direct3D unterstützt. Hier steckt dann erheblich mehr Aufwand in der Berechnung, ob eine Fläche überhaupt sichtbar ist, in Verdeckungsberechnung, Beleuchtung und Texturen. Dinge wie Reflexion und Schatten, die bei einem Raytracer sozusagen als Nebenprodukt abfallen, müssen hier eigens berechnet werden.

So oder so setzt man bei solchen Programmen allerdings auf Hardwarebeschleunigung. Man lässt das speziell darauf zugeschnittene Grafikprozessoren machen, weil es sonst einfach nicht schnell genug geht.

Als Einstieg vielleicht einfach mal dies:

Bildsynthese ? Wikipedia

[_Black_Hawk_]

danke für den link , ich wünschte ich würde alle seiten, die man auf wikipedia liest sofort verstehen

ich merk schon, dass es eig schwachsinn ist, 3D ansichten oder spiele ohne openGL oder direct3D zu machen, aber das is irgendwie ziemlich intressant.