Get Available Space for 3D Texture

Started by
3 comments, last by V-man 16 years, 2 months ago
Hey guys, I'm trying to render a cube with a 3D texture on it and have trouble when the texturesize becomes to big. I tried a few things to figure out where the texture will be ok or not. 1) First: i figure out which maximum texture size is supported and which version of opengl i'm using.

int texSize[3];
glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE, texSize);
const GLubyte* string = glGetString(GL_VERSION);

The results are: <512, uninitialized, uninitialized> for texSize and 2.0.1 for string. I assume that this means that the maximum size is <512, 512, 512> 2) Second: i use a proxy texture to find out whether there is enough space for the texture or not

glTexImage3D(GL_PROXY_TEXTURE_3D, 0, GL_RGBA, 
             extent[0], extent[1], extent[2],
             0, GL_LUMINANCE, GL_UNSIGNED_BYTE, 0);
GLint width, height, depth;
glGetTexLevelParameteriv(GL_PROXY_TEXTURE_3D, 0, GL_TEXTURE_WIDTH, &width);
glGetTexLevelParameteriv(GL_PROXY_TEXTURE_3D, 0, GL_TEXTURE_HEIGHT, &height);
glGetTexLevelParameteriv(GL_PROXY_TEXTURE_3D, 0, GL_TEXTURE_DEPTH, &depth);

The extent i'm using is <512, 512, 267>. The width height and depth values are set according to the extent. After that i thought: Well looks good for my texture to fit into memory. 3) Third: Now i'm using Texture Objects to Bind the Texture with the following code

glBindTexture(GL_TEXTURE_3D, identifiers[textureId]);

glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

// extent[0], extent[1], extent[2],
glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 
             extent[0], extent[1], extent[2], 
             0, GL_LUMINANCE, GL_UNSIGNED_BYTE, image);
delete[] image;
glEnable(GL_TEXTURE_3D);//*/

4) Fourth: I would like to check whether the texture is now ready to use or not, and did the following:

glBindTexture(GL_TEXTURE_3D, identifiers[textureId]);
GLint residency;
glGetTexParameteriv(GL_TEXTURE_3D, GL_TEXTURE_RESIDENT, &residency);
glGetTexLevelParameteriv(GL_TEXTURE_3D, 0, GL_TEXTURE_WIDTH, &width);
glGetTexLevelParameteriv(GL_TEXTURE_3D, 0, GL_TEXTURE_HEIGHT, &height);
glGetTexLevelParameteriv(GL_TEXTURE_3D, 0, GL_TEXTURE_DEPTH, &depth);

Cause' the width, height and depth values are still equal to the extent and not 0 i thought everything is ok. So whats the problem now: When i use glTexImage3D with my extent than the window is black. When i call it like this:

glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, extent[0], extent[1], 220, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, image);

everything is ok. When i call it with 230 the window is black. So how can i find out why the window is black. Is it because the texture is to big? But why is glGetTexLevelParameteriv still returning non-zero values? looking forward to your help!!! myke
Advertisement
1) - It returns only the depth parameter actually, so the maximum 3D texture resolution in your case is x*x*512 (where x is GL_MAX_TEXTURE_SIZE, usually 2048 on today hardware)

As for proxy textures, IIRC OpenGL is talking about size (as in dimensions), not space (as in memory space, which cannot be portably determined), thus seeing that you're texture is 512x512x267xRGBA => more then 256MB, i'd say that yes, you may be running out of graphics memory.

Thanks for your reply snoutmate!
You are right, the texture is just to big. I didn't consider that, cause my texture is actually just ~68MB large, but with the internal format it becomes 4*68 which is too big. It works by changing the the glTexImage3D command to:

glTexImage3D(GL_TEXTURE_3D, 0, GL_LUMINANCE, extent[0], extent[1], extent[2], 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, image);


I'm still interested if it is possible to find out at runtime, that a texture was to big? Cause' when you have more than one objects in memory and you don't know the exact size of each of them, it would still be interesting to find out how much space is left, or at least to find out if the data (GL_ARRAY_BUFFER, GL_TEXTURE_*) was bound successfully.
For reference the value returned from glGetTexParameteriv(GL_TEXTURE_3D, GL_TEXTURE_RESIDENT, &residency); is pretty much worthless and tells you nothing on a modern system.

Quote:Original post by Myke111
I'm still interested if it is possible to find out at runtime, that a texture was to big? Cause' when you have more than one objects in memory and you don't know the exact size of each of them, it would still be interesting to find out how much space is left, or at least to find out if the data (GL_ARRAY_BUFFER, GL_TEXTURE_*) was bound successfully.


What you are doing is correct.
http://www.opengl.org/resources/faq/technical/texture.htm
shows the same method.

Perhaps your driver is buggy.
I would also call glGetError after creating the real texture to see if it returns any errors. Maybe it will return GL_OUT_OF_MEMORY.
Sig: http://glhlib.sourceforge.net
an open source GLU replacement library. Much more modern than GLU.
float matrix[16], inverse_matrix[16];
glhLoadIdentityf2(matrix);
glhTranslatef2(matrix, 0.0, 0.0, 5.0);
glhRotateAboutXf2(matrix, angleInRadians);
glhScalef2(matrix, 1.0, 1.0, -1.0);
glhQuickInvertMatrixf2(matrix, inverse_matrix);
glUniformMatrix4fv(uniformLocation1, 1, FALSE, matrix);
glUniformMatrix4fv(uniformLocation2, 1, FALSE, inverse_matrix);

This topic is closed to new replies.

Advertisement