Wie lade ich Texturen mit wxImage richtig?

[littletux]

Hallo Zusammen!

Ich bin gerade dabei OpenGL mit wxWidgets zu lernen. Momentan habe ich es so weit geschaft, dass OpenGL in meine GUI-Anwendung läuft. Ich kann zwar Dreiecke, Vierecke und Würfel zeichnen, aber sobald ich Texturen einfügen möchte, habe ich Probleme. Ich weiß, dass bei der LoadFile-Methode von meiner srImage-Klasse was fehlt. Da ich mich aber mit Texturen sehr wenig auskenne, möchte ich euch fragen, ob ihr mir vielleicht helfen könntet. Ich währe euch sehr dankbar!

Hier sind meine Quelltexte:

opengl.h:

////////////////////////////////////////////////////////////////////////////////
/// Die srOpenGL-Schablone
////////////////////////////////////////////////////////////////////////////////

#ifndef _srOpenGL_h_
#define _srOpenGL_h_

#include <wx/dcclient.h>
#include <wx/glcanvas.h>

#include "figure.h"

class srOpenGL : public wxGLCanvas
{
	private:
		bool init;
		float fit;
		float rotateX;
		float rotateY;
		float rotateZ;
		float translateX;
		float translateY;
		float translateZ;
		srFigure *srObject;
		void DrawObject();
		void InitOpenGL();
		void Render();
		void Rotate(int x, int y, int z);
		void Translate(float x, float y, float z);
	protected:
		virtual void OnMouseMove(wxMouseEvent &event);
		virtual void OnPaint(wxPaintEvent &event);
		virtual void OnSize(wxSizeEvent &event);
	public:
		srOpenGL(wxWindow *parent, int *args = 0, wxWindowID id = wxID_ANY,
		const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize,
		long style = wxTAB_TRAVERSAL, const wxString &name = wxT("srOpenGL"));
		~srOpenGL();
		int GetHeight();
		int GetWidth();
};

#endif

opengl.cpp:

////////////////////////////////////////////////////////////////////////////////
/// Die srOpenGL-Implementierung
////////////////////////////////////////////////////////////////////////////////

#include "opengl.h"

srOpenGL::srOpenGL(wxWindow *parent, int *args, wxWindowID id, const wxPoint &pos,
const wxSize &size, long style, const wxString &name) : wxGLCanvas(parent, id, pos,
size, style, name, args), init(FALSE), fit(1.0f), rotateX(-45), rotateY(-45), rotateZ(0),
translateX(0.0f), translateY(0.0f), translateZ(0.0f)
{
////////////////////////////////////////////////////////////////////////////////
/// Die Konfiguration
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	this->srObject = new srFigure();
	////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
/// Die Connect-Ereignisse
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	this->Connect(wxEVT_MOTION, wxMouseEventHandler(srOpenGL::OnMouseMove));
	this->Connect(wxEVT_PAINT, wxPaintEventHandler(srOpenGL::OnPaint));
	this->Connect(wxEVT_SIZE, wxSizeEventHandler(srOpenGL::OnSize));
	////////////////////////////////////////
}

srOpenGL::~srOpenGL()
{
////////////////////////////////////////////////////////////////////////////////
/// Die Disconnect-Ereignisse
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	this->Disconnect(wxEVT_SIZE, wxSizeEventHandler(srOpenGL::OnSize));
	this->Disconnect(wxEVT_PAINT, wxPaintEventHandler(srOpenGL::OnPaint));
	this->Disconnect(wxEVT_MOTION, wxMouseEventHandler(srOpenGL::OnMouseMove));
	////////////////////////////////////////
}

int srOpenGL::GetHeight()
{
////////////////////////////////////////////////////////////////////////////////
/// Der Höhen-Akzessor
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	return this->GetSize().y;
	////////////////////////////////////////
}

