Texture manager

[rapso]

Sgt. Nukem schrieb:

rapso schrieb:

dass vorher der context gesetzt sein muss, bevor irgendwelche textures generiert werden, ansonsten stecken die sonst wo...

Eigentlich muß doch für so ziemlich alles der Context vorher gesetzt sein, oder nicht...?!?

such dir einfach die threads dazu ;)... gibt leute die das beim starten vor dem contextsetzen irgendwo im c-tor schon machen und dann gibt es natürlich die IDs für die textures nicht und es passiert void... ist natürlich nur reine vermutung von mir in diesem fall

[David_pb]

Hi!

Sagte er nicht das eine Textur immer angezeigt wird? Ohne Rendercontext würde nichts angezeigt, rein garnüschts!!!

grüße

[Tc++H]

Der manager ist ein Singleton, ich habe nut tm verwendet, um die schreibarbeit zu sparen.

...
public:
	friend static textureManager& tm(void);
};

static textureManager& tm(void)
{
	return(textureManager::getInst());
}
...

[Tc++H]

OpenGL wurde schon vorher initialisiert.

[David_pb]

Hi!

Das erklährt trozdem nich den Fehler. Also, zeigst du uns den Code des Mgr's oder nich?

grüße

[Tc++H]

Ich habe ihn erstma statisch programmiert, ohne vector.

//*************************************************************************//
//
// Datei:		textureManager.h	
// Autor:		TcH
// Erstellt:	23.02.2006
// Geändert:	23.02.2006
//
//*************************************************************************//

//*************************************************************************//
// INCLUDE GUARD
//*************************************************************************//
#if !defined(__gfx_textureManager_h__)
#define __gfx_textureManager_h__
//*************************************************************************//

//*************************************************************************//
// HEADERS
//*************************************************************************//
#include <iostream>
#include "texture.h"

//*************************************************************************//
// NAMESPACE
//*************************************************************************//
namespace gfx
{

const static unsigned long maxTextures	= 128;

}

//*************************************************************************//
// NAMESPACE
//*************************************************************************//
namespace gfx
{

//*************************************************************************//
// CLASSES
//*************************************************************************//
class textureManager
{
private:
	texture* textures_;

private:
	textureManager(void);
	textureManager(const textureManager& other);
	~textureManager(void);

public:
	inline static textureManager& getInst(void)
	{
		static textureManager instance;

		return(instance);
	}
	void initialize(void);
	void restore(void);
	void shutdown(void);

	unsigned int getFreeSpace(void);
	unsigned int load(const std::basic_string<wchar_t>& filename);
	void unload(unsigned int tex);
	void select(unsigned int tex);

public:
	friend static textureManager& tm(void);
};

//*************************************************************************//
// FUNCTIONS
//*************************************************************************//
static textureManager& tm(void)
{
	return(textureManager::getInst());
}

}
//*************************************************************************//
// INCLUDE GUARD
//*************************************************************************//
#endif

//*************************************************************************//

//*************************************************************************//
//
// Datei:		textureManager.h	
// Autor:		TcH
// Erstellt:	03.03.2006
// Geändert:	03.03.2006
//
//*************************************************************************//

//*************************************************************************//
// HEADERS
//*************************************************************************//
#define WIN32_LEAN_AND_MEAN
#define WIN32_EXTRA_LEAN
#include <windows.h>
#include <gl/GL.h>

#include "textureManager.h"
#include "../core/debug.h"
#include "../utility/logsys.h"

