4. Texture manager

Texture manager

  • S

    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... 😉

    0
  • T

    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.

    0
  • S

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

    0
  • T

    t1 = 0
    t1 = 2
    t3 = 3

    0
  • T

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

    0
  • X
     

    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.

    0
  • T

    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?

    0
  • X

    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.

    0
  • T

    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.

    0
  • X

    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 😛

    0
  • T

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

    mfg

    0
  • X

    textures_[tex].select();

    Poste mal die select() Methode

    0
  • T

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

    0
  • T

    elbst, wenn ich das: glBindTexture(GL_TEXTURE_2D, 1);
    aufrufe(vor meiner zu texturierenden Fläche) tritt das Prob wieder auf...

    0
  • X

    Also textures_[] ist ein Array mit Instanzen der Klasse texture. Und jede Instanz hat ihre eigene TextureID texture_ ...nagut.
    Dann müsste das eigentlich stimmen.

    Dann nochmal meine Frage:
    Was genau ist das Problem? Es wird immer die zuletzt generierte Textur benutzt?
    Also die, die als letztes aus einem bitmap geladen wurde?

    0
  • T

    Ich kann selektieren, was ich will, es kommt immer wieder die letzte und ich sitze schon ne Woche an dem Prob.

    Ich schalge mal vor, dass wir lieber ICQ benutzten sollten, statt das Forum zu zu spamen *g*.

    mfg

    0
  • X

    gib nummer

    0
  • T

    232-825-830

    0
  • T

    Ich habe jetzt nochmal einen kleinen manager geschrieben und das gleiche Problem...
    ABER WARUM??????

    //*************************************************************************//
//
// Datei:		textureManager.cpp	
// Autor:		TcH
// Erstellt:	10.03.2006
// Geändert:	10.03.2006
//
//*************************************************************************//

//*************************************************************************//
// HEADERS
//*************************************************************************//
#include "textureManager.h"
#include "image.h"
#include "../file/bmp.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)
{
	shutdown();
	textures_ = new(unsigned int[maxTextures]);
}

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

//*************************************************************************//
// PUBLIC shutdown
//*************************************************************************//
void textureManager::shutdown(void)
{
	if(textures_)
	{
		for(unsigned int i = 0; i < maxTextures; i ++)
			glDeleteTextures(1, &textures_[i]);

		delete[](textures_);
	}

}

//*************************************************************************//
// PUBLIC getFreeSpace
//*************************************************************************//
unsigned int textureManager::getFreeSpace(void)
{
	if(textures_)
	{
		for(unsigned int i = 0; i < maxTextures; i ++)
			if(!glIsTexture(textures_[i]))
				return(i);
	}

	return(-1);	
}

//*************************************************************************//
// PUBLIC load
//*************************************************************************//
unsigned int textureManager::load(const std::basic_string<wchar_t>& filename)
{
	if(textures_)
	{
		image			tex;
		file::bmp		bmp_;
		unsigned int	ID;

		if(!bmp_.load(filename, &tex))
		{
			return(-1);
		}

		textures_[ID] = ID = getFreeSpace();
		uty::log().write(L"load: %s ID: %u", filename.c_str(), textures_[ID]);

		glGetError();
		glGenTextures(1, &textures_[ID]);
		glBindTexture(GL_TEXTURE_2D, textures_[ID]);
		gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGBA, tex.width_, tex.height_,
						  GL_RGBA, GL_UNSIGNED_BYTE, &tex.rgba_[0]);

		tex.unload();
		if(glGetError() != GL_NO_ERROR)
		{
			unload(textures_[ID]);

			return(-1);
		}

		return(textures_[ID]);
	}

	return(-1);
}

//*************************************************************************//
// PUBLIC unload
//*************************************************************************//
void textureManager::unload(unsigned int texture)
{
	if((texture >= 0) && (texture < maxTextures) && (textures_))
	{
		if(glIsTexture(textures_[texture]))
			glDeleteTextures(1, &textures_[texture]);
	}

}

//*************************************************************************//
// PUBLIC select
//*************************************************************************//
void textureManager::select(unsigned int texture)
{
	if((texture >= 0) && (texture < maxTextures) && (textures_))
	{
		if(glIsTexture(textures_[texture]))
			glBindTexture(GL_TEXTURE_2D, textures_[texture]);
	}
}

}

//*************************************************************************//
    0
  • T

    Kann das Prob. möglicherweise an den OpenGL Libs bzw. Treibrn liegen? ich habe mal meinen alten Texturenloader gestestet, der früher ging, aber nu tritt das gleiche Problem auf....

    0
Anmelden zum Antworten