int srOpenGL::GetWidth()
{
////////////////////////////////////////////////////////////////////////////////
/// Der Breiten-Akzessor
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	return this->GetSize().x;
	////////////////////////////////////////
}

void srOpenGL::DrawObject()
{
////////////////////////////////////////////////////////////////////////////////
/// Das Objekt zeichnen
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	this->srObject->DrawObject();
	////////////////////////////////////////
}

void srOpenGL::InitOpenGL()
{
////////////////////////////////////////////////////////////////////////////////
/// OpenGL vorbereiten
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	static const GLfloat light0_color[4]	= {0.6f, 0.6f, 0.6f, 1.0f};
	static const GLfloat light0_pos[4]	= {-5.0f, 5.0f, 5.0f, 0.0f};
	static const GLfloat light1_color[4]	= {0.4f, 0.4f, 1.0f, 1.0f};
	static const GLfloat light1_pos[4]	= {5.0f, -5.0f, -5.0f, 0.0f};

	glDisable(GL_CULL_FACE);
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_DITHER);
	glEnable(GL_TEXTURE_2D);
	glShadeModel(GL_SMOOTH);

	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_FASTEST);
	glHint(GL_POLYGON_SMOOTH_HINT, GL_FASTEST);

	glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_color);
	glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_color);
	glLightfv(GL_LIGHT0, GL_POSITION, light0_pos);
	glLightfv(GL_LIGHT1, GL_POSITION, light1_pos);

	glEnable(GL_LIGHT0);
	glEnable(GL_LIGHT1);
	glEnable(GL_LIGHTING);

	glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
	glEnable(GL_COLOR_MATERIAL);

	glClearColor(0.92f, 0.92f, 0.92f, 0.0f);
	////////////////////////////////////////
}

void srOpenGL::OnMouseMove(wxMouseEvent &event)
{
////////////////////////////////////////////////////////////////////////////////
/// Das Objekt mit der Maus drehen
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	int baseX, baseY, difX, difY, posX, posY;

	baseX = (this->GetWidth()/2);
	baseY = (this->GetHeight()/2);
	posX = event.GetX();
	posY = event.GetY();
	difX = (baseX-posX);
	difY = (baseY-posY);

	if(event.LeftIsDown())
	{
		this->Rotate(difY, difX, 0);
	}

	event.Skip();
	////////////////////////////////////////
}

void srOpenGL::OnPaint(wxPaintEvent &event)
{
////////////////////////////////////////////////////////////////////////////////
/// OpenGL einrichten
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	wxPaintDC *paint = new wxPaintDC(this);
	wxGLCanvas::SetCurrent();

	if(!this->init)
	{
		this->InitOpenGL();
		this->init = TRUE;
	}

	this->Render();
	glFlush();
	wxGLCanvas::SwapBuffers();

	delete paint;
	////////////////////////////////////////
}

void srOpenGL::OnSize(wxSizeEvent &event)
{
////////////////////////////////////////////////////////////////////////////////
/// OpenGL im Panel anpassen
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	int height, width;

	wxGLCanvas::GetClientSize(&width, &height);
	if(wxGLCanvas::GetContext())
	{
		wxGLCanvas::SetCurrent();
		glViewport(0, 0, (GLint)width, (GLint)height);
	}

	wxGLCanvas::OnSize(event);

	this->fit = (static_cast<float>(this->GetHeight())
	/static_cast<float>(this->GetWidth()));
	////////////////////////////////////////
}

void srOpenGL::Render()
{
////////////////////////////////////////////////////////////////////////////////
/// Das Objekt rendern
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	glLoadIdentity();

	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

	glScalef(this->fit, 1.0f, 1.0f);

	glRotatef(this->rotateX, 1.0f, 0.0f, 0.0f);
	glRotatef(this->rotateY, 0.0f, 1.0f, 0.0f);
	glRotatef(this->rotateZ, 0.0f, 0.0f, 1.0f);

	glTranslatef(this->translateX, this->translateY, this->translateZ);

	this->DrawObject();
	////////////////////////////////////////
}