//*************************************************************************//
// NAMESPACE
//*************************************************************************//
namespace gfx
{

//*************************************************************************//
// PRIVATE Constructor
//*************************************************************************//
textureManager::textureManager(void) : textures_(0)
{

}

//*************************************************************************//
// PRIVATE Copy-Constructor
//*************************************************************************//
textureManager::textureManager(const textureManager& other) : textures_(0)
{

}

//*************************************************************************//
// PRIVATE Destructor
//*************************************************************************//
textureManager::~textureManager(void)
{

}

//*************************************************************************//
// PUBLIC initialize
//*************************************************************************//
void textureManager::initialize(void)
{
	textures_ = new(texture[maxTextures]);
}

//*************************************************************************//
// PUBLIC restore
//*************************************************************************//
void textureManager::restore(void)
{
	shutdown();
	initialize();
}

//*************************************************************************//
// PUBLIC shutdown
//*************************************************************************//
void textureManager::shutdown(void)
{
	if(!textures_)
		return;

	for(int i = 0; i < maxTextures; i ++)
		unload(i);

	delete[](textures_);
	textures_ = 0;
}

//*************************************************************************//
// PUBLIC getFreeSpace
//*************************************************************************//
unsigned int textureManager::getFreeSpace(void)
{
	DEBUG_STACK;

	if(!textures_)
		return(-1);

	for(unsigned int i = 0; i < maxTextures; i ++)
		if(!textures_[i].isTexture())
			return(i);

	return(-1);
}

//*************************************************************************//
// PUBLIC load
//*************************************************************************//
unsigned int textureManager::load(const std::basic_string<wchar_t>& filename)
{	
	if(!textures_)
		return(-1);

	unsigned int i = getFreeSpace();
	uty::log().write(L"Texture: %s, ID: %u", filename.c_str(), i);

	if(textures_[i].load(i, filename))
		return(i);

	return(-1);
}

//*************************************************************************//
// PUBLIC unload
//*************************************************************************//
void textureManager::unload(unsigned int tex)
{
	if(!textures_)
		return;

	if((tex >= 0) && (tex < maxTextures))
		textures_[tex].unload();
}

//*************************************************************************//
// PUBLIC select
//*************************************************************************//
void textureManager::select(unsigned int tex)
{
	if(!textures_)
		return;

	if((tex >= 0) && (tex < maxTextures))
		textures_[tex].select();
}

}

//*************************************************************************//

[Tc++H]

Was ich noch sagen möchte: Ich habe mir den Texturemanager voll aus dem Kopf gezogen, ohne irgendeine Hilfe und bin auch erst 10te Klasse. --> also habe keine übermässigen Erfahrungen.

Aber Wie gesagt: es wird immer die zu letzt geladene Textur angezeigt.

[Sgt. Nukem]

Tc++H schrieb:

unsigned int t1, t1, t3;

gfx::tm().initialize();
t1 = gfx::tm().load(L"wall.bmp");
t2 = gfx::tm().load(L"salpeter.bmp");
t3 = gfx::tm().load(L"rock.bmp");

glBegin...
gfx::tm().select(t2);
glEnd...

--> Zeigt aber Textur 3, oder wenn ich t1 auswähle, zeigt es auch die 3.

Hast Du vielleicht zuerst mal t1 - t3 auf Dein -1 (FEHLER) geprüft?!?

Tc++H schrieb:

bool texture::load(const std::basic_string<wchar_t>& filename)

texture::load() hat also Signatur "bool (string)"

Im Mgr rufst Du es aber

Tc++H schrieb:

[cpp]unsigned int textureManager::load(const std::basic_string<wchar_t>& filename)
{
if(!textures_)
return(-1);

unsigned int i = getFreeSpace();
uty::log().write(L"Texture: %s, ID: %u", filename.c_str(), i);

if(textures_[i].load(i, filename))
return(i);

return(-1);
}[/cpp]

"bool (int, string)"-mässig auf...

Desweiteren:

Tc++H schrieb:

//*************************************************************************//
// PUBLIC isTexture
//*************************************************************************//
bool texture::isTexture(void)
{
	if(glIsTexture(texture_))
		return(true);

	return(false);
}

Nach dem Ctor steht texture_ auf 0. Kannst Du sicher sein, daß GL nicht die 0 auch als Namen (Handle) für 'ne Textur verwendet?!

