OpenGL Kollisionserkennung



  • Hallo an alle,
    ich habe wieder ein OpenGL Problem.
    Ich habe schon im Internet gesucht aber nichts passendes gefunden.

    Mein Problem: Ich möchte in OpenGL und C++ testen, ob sich zwei Objekte berühren, habe dies aber nicht hinbekommen

    ich nutze Microsoft Visual Studio und mein Betriebssystem ist Windows 10

    Mein Code:

    float Object1x = 0.0; //X-Position des ersten Objekts
    float Object2x = 1.0; //X-Position des zweiten Objekts
    
    int collision()
    {
         if(Object1x == Object2x)
         {
              //Kollision
         }
    }
    
    //DrawGLscene, usw...
    
    if (keys[VK_RIGHT]) // Wird Rechter Pfeil gedrückt?
    {
    	keys[VK_RIGHT] = FALSE;
    	Object1x += 0.05f;
    }
    if (keys[VK_LEFT]) // Wird Linker pfeil gedrückt?
    {
    	keys[VK_LEFT] = FALSE;
    	Object1x -= 0.05f;
    }
    			
    

    Dies ist erstmal nur für die x-achse, die y-Achse mache ich später

    Vielen Dank im Voraus,
    Krapfen



  • Entsprechend meiner Links aus deinem anderen Thema, s. z.B. https://learnopengl.com/In-Practice/2D-Game/Collisions/Collision-detection.



  • Das funkt bei mir aber leider nicht, Fehlermeldungen:

    ...Pfad\main.cpp(44): error C2065: "GameObject": nichtdeklarierter Bezeichner
    ...Pfad\main.cpp(44): error C2065: "one": nichtdeklarierter Bezeichner
    ...Pfad\main.cpp(44): error C2065: "two": nichtdeklarierter Bezeichner
    ...Pfad\main.cpp(45): error C2448: "CheckCollision": Funktionsstil-Initialisierung scheint eine Funktionsdefinition zu sein
    


  • @Krapfen Jetzt wär dann Zeit C++ zu lernen tät ich sagen.



  • @hustbaer ich bin dabei C++ zu lernen

    Ich habe das Problem gerade erkannt, ich denke ich muss als "one" und "two" die zwei Formen einsetzen. Nur weiß ich nicht wie ich diese benenne, bzw. classes oder structs für diese festlege. Kann mir wer weiterhelfen?



  • Nachdem du den Code vermutlich nicht 1:1 übernommen hast... nein, dir kann vermutlich keiner helfen so lange du deinen Code nicht herzeigst.



  • Folgender Code:

    //...
    
    float fObject1x = 0;
    float fObject1y = 0;
    
    float fObject2x = 0.0;
    float fObject2y = 0.0;
    
    GLboolean CheckCollision(GameObject &one, GameObject &two) // AABB - AABB collision
    {
    	// Collision x-axis?
    	bool collisionX = one.Position.x + one.Size.x >= two.Position.x &&
    		two.Position.x + two.Size.x >= one.Position.x;
    	// Collision y-axis?
    	bool collisionY = one.Position.y + one.Size.y >= two.Position.y &&
    		two.Position.y + two.Size.y >= one.Position.y;
    	// Collision only if on both axes
    	return collisionX && collisionY;
    }
    
    int DrawGLScene(GLvoid)									// Funktion mit der alle Sachen gezeichnet werden		
    {
            glTranslatef(fObject1x, fObject1y, -4.0f);
    	glBegin(GL_QUADS);
    	glColor3f(0.0f, 1.0f, 0.0f);
    	glVertex3f(0.0f, 0.0f, 0.0f);
    	glColor3f(1.0f, 0.0f, 0.0f);
    	glVertex3f(0.2f, 0.0f, 0.0f);
    	glColor3f(0.0f, 0.0f, 1.0f);
    	glVertex3f(0.2f, 0.2f, 0.0f);
    	glColor3f(1.0f, 1.0f, 0.0f);
    	glVertex3f(0.0f, 0.2f, 0.0f);
    	glEnd();
    
            glTranslatef(fObject2x, fObject2y, -4.1f);
    	glBegin(GL_QUADS);
    	glColor3f(1.0f, 0.0f, 0.0f);
    	glVertex3f(0.02f, 0.02f, 0.0f);
    	glVertex3f(0.02f, -0.02f, 0.0f);
    	glVertex3f(-0.02f, -0.02f, 0.0f);
    	glVertex3f(-0.02f, 0.02f, 0.0f);
    	glEnd();
    }
    
    //Funk tion usw.
    if (keys[VK_RIGHT]) // Wird Rechter Pfeil gedrückt?
    			{
    				keys[VK_RIGHT] = FALSE;
    				fObject1x += 0.05f;
    
    				if (fObject1x > 1.1f)
    				{
    					fObject1x = 1.1;
    				}
    			}
    			if (keys[VK_LEFT]) // Wird Linker pfeil gedrückt?
    			{
    				keys[VK_LEFT] = FALSE;
    				fObject1x -= 0.05f;
    
    				if (fObject1x < -1.3f)
    				{
    					fObject1x = -1.3;
    				}
    			}
    // Funktion usw.
    
    //...
    
    

    Das ist erstmal nur für die x-Achsen Bewegung, ich mache, wenn ich das Problem gelöst habe noch die y-Achse als Bewegung hinzu



  • //...

    Tja, wenn da kein GameObject steckt fehlt es wohl...



  • @Krapfen Glaubst du dass der Code so wie du ihn hier gepostet hast kompilieren kann? Also wenn ich den nehme und 1:1 in meine IDE reinkopiere, meinst du der sollte dann gehen? Nein? Nein. Und genau das ist auch der Grund warum das immer noch völlig nutzlos ist.
    Ich meiner ernsthaft, du hast keine Ahnung von Programmieren. Sonst müsstest du wissen dass wir damit nichts anfangen können.



  • Okay Okay fahr mal bitte einen Gang herunter!

    Ich poste euch hier einmal den ganzen Code:

    #include <Windows.h>
    
    #pragma comment(lib, "opengl32")
    #pragma comment(lib, "glu32")
    #include <gl/gl.h>
    #include <gl/glu.h>
    
    HGLRC hRC = NULL;         // Der OpenGL Darstellungs Kontext (RC)
    HDC hDC = NULL;           // GDI Geräte Kontext (DC)
    HWND hWnd = NULL;         // Windows Handle
    HINSTANCE hInstance;	// Die Instanz der Anwendung
    
    bool keys[256]; // Vektor (Array) der den Status 
    				// einzelner Tasten enthält    
    				// (gedrückt/nicht gedrückt)
    
    bool active = TRUE;  // Wenn active FALSE ist, wurde das 
    				   // Fenster vom Benutzer minimiert.
    
    bool fullscreen = TRUE; // Läuft das Programm im Vollbildmodus 
    					  // oder nicht?
    
    LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
    // WndProc wird deklariert
    
    float fObject1x = -0.04;
    float fObject1y = -0.04;
    
    float fObject2x = 0.0;
    float fObject2y = 0.0;
    
    GLboolean CheckCollision(GameObject &one, GameObject &two) // AABB - AABB collision
    {
    	// Collision x-axis?
    	bool collisionX = one.Position.x + one.Size.x >= two.Position.x &&
    		two.Position.x + two.Size.x >= one.Position.x;
    	// Collision y-axis?
    	bool collisionY = one.Position.y + one.Size.y >= two.Position.y &&
    		two.Position.y + two.Size.y >= one.Position.y;
    	// Collision only if on both axes
    	return collisionX && collisionY;
    }
    
    GLvoid ReSizeGLScene(GLsizei width, GLsizei height)
    // Initialisierung des OpenGL-Fensters
    {
    	if (height == 0)
    	{
    		height = 1;
    	}
    
    	// height darf nicht 0 sein, damit es im späteren 
    	// Programmablauf nicht zu einer Division durch 0 kommt.
    
    	glViewport(0, 0, width, height);
    	// Hier wird der Mittelpunkt auf den die Perspektive zuläuft 
    	// zurückgesetzt.
    
    	glMatrixMode(GL_PROJECTION);
    	// Hier wird die Projektionsmatrix festgelegt
    
    	glLoadIdentity();
    	// und angepasst
    
    	gluPerspective(45.0f, (GLfloat)width / (GLfloat)height, 0.1f, 100.0f);
    	// Hier wird die das Verhältnis der Höhe zur Breite übergeben
    	// und der Verzerrungswinkel von 45 Grad übergeben
    
    	glMatrixMode(GL_MODELVIEW);
    	// Hier wird die sogenannte modelview-Matrix festgelegt
    
    	glLoadIdentity();
    	// und angepasst.
    }
    
    
    int InitGL(GLvoid)
    {
    	glShadeModel(GL_SMOOTH);
    	// Das Smooth Shading wird aktiviert, das 
    	// sehr schöne Farbübergänge auf Körpern ermöglicht.
    	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    	// In diesem Falle ein schwarzer Hintergrund
    	glClearDepth(1.0f);
    	// depht buffer zurückgesetzt
    
    	glEnable(GL_DEPTH_TEST);
    	// Aktivierung des depht Tests (dazu später mehr.)
    
    	glDepthFunc(GL_LEQUAL);
    	// Der Typ des Depht Tests wird festgelegt
    	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
    	// Perspektive wird festgelegt
    	return TRUE; // Initialisierung scheint geklappt zu haben!
    }
    
    int DrawGLScene(GLvoid)									// Funktion mit der alle Sachen gezeichnet werden		
    {
    	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	// screen und depth buffer zurücksetzen	
    	glLoadIdentity();									// Sicht zurücksetzen
    
    	glTranslatef(fObject1x, fObject1y, -4.0f);
    	glBegin(GL_QUADS);
    	glColor3f(0.0f, 1.0f, 0.0f);
    	glVertex3f(0.0f, 0.0f, 0.0f);
    	glColor3f(1.0f, 0.0f, 0.0f);
    	glVertex3f(0.2f, 0.0f, 0.0f);
    	glColor3f(0.0f, 0.0f, 1.0f);
    	glVertex3f(0.2f, 0.2f, 0.0f);
    	glColor3f(1.0f, 1.0f, 0.0f);
    	glVertex3f(0.0f, 0.2f, 0.0f);
    	glEnd();
    
            glLoadIdentity();
    
    	glTranslatef(fObject2x, fObject2y, -4.1f);
    	glBegin(GL_QUADS);
    	glColor3f(1.0f, 0.0f, 0.0f);
    	glVertex3f(0.02f, 0.02f, 0.0f);
    	glVertex3f(0.02f, -0.02f, 0.0f);
    	glVertex3f(-0.02f, -0.02f, 0.0f);
    	glVertex3f(-0.02f, 0.02f, 0.0f);
    	glEnd();
    
            glLoadIdentity();
    	
    	return TRUE;// alles in Ordnung
    }
    
    GLvoid KillGLWindow(GLvoid)
    {
    	if (fullscreen) // Kontrolle auf Vollbildmodus
    	{
    		ChangeDisplaySettings(NULL, 0); // Zurück zum Desktop
    		ShowCursor(TRUE); // Der abgeschaltete Mauszeiger 
    						  // wird wieder angezeigt (Nicht 
    						  // vergessen ;)
    	}
    
    	if (hRC) // Rendering Context (RC) vorhanden?
    	{
    		if (!wglMakeCurrent(NULL, NULL)) // Kann der DC und RC überhaupt 
    										// gelöscht werden?
    		{
    			MessageBox(NULL, "Entfernen des DC und RC fehlgeschlagen.", "Fehler",
    				MB_OK | MB_ICONINFORMATION);
    		}
    
    		if (!wglDeleteContext(hRC)) // Kann der RC gelöscht werden?
    		{
    			MessageBox(NULL, "Entfernen des RC fehlgeschlagen.", "Fehler...",
    				MB_OK | MB_ICONINFORMATION);
    		}
    		hRC = NULL; // Der RC wird NULL gesetzt, also entfernt
    	}
    
    	if (hDC && !ReleaseDC(hWnd, hDC))
    		// Kann der Device Context (DC) freigegeben werden?
    	{
    		MessageBox(NULL, "Freigabe des Device Context fehlgeschlagen.", "Fehler", MB_OK | MB_ICONINFORMATION);
    
    		hDC = NULL; // Der DC wird entfernt
    	}
    
    	if (hWnd && !DestroyWindow(hWnd))
    		// Kann das Programmfenster geschlossen werden?
    	{
    		MessageBox(NULL, "Konnte hWnd nicht löschen.", "SHUTDOWN ERROR",
    			MB_OK | MB_ICONINFORMATION);
    
    		hWnd = NULL; // Setze den hWnd auf NULL
    	}
    
    	if (!UnregisterClass("OpenGL", hInstance))
    		// Kann die Registrierung rückgängig gemacht werden?
    
    	{
    		MessageBox(NULL, "Konnte Klasse nicht entfernen.", "SHUTDOWN ERROR",
    			MB_OK | MB_ICONINFORMATION);
    
    		hInstance = NULL; // Setze hInstance auf NULL
    	}
    }
    
    BOOL CreateGLWindow(const char* title, int width, int height, int bits, bool fullscreenflag)
    {
    	GLuint PixelFormat; // Speichert das Pixelformat
    	WNDCLASS wc; // wc wird eine Instanz der Fensterklasse
    	DWORD dwExStyle; // weitere Informationen
    	DWORD dwStyle; // Fensterinformationen
    	RECT WindowRect;
    	// Speicher für aktuelle Auflösung
    
    	WindowRect.left = (long)0;
    	// Die linke Seite des Rechtecks wirtd auf 0 gesetzt
    
    	WindowRect.right = (long)width;
    	// Hier wird die gewünschte Breite des Fensters gespeichert
    
    	WindowRect.top = (long)0;
    	// Die obere Seite wird auch auf 0 gesetzt
    
    	WindowRect.bottom = (long)height;
    	// Und hier wird die Höhe abgelegt
    
    	fullscreen = fullscreenflag;
    	// Hier wird fullscreen 
    	// auf den Wert von fullscreenflag 
    	// gesetzt, welches ja übergeben wurde
    	hInstance = GetModuleHandle(NULL);
    	// Die Instanz des Programmes bekommt ein 
    	// Handle zugeordnet
    
    	wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
    	// Bei Veränderungen in der Höhe und/oder Breite, 
    	// soll ne gezeichnet werden
    
    	wc.lpfnWndProc = (WNDPROC)WndProc;
    	// WndProc behandelt die auftretenden Nachrichten
    
    	wc.cbClsExtra = 0; // Wird nicht benötigt
    	wc.cbWndExtra = 0; // und das auch nicht
    	wc.hInstance = hInstance; // Die Instanz wird festgelegt
    	wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
    	// Lädt das Standardsymbol
    	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
    	// Lädt einen Cursor
    	wc.hbrBackground = NULL;
    	// Es soll kein bestimmter Hintergrund angezeigt werden
    	wc.lpszMenuName = NULL; // Auch ein Menü wird nicht benötigt.
    	wc.lpszClassName = "OpenGL"; // OpenGL wird der Name der Klasse
    
    	if (!RegisterClass(&wc)) // Versuch die Klasse zu registrieren
    	{
    		MessageBox(NULL, "Konnte die Fensterklasse nicht registrieren.",
    			"ERROR", MB_OK | MB_ICONEXCLAMATION);
    		return FALSE; // FALSE zurückgeben und beenden
    	}
    
    	if (fullscreen) // Soll im Vollbildmodus gestartet werden
    	{
    		DEVMODE dmScreenSettings;
    		// Instanz von DEVMODE wird erzeugt
    
    		memset(&dmScreenSettings, 0, sizeof(dmScreenSettings));
    		// Diese wird geleert
    
    		dmScreenSettings.dmSize = sizeof(dmScreenSettings);
    		// dmsize soll genauso groß wie die dmScreenSettings sein
    
    		dmScreenSettings.dmPelsWidth = width;
    		// Die drei Werte (height, width und bits) 
    		// wurden der Prozedur übergeben und werden 
    		// nun in dmScreenSettings gespeichert
    
    		dmScreenSettings.dmPelsHeight = height;
    		dmScreenSettings.dmBitsPerPel = bits;
    		dmScreenSettings.dmFields = DM_BITSPERPEL |
    			DM_PELSWIDTH | DM_PELSHEIGHT;
    		// Hier werden die drei Werte in einem Ausdruck gespeichert
    
    		if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN)
    			!= DISP_CHANGE_SUCCESSFUL)
    		{
    
    
    			// CDS_FULLSCREEN blendet zusätzlich die Startleiste aus
    			if (MessageBox(NULL, "Der gewünschte Vollbildmodus wird nicht unterstützt, soll stattdessen im Fenstermodus ausgegeben werden ? ", "OpenGL"
    				, MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
    			{
    				fullscreen = FALSE;
    				// Der Benutzer möchte im Fenster weitermachen, 
    				// dazu wird fullscreen auf FALSE gesetzt
    			}
    
    			else
    			{
    				return FALSE;
    				// Falls der Benutzer das Programm aus gegebenen 
    				// Anlass beenden will, wird FALSE zurückgegeben.
    			}
    		}
    	}
    
    	if (fullscreen)
    		// Konnte in den Vollbildmodus geschaltet werden? 
    		// (Wenn nicht, wird ja im Fenster weitergemacht!)
    	{
    		dwExStyle = WS_EX_APPWINDOW; // Fenstereigenschaften
    		dwStyle = WS_POPUP; // -"-
    		ShowCursor(FALSE); // Der Mauszeiger wird nicht angezeigt
    	}
    
    	else
    	{
    		dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
    		// Das Fenster soll zusätzlich einen 3D Rahmen bekommen
    
    		dwStyle = WS_OVERLAPPEDWINDOW;
    		// Ein typisches Windowsfenster mit 
    		// Minimieren, Maximieren, etc
    	}
    
    	AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle);
    	// Fenster wird angepasst
    
    	if (!(hWnd = CreateWindowEx(dwExStyle,
    		// Die erweiterten Eigenschaften des    Fensters
    		"OpenGL", // Der Name der Klasse
    		title, // Der Titel des Fensters
    		WS_CLIPSIBLINGS | // Wird von OpenGL benötigt
    		WS_CLIPCHILDREN | // Wird auch von OpenGL benötigt
    		dwStyle, // auch Eigenschaften des Fensters
    		0, 0, // Die Position des zu erstellenden Fensters
    		WindowRect.right - WindowRect.left,
    		// Hier werden die ermittelten Werte für die Breite eingesetzt
    		WindowRect.bottom - WindowRect.top, // und hier für die Länge
    		NULL, // Es soll kein übergordnetes Fendster erstellt werden
    		NULL, // kein Menü
    		hInstance, // Die Instanz wird übergeben
    		NULL))) // Wird nicht benötigt
    
    	{
    		KillGLWindow(); // Grafikeinstellungen zurücksetzen
    		MessageBox(NULL, "Fenster konnte nicht erstellt werden.",
    			"ERROR", MB_OK | MB_ICONEXCLAMATION);
    		return FALSE;
    	}
    
    	static PIXELFORMATDESCRIPTOR pfd =
    		// pdf ist jetzt ein PIXELFORMATDESCRIPTOR
    	{
    	  sizeof(PIXELFORMATDESCRIPTOR),
    	  // Die größe muss natürlich stimmen
    	  1, // Versionsnummer
    	  PFD_DRAW_TO_WINDOW |
    	  // Das Format muss in Fenster sichtbar sein können
    	  PFD_SUPPORT_OPENGL |
    		// OpenGL muss unterstützt werden
    		PFD_DOUBLEBUFFER,
    		// Double Buffering muss unterstützt werden
    		PFD_TYPE_RGBA,
    		// Das RGBA (Rot,Grün,Blau,Alpha(Transparenz)) 
    		// muss unterstützt werden
    		bits,
    		// Die Farbtiefe, die schon 
    		// übergeben wurde, wird hier benötigt
    		0, 0, 0, 0, 0, 0, // wird nicht benötigt
    		0, // kein Alpha Buffer
    		0, // Shift Bit ignoriert
    		0, // kein Accumulation Buffer
    		0, 0, 0, 0, // nicht benötigt
    		16, // 16Bit Z-Buffer (Depth Buffer)
    		0, // kein Stencil Buffer
    		0, // kein Auxiliary Buffer
    		PFD_MAIN_PLANE,
    		// Die Hauptebene auf die später gezeichnet wird
    		0, // unwichtig
    		0, 0, 0 // keine Ebenenmasken benötigt
    	};
    
    	if (!(hDC = GetDC(hWnd))) // Versuch, den DC zu bekommen
    	{
    		KillGLWindow();
    		// Alles rückgängig machen
    		MessageBox(NULL, "Konnte keinen DC erstellen.",
    			"ERROR", MB_OK | MB_ICONEXCLAMATION);
    		return FALSE; // FALSE zurückgeben, beenden
    	}
    
    	if (!(PixelFormat = ChoosePixelFormat(hDC, &pfd)))
    		// Kann Windows ein passendes finden? 
    	{
    		// Falls keins gefunden werden kann:
    		KillGLWindow(); // Alles zurücksetzen
    		MessageBox(NULL, "Konnte kein passendes Pixelformat finden."
    			, "ERROR", MB_OK | MB_ICONEXCLAMATION);
    		return FALSE; // FALSE zurück und Ende.
    	}
    
    	if (!SetPixelFormat(hDC, PixelFormat, &pfd))
    		// Kann das Pixelformat gesetzt werden?
    	{
    		KillGLWindow(); // Leider nicht, Fehlerpopup und raus
    		MessageBox(NULL, "Konnte Pixelformat nicht setzen.",
    			"ERROR", MB_OK | MB_ICONEXCLAMATION);
    		return FALSE; // FALSE zurück und raus
    	}
    
    	if (!(hRC = wglCreateContext(hDC))) // Versuch den RC zu bekommen
    	{
    		KillGLWindow(); // Alles rückgängig machen
    		MessageBox(NULL, "Konnte keinen Rendering Context bekommen.",
    			"Fehler", MB_OK | MB_ICONEXCLAMATION);
    		return FALSE;
    	}
    
    	if (!wglMakeCurrent(hDC, hRC)) // Versuch den RC zu aktivieren
    	{
    		KillGLWindow(); // hat nicht geklappt, also alles zurück
    		MessageBox(NULL, "Konnte den Rendering Context nmicht aktivieren.",
    			"Fehler", MB_OK | MB_ICONEXCLAMATION);
    		return FALSE;
    	}
    
    	ShowWindow(hWnd, SW_SHOW); // Fenster anzeigen
    	SetForegroundWindow(hWnd); // Priorität des Programms wird erhöht
    	SetFocus(hWnd); // Tastatureingaben werden 
    					// jetzt an das Programm geleitet
    
    	ReSizeGLScene(width, height); // Die Perspektive wird aktiviert
    
    	if (!InitGL()) // Initialisiere das OpenGL Fenster
    	{
    		KillGLWindow(); // Falls das nicht geklappt 
    						// haben sollte alles rückgängig machen
    
    		MessageBox(NULL, "Initialisierung fehlgeschlagen.",
    			"Fehler", MB_OK | MB_ICONEXCLAMATION);
    		return FALSE; // FALSE wird zurückgegeben
    	}
    
    	return TRUE; // Alles hat geklappt!!!
    
    }
    
    LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg,
    	WPARAM wParam, LPARAM lParam)
    {
    	switch (uMsg) // Sind Nachrichten in der Nachrichtenschleife?
    	{
    	case WM_ACTIVATE: // Ist das Programm aktiv?
    	{
    		if (!HIWORD(wParam)) // Ist das Programm nicht minimiert?
    		{
    			active = TRUE; // active wird TRUE
    		}
    
    		else
    		{
    			active = FALSE; // Programm ist minimiert
    		}
    
    		return 0; // Rückgabe: 0
    	}
    	case WM_SYSCOMMAND: // Ist ein Systemkommando 
    						// (wie z.B. "Bildschirmschoner 
    						// soll gestartet werden") vorhanden?
    	{
    		switch (wParam) // wParam würde diesen Befehl enthalten
    		{
    		case SC_SCREENSAVE:
    			// Versucht Windows den Bildschirmschoner zu starten
    
    		case SC_MONITORPOWER:
    			// Soll der Monitor in den Stromsparmodus gehen?
    
    			return 0;
    			// Beide Fälle werden durch die Rückgabe von 0 verhindert
    		}
    		break; // Das wars.
    	}
    	case WM_CLOSE: // Ist eine WM_CLOSE Nachricht vorhanden?
    	{
    		PostQuitMessage(0);
    		// Die Nachricht zum Beenden wird "gepostet"
    
    		return 0; // und zurück.
    	}
    	case WM_KEYDOWN: // Drückt der Benutzer eine Taste???
    	{
    		keys[wParam] = TRUE;
    		// Der Wert im Array keys[] der dem Code 
    		// der Taste entspricht, wird true gesetzt
    
    		return 0; // und zurück...
    	}
    	case WM_KEYUP: // Wurde eine Taste losgelassen?
    	{
    		keys[wParam] = FALSE;
    		// Wen ja, dann soll dieser Wert im Array keys[] 
    		// auf FALSE gesetzt werden
    		return 0; // und zurück.
    	}
    	case WM_SIZE: // Die Fenstergröße wurde geändert
    	{
    		ReSizeGLScene(LOWORD(lParam), HIWORD(lParam));
    		// LoWord ist die Breite, HiWord die Höhe, 
    		// ReSizeGLScene() verändert dann die 
    		// Größe des OpenGL-Fensters
    		return 0; // und zurück
    	}
    	}
    	return DefWindowProc(hWnd, uMsg, wParam, lParam);
    }
    
    int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
    	LPSTR lpCmdLine, int nCmdShow)
    {
    	MSG msg;
    	BOOL done = FALSE;
    	if (MessageBox(NULL, "Soll im Vollbildmodus gestartet werden?",
    		"Vollbilmodus gewünscht?", MB_YESNO | MB_ICONQUESTION) == IDNO)
    	{
    		fullscreen = FALSE; // Falls nein gedrückt wurde, 
    						  // wird fullscreen false gesetzt
    	}
    	if (!CreateGLWindow("Block vs Apples", 640, 480, 16, fullscreen))
    	{
    		return 0; // Falls ein Fehler auftrat, beenden
    	}
    	while (!done) // Solange done nicht TRUE ist:
    	{
    		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
    			// Sind Nachrichten vorhanden
    		{
    
    			if (msg.message == WM_QUIT)
    				// Liegt eine Nachricht zum beenden vpr?
    			{
    				done = TRUE; // Wenn dem so ist, wird done 
    						   // true und das Programm beendet
    			}
    
    			else
    				// Wenn nicht werden die anderen Nachrichten ausgewertet
    
    			{
    				TranslateMessage(&msg); // Umformen der Nachricht
    				DispatchMessage(&msg);
    			}
    		}
    
    		else // Falls keine Nachrichten bereit liegen
    		{
    			if (active) // Programm aktiv?
    			{
    				if (keys[VK_ESCAPE]) // Wurde ESC gedrückt?
    				{
    					done = TRUE; // Wenn ESC gedrückt wurde, beenden
    				}
    
    				else // ESC wurde nicht gedrückt
    				{
    					DrawGLScene(); // Die Szene ausgeben
    					SwapBuffers(hDC); // Die Puffer werden getauscht
    				}
    			}
    			if (keys[VK_RIGHT]) // Wird Rechter Pfeil gedrückt?
    			{
    				keys[VK_RIGHT] = FALSE;
    				fObject1x += 0.05f;
    
    				if (fObject1x > 1.1f)
    				{
    					fObject1x = 1.1;
    				}
    			}
    			if (keys[VK_LEFT]) // Wird Linker pfeil gedrückt?
    			{
    				keys[VK_LEFT] = FALSE;
    				fObject1x -= 0.05f;
    
    				if (fObject1x < -1.3f)
    				{
    					fObject1x = -1.3;
    				}
    			}
    			
    		}
    	}
    }
    

    ich habe es getestet. Dieser Code funktioniert ohne die Funktion

    GLboolean CheckCollision(GameObject &one, GameObject &two) // AABB - AABB collision
    

    Leider funktioniert er nicht mit der Funktion, sondern gibt die obigen Fehlermeldungen aus

    ...Pfad\main.cpp(44): error C2065: "GameObject": nichtdeklarierter Bezeichner
    ...Pfad\main.cpp(44): error C2065: "one": nichtdeklarierter Bezeichner
    ...Pfad\main.cpp(44): error C2065: "two": nichtdeklarierter Bezeichner
    ...Pfad\main.cpp(45): error C2448: "CheckCollision": Funktionsstil-Initialisierung scheint eine Funktionsdefinition zu sein
    

    Ich wüsste jetzt gerne, was ich falsch gemacht habe. Falls Infos fehlen, kann man mich gerne anschreiben/mir antworten

    Danke im voraus



  • @manni66 sagte in OpenGL Kollisionserkennung:

    Tja, wenn da kein GameObject steckt fehlt es wohl...

    https://learnopengl.com/In-Practice/2D-Game/Levels

    @hustbaer sagte in OpenGL Kollisionserkennung:

    @Krapfen Jetzt wär dann Zeit C++ zu lernen tät ich sagen.

    Das. Vergiss fürs erste OpenGL und lerne die Gundlagen.



  • Welche Grundlagen? 😞

    Sry dass ich so dumm fragen muss, ich weiß nicht womit ich weitermachen soll



  • @Krapfen sagte in OpenGL Kollisionserkennung:

    Welche Grundlagen?

    Grundlagen der Sprache C++. Wenn dir nicht selbst auffällt, daß es in deinem Code keinen Typ namens GameObject gibt ...

    @Krapfen sagte in OpenGL Kollisionserkennung:

    ich weiß nicht womit ich weitermachen soll

    Irgendein Lehrbuch zu C++ besorgen und durcharbeiten. Evtl. zu Ostern wünschen. Der Breymann wird oft empfohlen.



  • Dankeschön



  • Könntet ihr mir trotzdem bitte bitte sagen, wie der Code richtig heißt? 👁



  • @Krapfen sagte in OpenGL Kollisionserkennung:

    Könntet ihr mir trotzdem bitte bitte sagen, wie der Code richtig heißt? 👁

    Wilhelm.

    Irgendwo muss die Klasse definiert sein. Die Definition muss der Compiler sehen. Dazu wird häufig eine Headerdatei verwendet. Grundlagen!



  • @Krapfen sagte in OpenGL Kollisionserkennung:

    Könntet ihr mir trotzdem bitte bitte sagen, wie der Code richtig heißt? 👁

    Du bist komplett auf dem Holzweg. Bevor du dich mit OpenGL auseinandersetzt, solltest du zunächst mal die Grundlagen von C++ lernen. Sonst produzierst du garantiert Schrott-Quellcode, der dir nicht im geringsten weiterhilft. Also fang lieber mit etwas leichterem an.



  • @Krapfen sagte in OpenGL Kollisionserkennung:

    Könntet ihr mir trotzdem bitte bitte sagen, wie der Code richtig heißt? 👁

    Den Code für GameObject findest Du wenn Du den Abschnitt liest den ich weiter oben verlinkt habe.



  • Auch wenn der Code dann kompiliert, so wird die Funktion bisher nicht benutzt.
    Du müßtest also dein restliches Programm so umschreiben, daß es dann auch GameObject verwendet (anstatt die globalen Object1x, Object1y, Object2x, Object2y).


Log in to reply