void srOpenGL::Rotate(int x, int y, int z)
{
////////////////////////////////////////////////////////////////////////////////
/// Das 3D-Objekt drehen
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	this->rotateX = x;
	this->rotateY = y;
	this->rotateZ = z;
	this->Refresh();
	////////////////////////////////////////
}

void srOpenGL::Translate(float x, float y, float z)
{
////////////////////////////////////////////////////////////////////////////////
/// Das 3D-Objekt verschieben
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	this->translateX = x;
	this->translateY = y;
	this->translateZ = z;
	this->Refresh();
	////////////////////////////////////////
}

figure.h:

////////////////////////////////////////////////////////////////////////////////
/// Die srFigure-Schablone
////////////////////////////////////////////////////////////////////////////////

#ifndef _srFigure_h_
#define _srFigure_h_

#include "image.h"

class srFigure
{
	private:
		srImage *image;
	public:
		srFigure();
		~srFigure();
		void DrawObject();
};

#endif

figure.cpp:

////////////////////////////////////////////////////////////////////////////////
/// Die srFigure-Implementierung
////////////////////////////////////////////////////////////////////////////////

#include "figure.h"

srFigure::srFigure()
{
////////////////////////////////////////////////////////////////////////////////
/// Die Konfiguration
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	image = new srImage();
	image->LoadFile(wxT("test.bmp"));
	image->IsTexture();
	////////////////////////////////////////
}

srFigure::~srFigure()
{
}

void srFigure::DrawObject()
{
////////////////////////////////////////////////////////////////////////////////
/// Objekt zeichnen
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	glBindTexture(GL_TEXTURE_2D, image->GetID());

	glBegin(GL_QUADS);
		glTexCoord2f(0.0f, 0.0f); glVertex3f(-1.0f, 1.0f, 0.0f);
		glTexCoord2f(0.0f, 1.0f); glVertex3f(-1.0f, -1.0f, 0.0f);
		glTexCoord2f(1.0f, 1.0f); glVertex3f(1.0f, -1.0f, 0.0f);
		glTexCoord2f(1.0f, 0.0f); glVertex3f(1.0f, 1.0f, 0.0f);
	glEnd();
	////////////////////////////////////////
}

image.h:

////////////////////////////////////////////////////////////////////////////////
/// Die srImage-Schablone
////////////////////////////////////////////////////////////////////////////////

#ifndef _srImage_h_
#define _srImage_h_

#include <GL/gl.h>
#include <wx/image.h>
#include <wx/msgdlg.h>

class srImage
{
	private:
		int height;
		int width;
		GLuint id;
	public:
		srImage();
		~srImage();
		bool IsTexture();
		int GetHeight();
		int GetWidth();
		GLuint GetID();
		void Destroy();
		void LoadFile(const wxString &file);
};

#endif

image.cpp:

////////////////////////////////////////////////////////////////////////////////
/// Die srImage-Implementierung
////////////////////////////////////////////////////////////////////////////////

#include "image.h"

srImage::srImage()
{
}

srImage::~srImage()
{
}

bool srImage::IsTexture()
{
////////////////////////////////////////////////////////////////////////////////
/// Die Textur-ID überprüfen
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	wxString caption, message;

	caption = wxT("Fehlermeldung");

	if(glIsTexture(this->id) != GL_TRUE)
	{
		message = wxT("Die ID bezeichnet keine\nexisierende OpenGL-Textur!");
		wxMessageBox(message, caption);

		return FALSE;
	}

	GLboolean resident;

	if(!glAreTexturesResident(1, &this->id, &resident))
	{
		message = wxT("Die Textur wurde nicht auf\ndie Grafikkarte geladen!");
		wxMessageBox(message, caption);

		return FALSE;
	}
	else
	{
		return TRUE;
	}
	////////////////////////////////////////
}

