Question

I would like to load textures, and then have them be used by multiple objects. Would this work?

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

And is there a different way I should do this, even if it would work?

Thanks.

Answer 1

1. yes, this would work
2. no need to make them be a reference: you store/pass a copy of a pointer (it’s fast), and you don’t plan to change this pointer outside
3. there’re many different ways to do this, and the right one depends on your other code requirements.

e.g. you can use a global instance of 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();

it’s a simple approach and safe enough because textures will be loaded once and loading doesn’t have a problem of static initialization order ambiguity