Texture manager

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

}

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

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