int srImage::GetHeight()
{
////////////////////////////////////////////////////////////////////////////////
/// Der Höhen-Akzessor
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	return this->height;
	////////////////////////////////////////
}

int srImage::GetWidth()
{
////////////////////////////////////////////////////////////////////////////////
/// Der Breiten-Akzessor
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	return this->width;
	////////////////////////////////////////
}

GLuint srImage::GetID()
{
////////////////////////////////////////////////////////////////////////////////
/// Der Textur-ID-Akzessor
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	return this->id;
	////////////////////////////////////////
}

void srImage::Destroy()
{
////////////////////////////////////////////////////////////////////////////////
/// Die Textur-ID entfernen
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	glDeleteTextures(1, &this->id);
	////////////////////////////////////////
}

void srImage::LoadFile(const wxString &file)
{
////////////////////////////////////////////////////////////////////////////////
/// Die Textur laden
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	if(!wxFileExists(file))
	{
		wxString caption, message;

		caption = wxT("Fehlermeldung");
		message = wxT("Die Datei \"");
		message.Append(file);
		message.Append(wxT("\"\nwurde nicht gefunden!"));

		wxMessageBox(message, caption);

		return;
	}

	glGenTextures(1, &this->id);
	glBindTexture(GL_TEXTURE_2D, this->id);
	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

	wxInitAllImageHandlers();

	wxImage *image = new wxImage(file);

	this->height = image->GetHeight();
	this->width = image->GetWidth();

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
	this->GetWidth(), this->GetHeight(), 0,
	GL_RGB, GL_UNSIGNED_BYTE, image->GetData());

	delete image;
	////////////////////////////////////////
}

[littletux]

Wie kann ich mein Thread ins "Spiele/-Grafikprogrammierung" verschieben? Ich glaube mein Thema passt hier nicht richtig rein, obwohl es auch was mit wxWidgets zu tuen hat.

[C++ Forumbot]

Dieser Thread wurde von Moderator/in phlox81 aus dem Forum Andere GUIs - Qt, GTK+, wxWidgets in das Forum Spiele-/Grafikprogrammierung verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

[player424]

Was genau funktioniert denn nicht. Compilerfehler? Wird das Bild nicht (richtig) angezeigt?

[littletux]

Beim kompilieren gibt es keine Fehler. Mein GUI-Programm arbeitet so wie ich es erwarte. Er zeigt nur die Fehlermeldung "Die ID bezeichnet keine exisierende OpenGL-Textur!" an, die von meine srImage-Klasse ausgelöst wird. Danach zeichnet OpenGL aber gleich das Viereck in weißer Farbe.

Mein Problem ist, dass meine LoadFile-Methode aus der srImage-Klasse die Textur nicht richtig in meine id ablegt. Siehe Codeschnipsel "image.h" und "image.cpp", der in meinen ersten Beitrag ganz unten steht.

[littletux]

Im Codeschnipsel "figure.cpp" findest Du meine srFigure-Klasse, die für das Zeichnen des Vierecks zuständig ist und den ablauf schildert, was passiert, wenn OpenGL aufgerufen wird. Die Methode IsTextur von srImage überprüft, ob die Textur richtig abgelegt wurde und gibt ein bool zurück.

[littletux]

Ich glaube es liegt irgendwie an glGenTextures. Ich habe auch versucht meine srImage-Klasse umzuändern. Leider hat es mich nicht weitergebracht.

image.h:

////////////////////////////////////////////////////////////////////////////////
/// Die srImage-Schablone
////////////////////////////////////////////////////////////////////////////////

#ifndef _srImage_h_
#define _srImage_h_

#include <GL/gl.h>
#include <wx/image.h>
#include <wx/msgdlg.h>

