2D Problem OpenGL VC++6

[ShadowEater]

Hi Leute,

ich hab vor kurzem mit OpenGl angefangen und hab einige 3D Sachen gemacht, die haben auch gut geklappt, jetzt hab ich aber ein 2D Prob, das mich langsam in den Wahnsinn gleiten lässt .

1.)
Ich bin grad dabei den 2D Level-Editor für nen Lode Runner Clone zu coden, die erste Frage ist, wie kann ich 2D Sachen richtig positionieren, ich spiel hier mit Translatef und dem ZoomFaktor rum aber die Positionen stimmen einfach net. Gibt es dazu irgend wo ein einiermassen verständliches tut oder sogar n' bissl Source Code der das Prob coverd (nicht son riesen Source von nem fertigen Spiel) das wär echt abgefahren?

2.)
Das 2. Prob hängt direkt mit dem Editor zusammen, jedes Bild is ein Objekt wenn ichs zeichnen will wird aber nur ein Objkt gezeichnet un beim zeichnen des nächsten Objektes gelöscht ?

Hier mein Code:

class CLrunner
{

	public:

				CLrunner(): itsPosX(0.0),
					   itsPosY(0.0), 
					   itsPosZ(0.0) 
					   {}
				CLrunner(float posX, float posY, float posZ, GLuint * rTexture)
				{	
					static  int countInstanzen;			
					itsPosX = posX;
					itsPosY = posY;
					itsPosZ = posZ;
				    texture = rTexture;
					countInstanzen++;
					myInstanz = countInstanzen;

				} 

				~CLrunner(){}

				void	setItsPosX(float posX)	{ itsPosX = posX; }
				void	setItsPosY(float posY)  { itsPosY = posY; }
				void	setItsPosZ(float posZ)  { itsPosZ = posZ; }

				void	setTexture(GLuint * rTexture) {texture = rTexture; }

				float	getItsPosX() const	{ return itsPosX; }
				float	getItsPosY() const	{ return itsPosY; }		
				float	getItsPosZ() const	{ return itsPosZ; }	

				GLuint	* getTexture() const	{return texture; }
				void    Paint(int SelectedItem);
				int     getInstanz()        { return myInstanz; }

			int		DrawGLScene(GLvoid);

			void	moveRight();
			void	moveLeft();
			void    moveUp();
			void    moveDown();

	private:

						GLuint	*texture;
			float	itsPosX;
			float	itsPosY;
			float	itsPosZ;
			int     myInstanz;
			static const float  itsMoveX;
			static const float  itsMoveY;
};

float const CLrunner::itsMoveX = 0.255;
float const CLrunner::itsMoveY = 0.255;

void    CLrunner::Paint(int SelectedItem)
{
	glBindTexture(GL_TEXTURE_2D, texture[SelectedItem]);  
	glBegin(GL_QUADS);
	glTexCoord2f(1.0, 0.0); glVertex2f(-1.0/3, -0.5/3);
	glTexCoord2f(1.0, 1.0); glVertex2f(-1.0/3, 0.5/3);
	glTexCoord2f(0.0, 1.0); glVertex2f(0.0/3, 0.5/3);
	glTexCoord2f(0.0, 0.0); glVertex2f(0.0/3, -0.5/3);
	glEnd();

}

#include <windows.h>
#include <gl\gl.h>
#include <gl\glu.h>
#include <gl\glaux.h>

#include <stdio.h>    // Dateien sollen verwendet werden
#include <stdlib.h>
#include "CLode.h"

HGLRC hRC = NULL;
HDC hDC = NULL;
HWND hWnd = NULL;
HINSTANCE hInstance;

