Breaking big texture into 256x256 textures


As far as I know, maximum texture dimension supported by gfx cards can be vary. I use Vodoo3 and I see that the highest dimension that I can use to maintain its quality is 256x256. Bigger than that, it become blur.

So each time I create a project which has a fullscreen background image, I break my background’s texture into 256x256 manually using Paint Brush. Then I paste them on several quards and rearrange them. By using this way, I can get a “wallpaper” quality.

Is there any other better way?

yep there is another way, i’ve done it, but its not as easy like your verion (but works for all texture-sizes). The problem for you is, that i dont publicate this source, but here is a sheme of the algo: get maxtexsize
2. calc:
tilesx= image_x+1 /maxtexsize
tilesy= image_y+1 /maxtexsize
calc much other stuff (related to texcoords, vertexcoords)
3. now you gen tilesxtilesy times a texture of maxtexsizemaxtexsize and use for each of them seperate texcoord, vertexcoords (i prefer the range from 0 to 1) the clue is that you have to handle the last row/col seperate, it gets different texcoords …

now you maybe have an idea of how it works, but in real life its more complicated. think of that:
you have an image 100100 and a max texsize of 6464 now your algo should produce 4 textures with vertexes and texcoords. all together producing a texture which lay on a playne between (o,o) and (1,1) and it is not that easy that you can split at half the length (or you want to waste memory)…

and dont forget: to map this texture on an object you will have to split the object at the texture-edges…

but there is another way, an extension (which i dont know anymore) makes all this stuff for you…

Hi, thanks for that. But I’m not that good to manipulate your idea. I’m still in a “beginer” category. So that idea won’t help me much.

I just know how to load a texture (which I grab from somebody tutorial). I don’t know how to take a portion of it and pass it into glGenTexture.

Let say I found the array that hold the pixels value and I know the texture actual dimension, what should I do with it? This is the most important part for me.

Please give me more tips. Or can I have your codes so I can use it without any modifying?

But I think I can make the coordinate and vertex part.

my code won’t help you, but hmm here is it(i’ve decided that you can have this part of my code :slight_smile: but not more, so try to understand), and dont try to copy simple to your app, it won’t work(you need some struct/the class IMAGE …):

void IMAGE::GenImages(){
unsigned long max_texture_size= GetTextureSize();

_glImage_Columns= width/max_texture_size +1;
_glImage_Rows= height/max_texture_size +1;

unsigned long flag_new_texture= !glimages;
glimages= new _glImage[_glImage_Columns * _glImage_Rows];

unsigned long partimagesize= max_texture_size* datacomponents;
partimagesize+= partimagesize%4;
unsigned char partimage= new unsigned char [partimagesizemax_texture_size];

_glImage *ptr= glimages;
for(unsigned long i= _glImage_Columns;i-- :wink:
for(unsigned long j= _glImage_Rows;j-- ;){
glGenTextures(1, &ptr->id);
glBindTexture(GL_TEXTURE_2D, ptr->id);

  	unsigned long	partimage_left= (_glImage_Columns-i-1) * max_texture_size * datacomponents,
  					partimage_top= (_glImage_Rows-j-1) * max_texture_size,
  					partimage_width= max_texture_size * datacomponents,
  					partimage_height= max_texture_size;

  	float tmp= (2.0f/width*max_texture_size);
  	if(tmp > 2.0f) tmp= 2.0f;
  	ptr->image_coords.left= -1.0f + tmp*(_glImage_Columns-i-1);
  		ptr->image_coords.right= ptr->image_coords.left + tmp;
  		partimage_width= width *datacomponents - (_glImage_Columns -1) * partimage_width;
  		ptr->texture_coords.right= 1.0f/max_texture_size*(width-max_texture_size*(_glImage_Columns-1));
  		ptr->image_coords.right= 1;

  	tmp= (2.0f/height*max_texture_size);
  	if(tmp > 2.0f) tmp= 2.0f;
  	ptr-> 1.0f - tmp*(_glImage_Rows-j-1);
  		ptr->image_coords.bottom= ptr-> - tmp;
  		partimage_height= height - (_glImage_Rows -1) * partimage_height;
  		ptr->texture_coords.bottom= 1.0f/max_texture_size*(height-max_texture_size*(_glImage_Rows-1));
  		ptr->image_coords.bottom= -1;

  	unsigned long	src_lineoffset= width*datacomponents;
  	src_lineoffset+= src_lineoffset%4;
  	unsigned char	*src= data + (partimage_top * src_lineoffset) + partimage_left,
  					*dest= partimage;
  	unsigned long tmp2;
  	for(unsigned long k= partimage_height; k-- ;){
  		memcpy(dest, src, partimage_width);
  		tmp2= partimagesize-partimage_width;
  			memset(dest+ partimage_width, 0, tmp2);
  		dest+= partimagesize;
  		src+= src_lineoffset;
  	tmp2= (max_texture_size-partimage_height)*partimagesize;
  		memset(dest, 0, tmp2 );

  		glTexImage2D(GL_TEXTURE_2D, 0, datacomponents, max_texture_size, max_texture_size, 0, (datacomponents == 4 ? GL_RGBA : GL_RGB), GL_UNSIGNED_BYTE, partimage);
  		glTexSubImage2D(GL_TEXTURE_2D, 0, 0,0, max_texture_size, max_texture_size, (datacomponents == 4 ? GL_RGBA : GL_RGB), GL_UNSIGNED_BYTE, partimage);



[This message has been edited by T2k (edited 03-01-2002).]

Thank you very much! I’ll try my best!