Texture manager

[Tc++H]

Ich baue mir gearde mit OGL einen Texture manager. Dabei habe ich folgende Frage:

void a()
{
   unsigned int tex;
   glGenTexture(1, &tex);
   glBindTexture(GL_TEXTURE_2D);
   gluBuildMipmap...
...
}

void b()
{
   unsigned int tex;
   glGenTexture(1, &tex);
   glBindTexture(GL_TEXTURE_2D);
   gluBuildMipmap...
...
}

was mich dabie interessiert ist, ob die Funktion b, die in einer anderen Klasse ist, die Textur aus der Klasse a überchreiben würde?

[xindon]

Ich sage nein.

Probiers doch aus

[Tc++H]

Das ist ja mein Problem, mir kommt es so vor, als würden die sich überschreiben.

[Tc++H]

Ich möchte jetzt hier aber auch keine Quellcode einfügen, dass wären dann belastende 600 Zeilen.

[Ein ehemaliger Benutzer]

gogo

[David_pb]

Hi!

Nein tut sie nicht. Kannst du ja ganz einfach an der zurückgelieferten ID erkennen.

grüße

[ChaosAngel]

unsigned int tex;

Tut sie nicht, aber du solltest dir den index nicht nur in einer lokalen Variable merken, denn sonst issa ja für imma wech wenn du die Textur wieder setzen willst.

[Tc++H]

Das Hauptproblem liegt sicher in der 200 Zeilen, es sind noch mehr Klassen, eine Image Class, eine Manager Class. --> die sind aber OK

Wenn ich jetzt zwei Texturobjekte erstelle und 2 Texturen lade und mit select auswähle selektiere, sind es die gleichen, immer die zu letzt geleadene. Die ID's sind aber richtig.
Und der Manager legt einfach immer mehr Texturobjekte an und verwalet sie, er funzt auch, aber eben nicht die TextureClass.

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

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

//*************************************************************************//
// HEADERS
//*************************************************************************//
#include <iostream>

#include "image.h"

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

//*************************************************************************//
// CLASSES
//*************************************************************************//
class texture
{
private:
	unsigned int texture_;

public:
	texture(void);
	texture(const texture& other);
	~texture(void);

	bool load	(const std::basic_string<wchar_t>& filename);
	void unload	(void);

	void select(void);

	unsigned int*	getTexture	(void);
	bool			isTexture	(void);

	// set und get Funktionen
};
}

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

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

//*************************************************************************//
//
// Datei:		texture.cpp	
// 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 <gl/glu.h>
#include "texture.h"
#include "../core/debug.h"
#include "../file/bmp.h"

#include "../tools/logsys.h"

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

//*************************************************************************//
// PUBLIC Constructor
//*************************************************************************//
texture::texture(void) : texture_(-1)
{

}

//*************************************************************************//
// PUBLIC Copy-Constructor
//*************************************************************************//
texture::texture(const texture& other) : texture_(-1)
{

}

//*************************************************************************//
// PUBLIC Destructor
//*************************************************************************//
texture::~texture(void)
{

}

//*************************************************************************//
// PUBLIC load
//*************************************************************************//
bool texture::load(const std::basic_string<wchar_t>& filename)
{
	glGetError();
	image tex;
	file::bmp bmp_;

	if(!bmp_.load(filename, &tex))
	{
		unload();

		return(false);
	}

	glGenTextures(1, &texture_);

	glBindTexture(GL_TEXTURE_2D, texture_);
	gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, tex.width_, tex.height_, GL_RGBA, GL_UNSIGNED_BYTE, &tex.rgba_[0]);

	if(glGetError() != GL_NO_ERROR)
	{
		unload();

		return(false);
	}

	tex.unload();
	return(true);
}

//*************************************************************************//
// PUBLIC unload
//*************************************************************************//
void texture::unload(void)
{
	if(glIsTexture(texture_))
	{
		glDeleteTextures(1, &texture_);
		texture_ = -1;
	}
}

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

//*************************************************************************//
// PUBLIC getTexture
//*************************************************************************//
unsigned int* texture::getTexture(void)
{
	return(&texture_);
}

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

	return(false);
}

}

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

[Tc++H]

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.

[David_pb]

Hi!

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

Was macht diese Methode? Bzw, sicher das es nicht am Texture Manager liegt?
Der Rest sieht ganz ok aus. Ich würde tatsächlich eher auf den Mgr tippen.

Übrigens: Schonmal was von der const correctness gehört?

grüße

[ChaosAngel]

Man man man, so n beschissenen Stil hab i lange net mehr gesehen...

gfx::tm().initialize();

gfx ist dein Namespace, dementsprechend ist tm wohl eine Funktion die eine Referenz auf deinen TexturManager zurückliefert ?
1. Wissen wir das nicht genau
2. Man macht sowas über Singletons <- google !

t1 = gfx::tm().load(L"wall.bmp");

1. Wir kennen auch die load Funktion deines TMs net ,
aber soviel kann ich sagen: Falls er die Textur Klasse benutzt kann das so nichts werden !
Du gibst hier einen Integer zurück (i nehme an das soll der index der Textur sein der durch glGenTextures erzeugt wurde.
Ich glaube aber nicht das es dieser Index ist !
Da deine Textur keinen Zugriff darauf bietet.

Kleiner Tip.

Lass die Load Funktion des TextureManagers ein Objekt von "Texture" zurückgeben(Klassennamen sehen übrigens besser grossgeschrieben aus )
Und die select Methode ein genau solches Objekt erwarten.
Dann könntest du dort

textureParam.select();

aufrufen.

Das ganze wäre zwar immernoch ziemlich schlechter Stil aber würde erstmal funktionieren. Falls das auch nichts bringt musst du vielleicht schon ob du nirgends die Textur wieder löschst ! Zumindest net bevor du sie nicht mehr brauchst ...
[/cpp]

[David_pb]

Hi!

Kleiner Denkanstoß:

class TextureMgr : public TSingleton< TextureMgr >
{
private:
  vector< Texture *> list;

public:
  // ...

  const Texture &add( const std::basic_string< wchar_t > &name )
  {
    if ( textureschonvorhanden??? )
      return referenzaufdeintexturobjekt

    // Bilddaten laden, aufbereiten etc...
    Image img( name ); // ...

    list.push_back( deinobjekt{ptr} );
    return referenzaufdeintexturobjekt
  }

  const Texture &find( const std::basic_string< wchar_t > &name ) const
  {
    // suchen
    return referenzaufdeintexturobjekt
  }
};

class Texture
{
private:
  dword id;

public:
  // ...

  void setActive() const
  { 
    glBindTexture( GL_TEXTURE_2D, id );
  }

  // ...
};

// ...
Texture texObj = TextureMgr::getInstance()->load( L"wall.dds" );
Texture texObj = TextureMgr::getInstance()->load( L"floor.dds" );

// ...
texObj.setActive();
// oder
texObj = TextureMgr::getInstance()->find( L"wall.dds" );
texObj.setActive();

grüße

[rapso]

diese frage wurde hier schön ofter damit gelöst, dass vorher der context gesetzt sein muss, bevor irgendwelche textures generiert werden, ansonsten stecken die sonst wo...

[Sgt. Nukem]

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...?!?

[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();
}

}

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