How to use TextureArray's Pre-OpenGL 4.2?

Question

I've been using TextureArray's in my current Project; However, I have come to the problem of OpenGL 4.2 functions not being on the present Mac software when ported over. Due to only version 4.1 of OpenGL being supported.

All my problems stem from the single function. glTexStorage3D which is the only function not supported.

This is how it currently works on my OpenGL 4.2 capable machine. (and works wonderfully I might add.)

1.) I allocate the memory beforehand with glTexStorage3D.

glGenTextures(1, &_texture);
glBindTexture(GL_TEXTURE_2D_ARRAY, _texture);
glTexStorage3D(GL_TEXTURE_2D_ARRAY, 255, GL_RGBA8, 16, 16, _maxLayerCount);

2.) Then per image I would load it into the before allocated memory block with the following.

glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, _layerCount, 16, 16, 1, GL_RGBA, GL_UNSIGNED_BYTE, image.getPixelsPtr());

3.) Success.

How would I go about mimicking this functionality pre OpenGL 4.2 without using Immutable Storage? Aka (glTexStorage3D).

I've tried stuffing all my images into a horizontal single image and then loading that into just glTexImage3D with no success. Am I missing something?

Additional Note: I prefer to use TextureArray's for my project in order to avoid rendering artifacts I had using a TextureAtlas. It's simplicity during shaders is also a big plus.

Answer 1

Without immutable storage you can just specify a texture array using glTexImage3D.

I note that you say you've tried this but it didn't work; it would have been helpful if you had given us the code that didn't work, as you clearly have an error in it which we may have been able to help you with.

That aside, there is another way which is minimally invasive and will work for you with just a single line of code changed; from:

glTexStorage3D(GL_TEXTURE_2D_ARRAY, 255, GL_RGBA8, 16, 16, _maxLayerCount);

To:

glTexImage3D (GL_TEXTURE_2D_ARRAY, 0, GL_RGBA8, 16, 16,
    _maxLayerCount, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);

Like glTexStorage3D, glTexImage3D with a NULL data pointer will reserve storage for the texture, but in this case without the constraint that the texture be immutable (you'll also need to make an additional glTexImage3D call for each submip if you want to mipmap the texture).

From the documentation:

data may be a null pointer. In this case texture memory is allocated to accommodate a texture of width width, height height, and depth depth. You can then download subtextures to initialize this texture memory.

Once you have that done you can just load the individual array slices using glTexSubImage3D in exactly the same way as you are doing so now.

Answer 2

Texture arrays have been part of the OpenGL core context for as long as there's been a core context; ever since OpenGL 3.0. Pretty much every desktop computer sold within the last six years will support OpenGL 3.0 or later. Ultra-mobility laptops more than three years old might be problematic, but anything more recent or more beefy than that should be completely fine. So there's how you support it under OpenGL pre-4.2; do exactly what you're already doing, as long as you have 3.0 or later.

You only need to think about alternate implementations if you're trying to support OpenGL 2.1. But even in 2.1, texture arrays were available in many drivers as an extension, so few changes might be required to your texture handling: EXT_texture_array.

But honestly, the differences in the rendering pipeline between OpenGL 4.x and OpenGL 2.1 are huge -- texture arrays will be the least of your problems if you're really trying to support both in a single program. Probably better off picking one or the other, and running with it.