bool keys[256];
bool active = TRUE;
bool fullscreen = TRUE;
unsigned int  SelectedItem =0;
GLuint texture[9]; // Texturspeicher
GLuint textureEditor[9]; //Texturspeicher für Levelelemente
CLrunner Cursor = CLrunner(-3,0,-5.75, textureEditor);
CLrunner Items[450];
int o = 0;
int InitGL(GLvoid);
GLvoid ReSizeGLScene(GLsizei width, GLsizei height);
//int DrawGLScene(GLvoid);
BOOL CreateGLWindow(char*, int, int, int, bool);
GLvoid KillGLWindow(GLvoid);
int LoadGLTextures();
void initialGL();
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
	MSG msg;
	BOOL done = false;

	if (true)//MessageBox(NULL, "Would You Like To Run In Fullscreen Mode?", "Start FullScreen?", MB_YESNO | MB_ICONQUESTION) == IDNO)
	{
	  fullscreen=false;
	}

	if (!CreateGLWindow("NeHe's OpenGL Framework", 800, 600, 16, fullscreen))
	{
	  return 0;
	}

	while(!done)
	{
	  if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
	  {
		if (msg.message==WM_QUIT)
		{
		  done=true;
		}
		else
		{
		  TranslateMessage(&msg);
		  DispatchMessage(&msg);
		}
	  }
	  else
	  {
		if (active)
		{
		  if (keys[VK_ESCAPE])
		  {
			done=true;
		  }

		  else
		  {

			SwapBuffers(hDC);
		  }
		}

		 if (keys[VK_F1])
			{
			  keys[VK_F1]=FALSE;
			  KillGLWindow();
			  fullscreen=!fullscreen;
			  if (!CreateGLWindow("NeHe's OpenGL Framework",800,600,16,fullscreen))
			  {
				return 0;
			  }
			}
		}	  
	  }
	KillGLWindow();
	return (msg.wParam);
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
  switch (uMsg)
  {
	  case WM_ACTIVATE:
		{
		  if (!HIWORD(wParam))
		  {
			active=true;
		  }
		  else
		  {
			active=false;
		  }
		  return 0;
		}

	  case WM_SYSCOMMAND:
		{
		  switch (wParam)
		  {
		  case SC_SCREENSAVE:
		  case SC_MONITORPOWER:
			return 0;
		  }
		  break;
		}

	  case WM_CLOSE:
		{
		  PostQuitMessage(0);
		  return 0;
		}

	 case WM_KEYDOWN:
		{
		    if(wParam==VK_RIGHT)
			{

				initialGL();
			//	Cursor.moveRight();

			}

			else if(wParam==VK_LEFT)
			{

		//		Cursor.moveLeft();

			}

			else if(wParam==VK_UP)
			{

		//		Cursor.moveUp();

			}
			else if(wParam==VK_DOWN)
			{

		//		Cursor.moveDown();
			}
			else if(wParam==VK_SPACE)
			{
				o++;
				initialGL();

				/*SelectedItem=0;
				Cursor.Paint(0);*/
			}
			else if(wParam==0x031)
			{
				SelectedItem=1;
				Cursor.Paint(1);
			}
			else if(wParam==0x032) 
			{
				SelectedItem=2;
				Cursor.Paint(2);
			}
			else if(wParam==0x033)
			{
				SelectedItem=3;
				Cursor.Paint(3);
			}
			else if(wParam==0x034)
			{
				SelectedItem=4;
				Cursor.Paint(4);
			}
			else if(wParam==0x035)
			{
				SelectedItem=5;
				Cursor.Paint(5);
			}
			else if(wParam==0x036)
			{
				SelectedItem=6;
				Cursor.Paint(6);
			}
			else if(wParam==0x037)
			{
				SelectedItem=7;
				Cursor.Paint(7);
			}
			else if(wParam==0x038)
			{
				SelectedItem=8;
				Cursor.Paint(8);
			}
		  keys[wParam] = true;
		  return 0;
		}

	 case WM_KEYUP:
		{
		  keys[wParam] = false;
		  return 0;
		}

	 case WM_SIZE:
		{
		  ReSizeGLScene(LOWORD(lParam), HIWORD(lParam));
		  return 0;
		}

	}

	return DefWindowProc(hWnd,uMsg,wParam,lParam);
}

BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
	GLuint    PixelFormat;
	WNDCLASS  wc;
	DWORD	  dwExStyle;
	DWORD	  dwStyle;
	RECT	  WindowRect;

	WindowRect.left=  (long)0;
	WindowRect.right= (long)width;
	WindowRect.top=   (long)0;
	WindowRect.bottom=(long)height;
	fullscreen =      fullscreenflag;

	hInstance= GetModuleHandle(NULL);

	wc.style= CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
	wc.lpfnWndProc= (WNDPROC) WndProc;
	wc.cbClsExtra= 0;
	wc.cbWndExtra= 0;
	wc.hInstance= hInstance;
	wc.hIcon= LoadIcon(NULL, IDI_WINLOGO);
	wc.hCursor= LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground= NULL;
	wc.lpszMenuName= NULL;
	wc.lpszClassName= "OpenGL";

	if (!RegisterClass(&wc))
	{
	  MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
	  return false;
	}

	if (fullscreen)
	{
		DEVMODE dmScreenSettings;
		memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
		dmScreenSettings.dmSize= sizeof(dmScreenSettings);
		dmScreenSettings.dmPelsWidth= width;
		dmScreenSettings.dmPelsHeight= height;
		dmScreenSettings.dmBitsPerPel= bits;
		dmScreenSettings.dmFields= DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT; 

		if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
		  {
			if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?","NeHe GL",MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
			{
			  fullscreen=false;
			}
			else
			{
			  MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
			  return false;
			}
		  }
		}

		if (fullscreen)
		{
		  dwExStyle = WS_EX_APPWINDOW;
		  dwStyle = WS_POPUP;
		  ShowCursor(FALSE);
		}
		else
		{
		  dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
		  dwStyle = WS_OVERLAPPEDWINDOW;
		}

		AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle);

		if (!(hWnd=CreateWindowEx(dwExStyle,
									"OpenGL",
									title,
									WS_CLIPSIBLINGS |
									WS_CLIPCHILDREN |
									dwStyle,
									0, 0,
									WindowRect.right - WindowRect.left,
									WindowRect.bottom - WindowRect.top,
									NULL,
									NULL,
									hInstance,
									NULL)))
		{
		  KillGLWindow();
		  MessageBox(NULL, "Window Creation Error.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
		  return false;
		}

		static PIXELFORMATDESCRIPTOR pfd =
		{
		  sizeof(PIXELFORMATDESCRIPTOR),
		  1,
		  PFD_DRAW_TO_WINDOW |
		  PFD_SUPPORT_OPENGL |
		  PFD_DOUBLEBUFFER,
		  PFD_TYPE_RGBA,
		  bits,
		  0, 0, 0, 0, 0, 0,
		  0,
		  0,
		  0,
		  0, 0, 0, 0,
		  16,
		  0,
		  0,
		  PFD_MAIN_PLANE,
		  0,
		  0, 0, 0
		};

		if (!(hDC = GetDC(hWnd)))
		{
		  KillGLWindow();
		  MessageBox(NULL,"Can't Create A GL Device Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		  return false;
		}

		if (!(PixelFormat = ChoosePixelFormat(hDC, &pfd)))
		{
		  KillGLWindow();
		  MessageBox(NULL,"Can't Find A Suitable PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		  return false;
		}

		if(!SetPixelFormat(hDC, PixelFormat, &pfd))
		{
		  KillGLWindow();
		  MessageBox(NULL,"Can't Set The PixelFormat.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		  return false;
		}

		if (!(hRC = wglCreateContext(hDC)))
		{
		  KillGLWindow();
		  MessageBox(NULL,"Can't Create A GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		  return false;
		}

		if(!wglMakeCurrent(hDC,hRC))
		{
		  KillGLWindow();
		  MessageBox(NULL,"Can't Activate The GL Rendering Context.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		  return false;
		}

		ShowWindow(hWnd, SW_SHOW);
		SetForegroundWindow(hWnd);
		SetFocus(hWnd);
		ReSizeGLScene(width, height);

		if (!InitGL())
		{
	    	KillGLWindow();
		    MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION);
		return false;
		}
		else
		{
		GLfloat xItem=-3.15,yItem=+2.2;
		for (int o = 0;o<450;o++)
		{
			if (o%20 ==0 && o>0) //Ende der Zeile erreicht?
			{
				xItem = -3.15;
				yItem -= 0.325;
			}
			Items[o] = CLrunner(xItem,yItem,-5.75,&textureEditor[3]);
			xItem += 0.325;
		}
		//	Cursor.initialGL();
		//	Cursor.lastMove(0);
	}

  return true;
}

GLvoid KillGLWindow(GLvoid)
{
	if (fullscreen)
	{
	  ChangeDisplaySettings(NULL,0);
	  ShowCursor(TRUE);
	}

	if (hRC)
	{

	  if (!wglMakeCurrent(NULL, NULL))
	  {
		MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
	  }

	  if (!wglDeleteContext(hRC))
	  {
		MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
	  }

	  hRC=NULL;
	}

	if (hDC && !ReleaseDC(hWnd, hDC))
	{
	  MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
	  hDC=NULL;
	} 

	if (hWnd && !DestroyWindow(hWnd))
	{
	  MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
	  hWnd=NULL;
	} 

    if (!UnregisterClass("OpenGL", hInstance))
	{
    	MessageBox(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
    	hInstance=NULL;
	}
} 

GLvoid ReSizeGLScene(GLsizei width, GLsizei height)
{ 
	if (height==0)
	{
	  height=1;
	} 

	glViewport(0,0, width, height); 

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f); 

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}

int InitGL(GLvoid)
{ 
	if (!LoadGLTextures())                            
	{
		return FALSE; // Texturen konnten nicht geladen werden...
	}

//	lastMoveRight=true;//+++++++++++???????????????+++++++++++++++????????????????????????????
	glEnable(GL_TEXTURE_2D); // Texture Mapping aktivieren

	glShadeModel(GL_FLAT); 

	glClearColor(0.0f, 0.0f, 0.0f, 0.0f); 

	glClearDepth(1.0f);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LEQUAL); 

    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
  return true;
} 

//------------------

AUX_RGBImageRec *LoadBMP(char *Filename) // Lädt ein BMP
{
  FILE *File=NULL; // Das File Handle  
  if (!Filename)   // Ist ein Dateiname übergeben worden?
  {   
	  return NULL; // offenbar nicht... Abbruch  
  }

  File=fopen(Filename,"r");   // Versuch die Datei zu öffnen
  if (File) // Existiert die Datei? 
  {
	  fclose(File); // Datei schließen 
	  return auxDIBImageLoad(Filename);     // BMP laden und Zeiger (Pointer) zurückgeben, 
    // der auf die Bilddaten verweist 
  }
  return NULL; // Laden hat nicht geklappt
}

int LoadGLTextures() // Bitmaps laden und konvertieren
{
  int Status=FALSE;   // Status ersteinmal auf FALSE setzen

  AUX_RGBImageRec *TextureImage[1];   // Speicherplatz für die Textur schaffen

  //Vorher sichergehen das dieser auch leer ist
	memset (TextureImage,0,sizeof(void *)*1); 	

//*** Hier werden die Texturen für die Editor-Elemente eingelesen
for (int i = 0;i<9;i++)
{

	char buf[1];
	itoa(i, buf, 10);

	char tempString[100];
	strcpy(tempString,"e");
	strcat(tempString,buf);

	strcat(tempString,".BMP");

	if (TextureImage[0]=LoadBMP(tempString))
	  // Bitmap laden
	  {
		Status=TRUE; // hat geklappt.

		glGenTextures(1, &textureEditor[i]); // Textur wird erstellt

		glBindTexture(GL_TEXTURE_2D, textureEditor[i]);
		//Es handelt sich um eine 2D Textur

		glTexImage2D(GL_TEXTURE_2D, 0, 3, TextureImage[0]->sizeX, 
					 TextureImage[0]->sizeY, 0, GL_RGB, 
					 GL_UNSIGNED_BYTE, TextureImage[0]->data);
		 glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
		// GL_LINEAR wird für GL_TEXTURE_MIN_FILTER genutzt

		glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
		// GL_LINEAR wird für GL_TEXTURE_MAG_FILTER genutzt
	  }

//	LR.setTexture(texture);

	 if (TextureImage[0]) // Existiert TextureImage[0]?
	  {
		if (TextureImage[0]->data) // enthält sie Bilddaten?
		{
		  free(TextureImage[0]->data); 
		  // wenn ja, dann diese Bilddaten löschen
		}
		free(TextureImage[0]); 
		// Und auch die Struktur an sich löschen.
	  }
	}

return Status;
}

void initialGL()
{

//	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	// Die vorherige Szene wird vom Bildschirm gelöscht,
	// damit die neuen nicht einfach über die alten 
	// Objekte gezeichnet werden 
	// Initialisiere die Levelobjekte

	glLoadIdentity();  // modelview-Matrix wird wieder einmal zurückgesetzt

    glTranslatef(Items[o].getItsPosX(),Items[o].getItsPosY(),-7);
		    Items[o].Paint(3);

//	Cursor.Paint(SelectedItem);
/*	for (int o = 0;o<450;o++)
	{
		if (o==0)
			glTranslatef(Items[o].getItsPosX(),Items[o].getItsPosY(),-5.75);
		else
			glTranslatef(Items[o].getItsPosX(),Items[o].getItsPosY(),0.0);

		    Items[o].Paint(3);

	}*/
//	glTranslatef(Cursor.getItsPosX(),Cursor.getItsPosY(),-5.75);

	//glTranslatef(setItem->getItsPosX(),setItem->getItsPosY(),-5.75);

	//glMatrixMode(GL_PROJECTION); 
	//glLoadIdentity();  // modelview-Matrix wird wieder einmal zurückgesetzt

}

Vielen Dank schonmal im voraus WinDDancer...

[Cpp_Junky]

void ResizeScene(int nWidth, int nHeight)
{
	if (nHeight == 0)						
	   nHeight = 1;									

	glViewport(0,0,nWidth,nHeight);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(0.0f,nWidth,nHeight,0.0f,-1.0f,1.0f);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();	
}

Dann kannste mit glVertex2d direkt auf Bildschirmkoordinaten mappen

[ShadowEater]

Danke Cpp_Junky,

sieht ziemlich einfach aus, hab aber lerder erst morgen Zeit zum ausprobieren !
Schick Dir Ergebnisbericht.

P.S.: Deine Site is echt gut !!!

ShadowEater