(In dem Fall wär' aber nach dem Laden der ersten Textur wohl das Array "voll".)

Aber ich hab' Deinen Code auch nicht so richtig geblickt, also null Garantie...

[Tc++H]

Also die loadfunktion gibt die richtigen IDs zurück.

Ich habe mir beim Prinzip des Managers folgendes gedacht:

der manager enthält 128 Texturelemente. und über die Funktion load des managers wird die loadfunktion der texture aufgerufen, da texture privat ist. die load Funktion gibt dem manager einen Boolschen Wert zurück, ob die Textur geladen werden konnte. Falls ja, dann gibt der Manager die ID zurück.

[Sgt. Nukem]

Wie sind denn die "unsigned int"-Werte, die OpenGL Dir als Texture IDs zurückgibt?!

[Tc++H]

t1 = 0
t1 = 2
t3 = 3

[Tc++H]

Das Problem ist halt, dass die Textureclass nicht mal funktioniert, aber keine Ahnung, warum.

[xindon]

unsigned int t1, t1, t3;

gfx::tm().initialize();
t1 = gfx::tm().load(L"wall.bmp");
t2 = gfx::tm().load(L"salpeter.bmp");
t3 = gfx::tm().load(L"rock.bmp");

glBegin...
gfx::tm().select(t2);
glEnd...

Ich finde den Aufbau nicht so schön. Es soll ja ein Manager sein, der dir deine Arbeit erleichtert und übersichtlicher macht.

Ich würde es so machen:

In Init:
TextureManager.LoadTexture("rock", "data/images/rock123.bmp");

Beim Zeichnen rufst du dann auf:
TextureManager.Use("rock");

Oder so ähnlich halt, aber das Prinzip sollte klar sein. Finde ich übersichtlicher und sieht schöner aus.
Ist vielleicht nicht so performant wie ein Integer, aber relevante Änderungen an der Performanceschraube kann man bestimmt an anderer Stelle besser tun.

[Tc++H]

Ja, das hatte ich mir auch schon gedacht, aber erstmal muss er ja mal funktionieren.

Gibt es bei VC++ 2005 einen Unterschied zw. GLuint und unsigned int?

[xindon]

Tc++H schrieb:

Gibt es bei VC++ 2005 einen Unterschied zw. GLuint und unsigned int?

Fahr mit der Maus einfach drüber oder mach rechte Maustaste auf GLuint und dann Zur Definition springen, dann siehst du es

Und ich würde sogar den Texturemanager einfach nochmal neu schreiben, und zwar auf die andere Variante wie ich es gerade gesagt habe (was du ja anscheinend auch so wolltest). Ist ja keine große Sache. Vielleicht wars einfach nur ein Denkfehler und die sind manchmal verdammt schwer zu finden Wenn dus neu machst, und du *nichts* kopierst/abschreibst, verschwinden so unbeabsichtigte Fehler meistens.

Es sei denn, du willst ihn unbedingt finden.

[Tc++H]

Das ist schon mein zweiter versuch, ich hatte den manager erst andwers gemacht, ohne textureclass, nur ein arry in dem Manager mit den IDs und es klappte trotzdem nicht, der gleiche Fehler.

[xindon]

Ist es eventuell auch ein Fehler bezüglich der Funktionalität von OpenGL ?

Du sagst, es wird immer die zuletzte geladene Textur angezeigt?

Ich nehme mal an, du hast dich an den NeHe Codes zum Laden von bmps orientiert.
Und da erstellst du bei jedem Laden eines BMPs eine Texture und bindest diese in GL.

Könnte es jetzt sein, dass du in deiner Methode des TextureManagers zum Wählen der Textur, die Textur gar nicht bindest? So bleibt nämlich immer die zuletzt geladene Textur gebindet.

Hört sich doof an, könnt ja aber sein

[Tc++H]

Ich habe NULL von NWHE übernommen.
und gfx::tm().select(t2);??

mfg

[xindon]

textures_[tex].select();

Poste mal die select() Methode

[Tc++H]

void texture::select(void)
{
glBindTexture(GL_TEXTURE_2D, texture_);
}