 |
JLI Spieleprogrammierung
|
| Vorheriges Thema anzeigen :: Nächstes Thema anzeigen |
| Autor |
Nachricht |
Legolas87
JLI'ler
Alter: 36
Anmeldedatum: 22.10.2003
Beiträge: 131
Medaillen: Keine
|
 Verfasst am: 27.06.2007, 15:33 Titel: OpenGL Klasse |
 |
|
ich hab versucht mir mal ne "ordentliche" Grundlage zu schaffen und mir eine OGL Klasse zu schreiben, die ich dann immer wieder verwenden kann. Wenn jemand Zeit hat, könnt ihr bitte mal drüberschauen und Verbesserungsvorschläge nennen, auch Sachen die zwar funktionieren, aber man nicht tun sollte (zB weiß ich nicht, ob ich das mit hInstance und hWnd sauber gelöst habe, vielleicht wäre ne Referenz zu übergeben sinnvoller). Und ich erhalte beim beenden 2 Fehlermeldungen: device context und hwnd können nicht freigegeben werden.
Gibts ein Tut oder iwas woraus man erkennen kann wo man Bibliotheken und Header einbindet, damit man die nicht mehrmals einbinden muss, in eine Header oder besser in eine *.cpp?
| CPP: | // ###########################################################################
// Datei: OpenGL.h
// ###########################################################################
// Autor:
// Erstellt: 04.05.2007
// Änderungen: 04.05.2007
// Bemerkung: abgeändert
// ###########################################################################
// Beschreibung:
//Bibliotheken
#pragma comment(lib,"OpenGL32.lib")
#pragma comment(lib,"GLu32.lib")
#pragma comment(lib,"GLaux.lib")
// Headerdateien
#include <windows.h>
#include <gl\glu.h>
#include <gl\gl.h>
#include <gl\glaux.h>
class OpenGL
{
public:
OpenGL();
~OpenGL();
GLvoid ReSizeGLScene(GLsizei width, GLsizei height);
int InitGL(HWND hWnd,HINSTANCE hInstance);
int DrawGLScene(GLvoid);
void Swap(void);
GLvoid KillGLWindow(GLvoid);
protected:
HGLRC m_hRC; // Der OpenGL Rendering Context
HDC m_hDC; // Geschützter GDI Device Context
HWND m_hWnd; // Verweist später auf den Windows Handle
HINSTANCE m_hInstance;// Die Instanz der Anwendung
}; |
| CPP: | // ###########################################################################
// Datei: OpenGL.cpp
// ###########################################################################
// Autor:
// Erstellt: 04.05.2007
// Änderungen: 04.05.2007
// Bemerkung: abgeändert
// ###########################################################################
// Beschreibung:
#include "opengl.h"
OpenGL::OpenGL(void)
{
m_hRC=0;
m_hDC=0;
m_hWnd=0;
m_hInstance=0;
}
OpenGL::~OpenGL()
{
}
GLvoid OpenGL::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 OpenGL::InitGL(HWND hWnd,HINSTANCE hInstance)
{
m_hWnd=hWnd;
m_hInstance=hInstance;
glClearColor(1.0f, 0.0f, 1.0f, 0.0f);
glClearDepth(1.0);
glShadeModel(GL_SMOOTH);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f,(GLfloat)800/(GLfloat)600,0.1f,150.0f);
glMatrixMode(GL_MODELVIEW);
GLuint PixelFormat;
// set the pixel format for the DC
PIXELFORMATDESCRIPTOR pfd;
ZeroMemory( &pfd, sizeof( pfd ) );
pfd.nSize = sizeof( pfd );
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL |
PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 24;
pfd.cDepthBits = 16;
pfd.iLayerType = PFD_MAIN_PLANE;
int format = ChoosePixelFormat( m_hDC, &pfd );
SetPixelFormat( m_hDC, format, &pfd );
if (!(m_hDC=GetDC(m_hWnd))) // Versuch, den DC zu bekommen
{
KillGLWindow();
MessageBox(NULL,L"Konnte keinen DC erstellen.",L"ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
if (!(PixelFormat=ChoosePixelFormat(m_hDC,&pfd)))
// Kann Windows ein passendes finden?
{
// Falls keins gefunden werden kann:
KillGLWindow(); // Alles zurücksetzen
MessageBox(NULL,L"Konnte kein passendes Pixelformat finden.",L"ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // FALSE zurück und Ende.
}
if(!SetPixelFormat(m_hDC,PixelFormat,&pfd))
// Kann das Pixelformat gesetzt werden?
{
KillGLWindow(); // Leider nicht, Fehlerpopup und raus
MessageBox(NULL,L"Konnte Pixelformat nicht setzen.",L"ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // FALSE zurück und raus
}
if (!(m_hRC=wglCreateContext(m_hDC))) // Versuch den RC zu bekommen
{
KillGLWindow(); // Alles rückgängig machen
MessageBox(NULL,L"Konnte keinen Rendering Context bekommen.",L"Fehler",MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
if(!wglMakeCurrent(m_hDC,m_hRC)) // Versuch den RC zu aktivieren
{
KillGLWindow(); // hat nicht geklappt, also alles zurück
MessageBox(NULL,L"Konnte den Rendering Context nmicht aktivieren.",L"Fehler",MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
return 1;
}
int OpenGL::DrawGLScene(GLvoid)
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
return TRUE; // Alles hat geklappt
}
GLvoid OpenGL::KillGLWindow(GLvoid)
{
if (m_hRC)
{
if (!wglMakeCurrent(NULL,NULL))
{
MessageBox(NULL,L"Entfernen des DC und RC fehlgeschlagen.",L"Fehler",MB_OK | MB_ICONINFORMATION);
}
if (!wglDeleteContext(m_hRC))
{
MessageBox(NULL,L"Entfernen des RC fehlgeschlagen.",L"Fehler...",MB_OK | MB_ICONINFORMATION);
}
m_hRC=NULL;
}
if (m_hDC && !ReleaseDC(m_hWnd,m_hDC))
{
MessageBox(NULL,L"Freigabe des Device Context fehlgeschlagen.",L"Fehler",MB_OK | MB_ICONINFORMATION);
m_hDC=NULL;
}
if (m_hWnd && !DestroyWindow(m_hWnd))
{
MessageBox(NULL,L"Konnte hWnd nicht löschen.",L"SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
m_hWnd=NULL;
}
if (!UnregisterClass(L"WindowClass",m_hInstance))
{
MessageBox(NULL,L"Konnte Klasse nicht entfernen.",L"SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
m_hInstance=NULL; // Setze hInstance auf NULL
}
}
void OpenGL::Swap(void)
{
SwapBuffers(m_hDC);
} |
| CPP: | // ###########################################################################
// Datei: main.cpp
// ###########################################################################
// Autor:
// Erstellt: 27.04.2007
// Änderungen: 29.04.2007
// Bemerkung: abgeändert
// ###########################################################################
// Beschreibung: Hiermit wird ein leeres Fenster zum immerwiederverwenden gebaut!
// Headerdatei
#include <windows.h>
#include "OpenGL.h"
// Anwendungsfenster erzeugen
HWND CreateMainWindow(HINSTANCE hInstance);
// Callback Funktion zur Nachrichtenbehandlung
LRESULT CALLBACK MessageHandler(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
// Das Fensterhandle
HWND hWnd = 0;
// Windows main-Funktion
int WINAPI WinMain(HINSTANCE hInstance, // Handle der Programminstanz
HINSTANCE hPrevInstance, // Handle der letzten Instanz
LPSTR lpCmdLine, // Kommandozeile
int nCmdShow) // Art wie das Fenster angezeigt werden soll
{
// Fenster erzeugen und Handle speichern
hWnd = CreateMainWindow(hInstance);
// Wenn der Rückgabewert 0 ist, ist ein Fehler aufgetreten
if(0 == hWnd)
{
MessageBox(0,L"Fenster konnte nicht erzeugt werden",L"Fehler",MB_OK);
return 0;
}
OpenGL gl;
gl.InitGL(hWnd,hInstance);
MSG msg = { 0 };
/*while(GetMessage(&msg,NULL,0,0))
{
// Nachricht an die Callbackfunktion senden
TranslateMessage(&msg);
DispatchMessage(&msg);
}*/
while(msg.message != WM_QUIT)
{
if(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
gl.DrawGLScene();
gl.Swap();
}
}
gl.KillGLWindow();
// Rückgabewert an Windows
return 0;
}
// Fenster erzeugen
HWND CreateMainWindow(HINSTANCE hInstance)
{
WNDCLASSEX wndClass =
{
sizeof(WNDCLASSEX), // Größe angeben
CS_DBLCLKS | CS_OWNDC | CS_HREDRAW | CS_VREDRAW, // Standardstile
MessageHandler, // Callback-Funktion
0, // Zusätzliche Angaben
0, // nicht benötigt
hInstance, // Anwendungsinstanz
LoadIcon(NULL, IDI_WINLOGO), // Windows-Logo
LoadCursor(NULL, IDC_ARROW), // Normaler Cursor
(HBRUSH)GetStockObject(WHITE_BRUSH), // Weißer Pinsel
NULL, // kein Menü
L"WindowClass", // Der Name der Klasse
LoadIcon(NULL, IDI_WINLOGO) // Windows Logo
};
RegisterClassEx(&wndClass);
return CreateWindowEx(NULL, // Keine erweiterten Stile nutzen
L"WindowClass", // Klassenname
L"standard title (please change!!!)", // Fenstertitel
WS_OVERLAPPEDWINDOW | // Fenster
WS_VISIBLE, // Eigenschaften
100, 100, 400, 300, // Anfangsposition und Größe
NULL, // Handle des Elternfensters
NULL, // Handle des Menüs
hInstance, // Anwendungsinstanz
0); // wird nicht benötigt
}
LRESULT CALLBACK MessageHandler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch(msg)
{
case WM_DESTROY:
PostQuitMessage(0);
return 0;
break;
}
return DefWindowProc(hwnd, msg, wParam, lParam);
}
|
_________________
I can see I'm going blind.
Zuletzt bearbeitet von Legolas87 am 25.05.2011, 19:56, insgesamt einmal bearbeitet |
|
| Nach oben |
|
 |
David
Super JLI'ler
Alter: 39
Anmeldedatum: 13.10.2005
Beiträge: 315
Medaillen: Keine
|
| Verfasst am: 27.06.2007, 17:31 Titel: |
|
|
Hab mal schnell drüber geschaut, was mir da aufgefallen ist:
 Initialisierungliste verwenden
D'tor is total unnötig in dem Fall
Ersten 4 Zeilen von ReSizeGLScene sind ein Hack, würd ich anders lösen
InitGL => Wieso bastelst du an OpenGL Settings rum wenn du sowiso noch keinen Kontext hast? 
InitGL => Messageboxen aus der Funktion nehmen, is nich schön
Allgemein => Immer nur ein return pro Funktion (wenns geht)
InitGL => Wieso gibst du immer FALSE zurück und am Ende "1"?
DrawGLScene => Wieso nen Rückgabewert?
DrawGLScene => Is total unflexibel...
KillGLWindow => Messagebox Problem
KillGLWindow => Zerstört auch Fenster usw... is nich gut weil das Fenster ja nicht auch von der Klasse erstellt wird.
Swap => Is irgendwie unnütz
Klassenname is nich gerade günstig gewählt, wie ich finde |
|
| Nach oben |
|
|
Legolas87
JLI'ler
Alter: 36
Anmeldedatum: 22.10.2003
Beiträge: 131
Medaillen: Keine
|
| Verfasst am: 27.06.2007, 17:51 Titel: |
|
|
Danke dass du dir das angesehen hast, aber kannst du bitte deine Punkte, wenn du Zeit hast, etwas mehr ausführen, verstehe nämlich die meisten nicht!
_________________
I can see I'm going blind. |
|
| Nach oben |
|
|
Legolas87
JLI'ler
Alter: 36
Anmeldedatum: 22.10.2003
Beiträge: 131
Medaillen: Keine
|
| Verfasst am: 27.06.2007, 18:19 Titel: |
|
|
Punkt 1: meinst du sowas und wenn ja was ist der Vorteil?
| Code: | OpenGL::OpenGL(void):m_hRC(0),m_hDC(0),m_hWnd(0),m_hInstance(0)
{
} |
Punkt 2:
Soll ich die Sachen aus KillGLWindow in den D'tor schreiben und das Fensterhandle rauslassen und dieses in main löschen?
Punkt 3:
Wie würdest dus lösen oder warum ist das schlampig programmiert? Kann da was passieren?
Punkt 4:
| Code: | int OpenGL::InitGL(HWND hWnd,HINSTANCE hInstance)
{
m_hWnd=hWnd;
m_hInstance=hInstance;
int PixelFormat;
// set the pixel format for the DC
PIXELFORMATDESCRIPTOR pfd;
ZeroMemory( &pfd, sizeof( pfd ) );
pfd.nSize = sizeof( pfd );
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL |
PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 24;
pfd.cDepthBits = 16;
pfd.iLayerType = PFD_MAIN_PLANE;
int format = ChoosePixelFormat( m_hDC, &pfd );
SetPixelFormat( m_hDC, format, &pfd );
if (!(m_hDC=GetDC(m_hWnd))) // Versuch, den DC zu bekommen
{
KillGLWindow();
MessageBox(NULL,L"Konnte keinen DC erstellen.",L"ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
if (!(PixelFormat=ChoosePixelFormat(m_hDC,&pfd)))
// Kann Windows ein passendes finden?
{
// Falls keins gefunden werden kann:
KillGLWindow(); // Alles zurücksetzen
MessageBox(NULL,L"Konnte kein passendes Pixelformat finden.",L"ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // FALSE zurück und Ende.
}
if(!SetPixelFormat(m_hDC,PixelFormat,&pfd))
// Kann das Pixelformat gesetzt werden?
{
KillGLWindow(); // Leider nicht, Fehlerpopup und raus
MessageBox(NULL,L"Konnte Pixelformat nicht setzen.",L"ERROR",MB_OK|MB_ICONEXCLAMATION);
return FALSE; // FALSE zurück und raus
}
if (!(m_hRC=wglCreateContext(m_hDC))) // Versuch den RC zu bekommen
{
KillGLWindow(); // Alles rückgängig machen
MessageBox(NULL,L"Konnte keinen Rendering Context bekommen.",L"Fehler",MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
if(!wglMakeCurrent(m_hDC,m_hRC)) // Versuch den RC zu aktivieren
{
KillGLWindow(); // hat nicht geklappt, also alles zurück
MessageBox(NULL,L"Konnte den Rendering Context nmicht aktivieren.",L"Fehler",MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
glClearColor(1.0f, 0.0f, 1.0f, 1.0f);
glClearDepth(1.0);
glShadeModel(GL_SMOOTH);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f,(float)800/(float)600,0.1f,150.0f);
glMatrixMode(GL_MODELVIEW);
return 1;
}
|
so besser? Ist die Übergabe von hWnd und hInstance so ok oder entspricht das nicht der OOP oder iwas anderem?
Punkt 5:
Meinst du ich sollte eine Fehlerklasse entwerfen der alle Fehler per Zeichenkette gesendet werden und die sich dann um die Ausgabe kümmert?
Punkt 6:
Wäre eine Variable besser die dann ganz am Ende returnt wird?
Punkt 7:
Weil ich die hässlichen MessageBoxen nicht selbst geschrieben habe und ich nur schnell testen wollte.
Punkt 8:
Kein Rückgabewert mehr da.
Punkt 9:
Was meinst du mit unflexibel?
Punkt 10:
Das Gleiche wie Punkt 5?
Punkt 11:
In main.cpp zerstören?
Punkt 12:
Swap hab ich gelöscht und das was drin war ans Ende von DrawGLScene geschrieben. ok?
Punkt 13:
ok da überleg ich noch was, war auch auf die Schnelle!
_________________
I can see I'm going blind. |
|
| Nach oben |
|
|
David
Super JLI'ler
Alter: 39
Anmeldedatum: 13.10.2005
Beiträge: 315
Medaillen: Keine
|
| Verfasst am: 27.06.2007, 19:15 Titel: |
|
|
Punkt 1:
Genau das mein ich. Das hat den Vorteil das die Variablen tatsächlich initialisiert werden und nicht per Defaultwert initialisiert werden und dann von dir Werte zugewiesen bekommen. Dadurch sparst du dir z.B. den Aufruf des Konstruktorbodies.
Punkt 2:
Könntest du machen. Wenn du's geschickt löst würd das sogar durchaus Sinn ergeben.
Punkt 3:
Hacks sind nie Zeichen guten Softwaredesigns oder guter Programmierung. Werf lieber eine Ausnahme oder gib einen Fehlercode als Returnwert zurück, das ist sauberer.
Punkt 4:
Ja, nun hast du wenigstens einen Renderkontext. Allerdings kannst du die Funktion öfter als einmal aufrufen, was passiert dann? Gute Frage! Auf jedenfall sollte man die ganze Funktion lieber nicht zweimal durchlaufen dürfen.
Punkt 5
Nein, du könntest aber Ausnahmen werfen und dort Fehlerberschreibungen liefert. Oder Fehlercodes zurückgeben, oder oder oder...
Punkt 6:
Unter Umständen schon. Vorallem wär es aber übersichtlicher.
Punkt 7:
Nadann...
Punkt 8:
Macht auch irgendwie kein Sinn wenn sowiso immer nur TRUE zurückgegeben wird, oder?
Punkt 9:
Fragen wir mal andersrum. Was ist daran Flexibel? Wie willst du z.B. Geometriedaten übergeben?
Punkt 10:
Genau
Punkt 11:
Wenn du die Fehnsterklasse dort erzeugst (sowie das Fenster) dann auch dort zerstören!
Punkt 12:
Kann man so machen.
Punkt 13:
Fein! |
|
| Nach oben |
|
|
Legolas87
JLI'ler
Alter: 36
Anmeldedatum: 22.10.2003
Beiträge: 131
Medaillen: Keine
|
| Verfasst am: 27.06.2007, 19:35 Titel: |
|
|
Punkt 1:
Aber ich habe die doch j auch mit 0 initialisiert. Oder soll ich die schon im Konstruktor mit was Ordentlichem füllen? Dazu müsste ich aber Funktionen in der Initialisierungsliste ausführen.
Punkt 4:
Also am Besten auch irgenwie in den Konstruktor packen?
Punkt 5:
Ich könnte ein gutes Tutorial brauchen, in den try catch und throw beschrieben wird, am besten sowas ähnliches, was ich brauche, um die MessageBoxen zu ersetzen. Weiß jmd was?
Punkt 9:
Da hab ich mir noch gar keine Gedanken drum gemacht, aber vielleicht wäres cool, wenn das Programm eine Textdatei ausliest mit Daten, diese an DrawGLScene übergibt, oder was meinst du?
Punkt11:
Muss man das alles zerstören, weil das war heute das erste Mal, dass ich sowas gesehen habe.
nochmals Danke
_________________
I can see I'm going blind. |
|
| Nach oben |
|
|
Legolas87
JLI'ler
Alter: 36
Anmeldedatum: 22.10.2003
Beiträge: 131
Medaillen: Keine
|
| Verfasst am: 03.07.2007, 14:04 Titel: |
|
|
Wäre nett wenn meine fragen aus dem letzten Beitrag noch beantwortet würden.
Außerdem hab ich bisschen an einer Exceptionklasse gebastelt.
| Code: |
/ ###########################################################################
// Datei: Cexception.h
// ###########################################################################
// Autor:
// Erstellt: 03.07.2007
// Änderungen: 03.07.2007
// Bemerkung: erstellt
// ###########################################################################
// Beschreibung:
#include <string>
using namespace std;
class Cexception
{
public:
enum ERROR_CODES
{
UNKNOWN_ERROR = 0,
OPENGL_INIT_ERROR = 100
};
Cexception(unsigned int Error);
~Cexception(void);
const wchar_t* GetErrorString(void);
unsigned int GetErrorID(void);
private:
unsigned int m_Error;
};
// ###########################################################################
// Datei: Cexception.cpp
// ###########################################################################
// Autor:
// Erstellt: 03.07.2007
// Änderungen: 03.07.2007
// Bemerkung: erstellt
// ###########################################################################
// Beschreibung:
#include "Cexception.h"
Cexception::Cexception(unsigned int Error):m_Error(Error)
{
}
Cexception::~Cexception(void)
{
}
const wchar_t* Cexception::GetErrorString(void)
{
switch(m_Error)
{
case OPENGL_INIT_ERROR: return L"OpenGL konnte nicht initialisiert werden";
case UNKNOWN_ERROR:
default: return L"Unbekannter Fehler";
}
}
unsigned int Cexception::GetErrorID(void)
{
return m_Error;
}
|
bei folgendem Aufruf erhalte ich aber eine Fehlermeldung, dass links von c_str() keine Klasse ist.
| Code: |
try
{
gl.InitGL(hWnd,hInstance);
}
catch(Cexception& error)
{
MessageBox(hWnd, error.GetErrorString().c_wstr(),L"Fehler",MB_OK);
}
|
_________________
I can see I'm going blind. |
|
| Nach oben |
|
|
The Lord of Programming
Living Legend
Alter: 36
Anmeldedatum: 14.03.2003
Beiträge: 3122
Medaillen: Keine
|
| Verfasst am: 03.07.2007, 15:03 Titel: |
|
|
| Legolas87 hat Folgendes geschrieben: | | bei folgendem Aufruf erhalte ich aber eine Fehlermeldung, dass links von c_str() keine Klasse ist. |
Kein Wunder...
Der Funktionskopf deiner GetErrorString()-Methode sieht so aus:
| CPP: | | const wchar_t* Cexception::GetErrorString(void) |
Der Rückgabetyp ist const wchat_t*, also logischerweise keine Klasse. Läuft dein gesamtes Programm auf Unicode? Dann sollte es kein Problem sein, der MessageBox()-Funktion schlichtweg den const wchat_t-Zeiger zu übergeben.
Allerdings ist Vorsicht geboten bei solchen Konstrukten. Immerhin ist der Rückgabetyp immer noch ein Zeiger, der auf eine lokal erstellte Variable zeigen soll. Was passiert denn, wenn du L"OpenGL konnte nicht initialisiert werden" oder L"Unbekannter Fehler" in den Speicher stellst und das Programm den Gültigkeitsbereich verlässt?
Gehe hier lieber einen anderen Weg:
1. (komfortabel & langsamer) std::wstring:
Gib einen wstring zurück. Der kümmert sich selbst um die Verwaltung des Speichers. Du brauchst nur (analog zu std::string) eine Instanz dieser Klasse erstellen, mit dem String initialisieren und zurückgeben.
Pass allerdings auf - die Methode von std::wstring, um den reinen String zurückzubekommen, heißt nicht wie du geschrieben hast c_wstr(), sondern wie bei std::string schlichtweg c_str().
2. (unkomfortabel & schneller) wchar_t-Array:
Erstelle ein Array tatsächlich im Speicher und übergib der GetErrorString()-Methode den Zeiger darauf. Dann kannst du dir wirklich sicher sein, dass der Speicher beim Verlassen der Methode immer noch gültig ist:
| CPP: | void Cexception::GetErrorString(wchar_t* String)
{
switch(m_Error)
{
case OPENGL_INIT_ERROR: wcscpy_s(String,wcslen(String),L"OpenGL konnte nicht initialisiert werden"); break;
case UNKNOWN_ERROR:
default: wcscpy_s(String,wcslen(String),L"Unbekannter Fehler"); break;
}
}
try
{
gl.InitGL(hWnd,hInstance);
}
catch(Cexception& error)
{
wchar_t error_string[100];
error.GetErrorString(error_string);
MessageBox(hWnd, error_string,L"Fehler",MB_OK);
}
|
PS: Verwende doch für C++ Codes auch die [ CPP ]-Tags, das ist um Längen lesbarer 
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console
Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet... |
|
| Nach oben |
|
|
Legolas87
JLI'ler
Alter: 36
Anmeldedatum: 22.10.2003
Beiträge: 131
Medaillen: Keine
|
| Verfasst am: 03.07.2007, 17:08 Titel: |
|
|
gut vielen Dank!
Ich habe j einfach wstring benutzt.
Kann das sein dass der Device Context nicht freigegeben werden kann, da bei Beenden der Klasse, also beim Konstruktoraufruf schon kein Fenster mehr existiert? Muss ich dann den Dekonstruktor vor dem PostQuitMessage aufrufen, auch wenn mein Gefühl mir sagt, dass das nicht elegant ist?
_________________
I can see I'm going blind. |
|
| Nach oben |
|
|
Legolas87
JLI'ler
Alter: 36
Anmeldedatum: 22.10.2003
Beiträge: 131
Medaillen: Keine
|
| Verfasst am: 04.07.2007, 20:45 Titel: |
|
|
>c:\program files\microsoft visual studio 9.0\vc\include\yvals.h(519) : error C2143: syntax error : missing ';' before 'namespace'
Das kommt bei mir wenn ich dinput.h einbinde. An der Datei hab ich doch gar nichts veränert, wieso sind da Fehler drin?
_________________
I can see I'm going blind. |
|
| Nach oben |
|
|
The Lord of Programming
Living Legend
Alter: 36
Anmeldedatum: 14.03.2003
Beiträge: 3122
Medaillen: Keine
|
| Verfasst am: 05.07.2007, 02:03 Titel: |
|
|
| Legolas87 hat Folgendes geschrieben: | >c:\program files\microsoft visual studio 9.0\vc\include\yvals.h(519) : error C2143: syntax error : missing ';' before 'namespace'
Das kommt bei mir wenn ich dinput.h einbinde. An der Datei hab ich doch gar nichts veränert, wieso sind da Fehler drin? |
Der Fehler ist nicht immer dort, wo er angezeigt wird
Gerade wenn ein Fehler verursacht wird, sobald du eine Datei einbindest, solltest du in dieser Datei nach dem Fehler suchen. Wahrscheinlich hast du dort irgendwo ein ; am Ende vergessen. Da der Compiler nicht ausspuckt "hinter xy fehlt ein ;", sondern "vor xy ...", merkt er es in vielen Fällen erst, wenn er beim Kompilieren schon in die nächste Datei gesprungen ist.
Wenn dich das noch nicht weitergebracht hat, am besten Code zeigen(nicht den der yvals.h )
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console
Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet... |
|
| Nach oben |
|
|
Legolas87
JLI'ler
Alter: 36
Anmeldedatum: 22.10.2003
Beiträge: 131
Medaillen: Keine
|
| Verfasst am: 05.07.2007, 10:13 Titel: |
|
|
nicht beschweren, da fehlt noch die hälfte
ist das eigentlich sinnvoll, opengl mit dinput zur tastaturverwaltung zu programmieren?
| CPP: | // ###########################################################################
// Datei: Cinput.h
// ###########################################################################
// Autor:
// Erstellt: 04.07.2007
// Änderungen: 04.07.2007
// Bemerkung: erstellt
// ###########################################################################
// Beschreibung:
//Bibliotheken
#pragma comment(lib,"dinput8.lib")
//Header
#include <windows.h>
#include <dinput.h>
class Cinput
{
public:
Cinput(void);
~Cinput(void);
bool Init(HWND& hWnd,HINSTANCE& hInstance,int Device);
int GetInput(void);
private:
LPDIRECTINPUT8 m_lpDI;
bool InitKeyboard(HWND hWnd);
bool InitMouse(HWND hWnd);
int GetKeyboardInput(void);
int GetMouseInput(void);
}
|
_________________
I can see I'm going blind.
Zuletzt bearbeitet von Legolas87 am 25.05.2011, 19:57, insgesamt einmal bearbeitet |
|
| Nach oben |
|
|
Asto
JLI'ler
Alter: 36
Anmeldedatum: 30.05.2007
Beiträge: 114
Wohnort: Dortmund
Medaillen: Keine
|
| Verfasst am: 05.07.2007, 10:53 Titel: |
|
|
ähm ich persönlich würde jetzt sagen: nein
DInput ist ja ein Teil von DirectX bzw. von den ganzen D-Dingern unter Windows ^^, wenn ich mich, als Neueinsteiger in die Thematik, grad nicht irre
Und ich denke du Programmierst mit OpenGL, um davon loszukommen und evt. auch unter Linux lauffähige Programme zu erstellen oder?
_________________
"A programmer started to cuss, Because getting to sleep was a fuss, As he lay there in bed, Looping 'round in his head, was: while(!asleep()) sheep++;", Unbekannt |
|
| Nach oben |
|
|
The Lord of Programming
Living Legend
Alter: 36
Anmeldedatum: 14.03.2003
Beiträge: 3122
Medaillen: Keine
|
|
| Nach oben |
|
|
Legolas87
JLI'ler
Alter: 36
Anmeldedatum: 22.10.2003
Beiträge: 131
Medaillen: Keine
|
| Verfasst am: 05.07.2007, 20:57 Titel: |
|
|
Ich will ne flotte Tastatur und Mauseingabeklasse schreiben, die ich auch in andere Programme übernehmen kann. Das mit Linux ist schon ein Argument, also was räts du mir?
krass was son ein ; alles anstellt!
jetzt muss ich nur noch mit einem unresolved external klarkommen aber heute nicht mehr
werde trotzdem bald wieder eine Frage dazu haben
Danke schonmal
Gruß
Legolas
_________________
I can see I'm going blind. |
|
| Nach oben |
|
|
|
|
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.
|
Powered by phpBB © 2001, 2005 phpBB Group
Deutsche Übersetzung von phpBB.de |
FAQ
Suchen
Mitgliederliste
Benutzergruppen
Medaillen
Registrieren
Profil
Einloggen, um private Nachrichten zu lesen
Login