class srImage
{
	private:
		int height;
		int width;
		GLuint *id;
	public:
		srImage();
		~srImage();
		bool IsTexture();
		int GetHeight();
		int GetWidth();
		GLuint *GetID();
		void Destroy();
		void LoadFile(const wxString &file);
};

#endif

image.cpp:

////////////////////////////////////////////////////////////////////////////////
/// Die srImage-Implementierung
////////////////////////////////////////////////////////////////////////////////

#include "image.h"

srImage::srImage()
{
////////////////////////////////////////////////////////////////////////////////
/// Die Konfiguration
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	this->id = new GLuint[1];
	////////////////////////////////////////
}

srImage::~srImage()
{
}

bool srImage::IsTexture()
{
////////////////////////////////////////////////////////////////////////////////
/// Die Textur-ID überprüfen
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	wxString caption, message;
	caption = wxT("Fehlermeldung");

	if(glIsTexture(this->id[0]) == GL_FALSE)
	{
		message = wxT("Die ID bezeichnet keine\nexisierende OpenGL-Textur!");
		wxMessageBox(message, caption);

		return FALSE;
	}

	GLboolean resident;

	if(!glAreTexturesResident(1, &this->id[0], &resident))
	{
		message = wxT("Die Textur wurde nicht auf\ndie Grafikkarte geladen!");
		wxMessageBox(message, caption);

		return FALSE;
	}
	else
	{
		return TRUE;
	}
	////////////////////////////////////////
}

int srImage::GetHeight()
{
////////////////////////////////////////////////////////////////////////////////
/// Der Höhen-Akzessor
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	return this->height;
	////////////////////////////////////////
}

int srImage::GetWidth()
{
////////////////////////////////////////////////////////////////////////////////
/// Der Breiten-Akzessor
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	return this->width;
	////////////////////////////////////////
}

GLuint *srImage::GetID()
{
////////////////////////////////////////////////////////////////////////////////
/// Der Textur-ID-Akzessor
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	return this->id;
	////////////////////////////////////////
}

void srImage::Destroy()
{
////////////////////////////////////////////////////////////////////////////////
/// Die Textur-ID entfernen
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	glDeleteTextures(1, &this->id[0]);
	////////////////////////////////////////
}

void srImage::LoadFile(const wxString &file)
{
////////////////////////////////////////////////////////////////////////////////
/// Die Textur laden
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	wxString caption, message;
	caption = wxT("Fehlermeldung");

	wxInitAllImageHandlers();

	if(!wxFileExists(file))
	{
		message = wxT("Die Datei \"");
		message.Append(file);
		message.Append(wxT("\"\nwurde nicht gefunden!"));
		wxMessageBox(message, caption);

		return;
	}

	wxImage *image = new wxImage(file);

	this->height = image->GetHeight();
	this->width = image->GetWidth();

	glGenTextures(1, &this->id[0]);

	if(image->IsOk())
	{
		glBindTexture(GL_TEXTURE_2D, *this->id);
		glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);

		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
		this->GetWidth(), this->GetHeight(), 0,
		GL_RGB, GL_UNSIGNED_BYTE, image->GetData());
	}
	else
	{
		message = wxT("Die Textur ist nicht in Ordnung!");
		wxMessageBox(message, caption);
	}

	delete image;
	////////////////////////////////////////
}

[littletux]

Ich habe es jetzt raus gefunden, wieso glGenTextures nicht funktioniert. Ich muss die Klasse srImage direkt in die OpenGL-Klasse vor der Render-Methode anhängen. Jetzt besitzt meine ID eine eindeutige Zahl.

Bei der Ausführung meines Programms erhalte zwar keine Fehlermeldungen mehr, aber das Viereck ist immer noch weiß. Liegt es am glTexImage2D?

[littletux]

Das Problem hat sich erledigt. Ich habe bei meiner OpenGl-Klasse vergessen was nachzutragen und eine Bedingung falsch aufgestellt. Jetzt funktioniert alles.