C++: question de référence et de pointeur (exemple concernant OpenGL)

Question

Je voudrais charger des textures, puis les faire utiliser par plusieurs objets. Cela fonctionnerait-il?

class Sprite 
{ 
    GLuint* mTextures; // do I need this to also be a reference? 

    Sprite(GLuint* textures) // do I need this to also be a reference? 
    { 
     mTextures = textures; 
    } 

    void Draw(textureNumber) 
    { 
     glBindTexture(GL_TEXTURE_2D, mTextures[ textureNumber ]); 
     // drawing code 
    } 
}; 

// normally these variables would be inputed, but I did this for simplicity. 
const int NUMBER_OF_TEXTURES = 40; 
const int WHICH_TEXTURE = 10; 

void main() 
{ 
    std::vector<GLuint> the_textures; 
    the_textures.resize(NUMBER_OF_TEXTURES); 

    glGenTextures(NUMBER_OF_TEXTURES, &the_textures[0]); 

    // texture loading code 

    Sprite the_sprite(&the_textures[0]); 
    the_sprite.Draw(WHICH_TEXTURE); 
} 

Et est-il une autre façon je le faire, même si cela fonctionnerait?

Merci.

Answer 1

1. oui, ce serait travail
2. pas besoin de les faire être une référence: vous magasin/pass une copie d'un pointeur (il est rapide), et vous ne prévoyez pas de changer cette pointeur à l'extérieur
3. Il existe de nombreuses façons différentes de le faire, et la bonne dépend de vos autres exigences de code.

par exemple. vous pouvez utiliser une instance globale de textures:

textures.cpp:

static std::vector load_once_textures(); 
std::vector<GLuint> const& get_textures() 
{ 
    static std::vector<GLuint> const the_textures = load_once_textures(); 
    return the_textures; 
} 

std::vector load_once_textures() 
{ 
    // loading 
} 

textures.h

std::vector<GLuint> const& get_textures(); 

c'est une approche simple et assez sûr, car les textures seront chargés une fois et le chargement ne pose pas de problème d'ambiguïté de l'ordre d'initialisation statique

Answer 2

Ce cas particulier devrait fonctionner. Cependant, dès que "the_textures" est hors de portée, le pointeur maintenu par Sprite devient invalide. Ce serait la même chose, même si c'était une référence. Dans ce cas, je vous suggère de mettre à la place le std :: vector <> dans la classe Sprite, et de le posséder et de le gérer par cette instance de classe.

Answer 3

Je me demande pourquoi Draw ne peut pas simplement prendre une référence à l'objet qu'il dessine.

class Sprite 
{ 
public: 

    Sprite() 
    { 
    } 

    void Draw(GLuint & texture) 
    { 
     glBindTexture(GL_TEXTURE_2D, texture); 
     // drawing code 
    } 
}; 

• Sprite est un type qui ne dessin d'une manière spécifique
• GLuint est un type qui est dessiné

Il pourrait y avoir polymorphisme quelque part ici en ce que: - vous avez différents dessiner des algorithmes - il existe des méthodes polymorphes (virtuelles) dans les différents types d'objets qui sont dessinés

alors Draw pourrait b e une méthode virtuelle et GLuint peut être une classe de base abstraite, auquel cas le vecteur réel ne sera pas des objets mais des pointeurs vers différents types de l'objet. Vous devriez certainement découpler la façon dont les objets sont dessinés à partir de la façon dont les objets sont stockés, donc stocker un vecteur dans la classe de dessin, ou même passer dans un pointeur qui suppose qu'ils sont dans une sorte de tableau n'est pas susceptible d'être une bonne idée. Par ailleurs, main devrait retourner int int void.

Answer 4

Étant donné que l'ID de texture ne change pas, qu'en est-il de l'utilisation d'une valeur GLuint dans Sprite au lieu de stocker le tableau-ptr et de choisir le sprite à dessiner?

semble plus simple, et pas à vous soucier de la portée

Ceci est à moins que vous devez appeler glDeleteTextures avant app-sortie, je vous suggère de créer une classe de TextureMgr ou quelque chose qui permet de résoudre ce problème une fois pour toutes. ;)