src/graphics/grgl1texture.cpp

   1 /*
   2  * Copyright (C) Volition, Inc. 1999.  All rights reserved.
   3  *
   4  * All source code herein is the property of Volition, Inc. You may not sell
   5  * or otherwise commercially exploit the source or things you created based on
   6  * the source.
   7  */
   8
   9 #include "pstypes.h"
  10 #include "2d.h"
  11 #include "gropengl.h"
  12 #include "grgl1.h"
  13 #include "gropenglinternal.h"
  14 #include "bmpman.h"
  15 #include "grinternal.h"
  16 #include "systemvars.h"
  17 #include "osregistry.h"
  18
  19
  20 int vram_full = 0;
  21
  22 typedef struct tcache_slot_opengl {
  23         GLuint  texture_handle;
  24         float   u_scale, v_scale;
  25         int     bitmap_id;
  26         int     size;
  27         int     used_this_frame;
  28         int     time_created;
  29         ushort  w,h;
  30
  31         // sections
  32         tcache_slot_opengl      *data_sections[MAX_BMAP_SECTIONS_X][MAX_BMAP_SECTIONS_Y];
  33         tcache_slot_opengl      *parent;
  34
  35         gr_texture_source       texture_mode;
  36 } tcache_slot_opengl;
  37
  38 static void *Texture_sections = NULL;
  39 static tcache_slot_opengl *Textures = NULL;
  40
  41 static tcache_slot_opengl *GL_bound_texture;
  42
  43 static int GL_frame_count = 0;
  44 static int GL_last_bitmap_id = -1;
  45 static int GL_last_detail = -1;
  46 static int GL_last_bitmap_type = -1;
  47 static int GL_last_section_x = -1;
  48 static int GL_last_section_y = -1;
  49 static int GL_should_preload = 0;
  50
  51 extern int Gr_textures_in;
  52
  53 static gr_texture_source GL_current_texture_source = (gr_texture_source) -1;
  54
  55 static ubyte GL_xlat[256] = { 0 };
  56
  57 extern int bm_get_cache_slot( int bitmap_id, int separate_ani_frames );
  58
  59
  60 void opengl1_set_texture_state(gr_texture_source ts)
  61 {
  62         if (ts == TEXTURE_SOURCE_NONE) {
  63                 GL_bound_texture = NULL;
  64
  65                 glBindTexture(GL_TEXTURE_2D, 0);
  66                 opengl1_tcache_set(-1, -1, NULL, NULL, 0, -1, -1, 0 );
  67         } else if (GL_bound_texture &&
  68                 GL_bound_texture->texture_mode != ts) {
  69                 switch (ts) {
  70                         case TEXTURE_SOURCE_DECAL:
  71                                 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  72                                 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  73                                 break;
  74                         case TEXTURE_SOURCE_NO_FILTERING:
  75                                 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
  76                                 glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  77                                 break;
  78                         default:
  79                                 break;
  80                 }
  81
  82                 GL_bound_texture->texture_mode = ts;
  83         }
  84
  85         GL_current_texture_source = ts;
  86 }
  87
  88
  89 void opengl1_tcache_init()
  90 {
  91         int i, idx, s_idx;
  92
  93         uint tmp_pl = os_config_read_uint( NULL, NOX("PreloadTextures"), 1 );
  94
  95         if (tmp_pl == 1) {
  96                 GL_should_preload = 1;
  97         } else {
  98                 GL_should_preload = 0;
  99         }
 100
 101         Textures = (tcache_slot_opengl *)malloc(MAX_BITMAPS*sizeof(tcache_slot_opengl));
 102         if ( !Textures )        {
 103                 exit(1);
 104         }
 105
 106         if (gr_screen.use_sections) {
 107                 Texture_sections = (tcache_slot_opengl*)malloc(MAX_BITMAPS * MAX_BMAP_SECTIONS_X * MAX_BMAP_SECTIONS_Y * sizeof(tcache_slot_opengl));
 108                 if(!Texture_sections){
 109                         exit(1);
 110                 }
 111                 memset(Texture_sections, 0, MAX_BITMAPS * MAX_BMAP_SECTIONS_X * MAX_BMAP_SECTIONS_Y * sizeof(tcache_slot_opengl));
 112         }
 113
 114         // Init the texture structures
 115         int section_count = 0;
 116         for( i=0; i<MAX_BITMAPS; i++ )  {
 117                 Textures[i].texture_handle = 0;
 118
 119                 Textures[i].bitmap_id = -1;
 120                 Textures[i].size = 0;
 121                 Textures[i].used_this_frame = 0;
 122
 123                 Textures[i].parent = NULL;
 124
 125                 // allocate sections
 126                 if (gr_screen.use_sections) {
 127                         for(idx=0; idx<MAX_BMAP_SECTIONS_X; idx++){
 128                                 for(s_idx=0; s_idx<MAX_BMAP_SECTIONS_Y; s_idx++){
 129                                         Textures[i].data_sections[idx][s_idx] = &((tcache_slot_opengl*)Texture_sections)[section_count++];
 130                                         Textures[i].data_sections[idx][s_idx]->parent = &Textures[i];
 131                                         Textures[i].data_sections[idx][s_idx]->texture_handle = 0;
 132                                         Textures[i].data_sections[idx][s_idx]->bitmap_id = -1;
 133                                         Textures[i].data_sections[idx][s_idx]->size = 0;
 134                                         Textures[i].data_sections[idx][s_idx]->used_this_frame = 0;
 135                                 }
 136                         }
 137                 } else {
 138                         for(idx=0; idx<MAX_BMAP_SECTIONS_X; idx++){
 139                                 for(s_idx=0; s_idx<MAX_BMAP_SECTIONS_Y; s_idx++){
 140                                         Textures[i].data_sections[idx][s_idx] = NULL;
 141                                 }
 142                         }
 143                 }
 144         }
 145
 146         GL_last_detail = Detail.hardware_textures;
 147         GL_last_bitmap_id = -1;
 148         GL_last_bitmap_type = -1;
 149
 150         GL_last_section_x = -1;
 151         GL_last_section_y = -1;
 152 }
 153
 154 static int opengl1_free_texture ( tcache_slot_opengl *t )
 155 {
 156         int idx, s_idx;
 157
 158
 159         // Bitmap changed!!
 160         if ( t->bitmap_id > -1 )        {
 161                 // if I, or any of my children have been used this frame, bail
 162                 if(t->used_this_frame == GL_frame_count){
 163                         return 0;
 164                 }
 165
 166                 if (gr_screen.use_sections) {
 167                         for(idx=0; idx<MAX_BMAP_SECTIONS_X; idx++){
 168                                 for(s_idx=0; s_idx<MAX_BMAP_SECTIONS_Y; s_idx++){
 169                                         if((t->data_sections[idx][s_idx] != NULL) && (t->data_sections[idx][s_idx]->used_this_frame == GL_frame_count)){
 170                                                 return 0;
 171                                         }
 172                                 }
 173                         }
 174                 }
 175
 176                 // ok, now we know its legal to free everything safely
 177                 t->texture_mode = (gr_texture_source) -1;
 178                 glDeleteTextures (1, &t->texture_handle);
 179                 t->texture_handle = 0;
 180
 181                 if ( GL_last_bitmap_id == t->bitmap_id )       {
 182                         GL_last_bitmap_id = -1;
 183                 }
 184
 185                 // if this guy has children, free them too, since the children
 186                 // actually make up his size
 187                 if (gr_screen.use_sections) {
 188                         for(idx=0; idx<MAX_BMAP_SECTIONS_X; idx++){
 189                                 for(s_idx=0; s_idx<MAX_BMAP_SECTIONS_Y; s_idx++){
 190                                         if(t->data_sections[idx][s_idx] != NULL){
 191                                                 opengl1_free_texture(t->data_sections[idx][s_idx]);
 192                                         }
 193                                 }
 194                         }
 195                 }
 196
 197                 t->bitmap_id = -1;
 198                 t->used_this_frame = 0;
 199                 Gr_textures_in -= t->size;
 200                 t->size = 0;
 201         }
 202
 203         return 1;
 204 }
 205
 206 void opengl1_free_texture_with_handle(int handle)
 207 {
 208         for(int i=0; i<MAX_BITMAPS; i++ )  {
 209                 if (Textures[i].bitmap_id == handle) {
 210                         Textures[i].used_this_frame = 0; // this bmp doesn't even exist any longer...
 211                         opengl1_free_texture ( &Textures[i] );
 212                 }
 213         }
 214 }
 215
 216 void opengl1_tcache_flush()
 217 {
 218         int i;
 219
 220         for( i=0; i<MAX_BITMAPS; i++ )  {
 221                 opengl1_free_texture ( &Textures[i] );
 222         }
 223         if (Gr_textures_in != 0) {
 224                 mprintf(( "WARNING: VRAM is at %d instead of zero after flushing!\n", Gr_textures_in ));
 225                 Gr_textures_in = 0;
 226         }
 227
 228         GL_last_bitmap_id = -1;
 229         GL_last_section_x = -1;
 230         GL_last_section_y = -1;
 231 }
 232
 233 void opengl1_tcache_cleanup()
 234 {
 235         opengl1_tcache_flush ();
 236
 237         if ( Textures ) {
 238                 free(Textures);
 239                 Textures = NULL;
 240         }
 241
 242         if( Texture_sections != NULL ){
 243                 free(Texture_sections);
 244                 Texture_sections = NULL;
 245         }
 246 }
 247
 248 void opengl1_tcache_frame()
 249 {
 250         GL_last_bitmap_id = -1;
 251
 252         GL_frame_count++;
 253
 254         /*
 255         int idx, s_idx;
 256         int i;
 257         for( i=0; i<MAX_BITMAPS; i++ )  {
 258                 Textures[i].used_this_frame = 0;
 259
 260                 // data sections
 261                 if(Textures[i].data_sections[0][0] != NULL){
 262                         SDL_assert(GL_texture_sections);
 263                         if(GL_texture_sections){
 264                                 for(idx=0; idx<MAX_BMAP_SECTIONS_X; idx++){
 265                                         for(s_idx=0; s_idx<MAX_BMAP_SECTIONS_Y; s_idx++){
 266                                                 if(Textures[i].data_sections[idx][s_idx] != NULL){
 267                                                         Textures[i].data_sections[idx][s_idx]->used_this_frame = 0;
 268                                                 }
 269                                         }
 270                                 }
 271                         }
 272                 }
 273         }
 274         */
 275
 276         if ( vram_full )        {
 277                 opengl1_tcache_flush();
 278                 vram_full = 0;
 279         }
 280 }
 281
 282 static void opengl1_tcache_get_adjusted_texture_size(int w_in, int h_in, int *w_out, int *h_out)
 283 {
 284         int tex_w, tex_h;
 285         int i;
 286
 287         // bogus
 288         if((w_out == NULL) ||  (h_out == NULL)){
 289                 return;
 290         }
 291
 292         // starting size
 293         tex_w = w_in;
 294         tex_h = h_in;
 295
 296         // set height and width to a power of 2
 297         for (i=0; i<16; i++ )   {
 298                 if ( (tex_w > (1<<i)) && (tex_w <= (1<<(i+1))) )        {
 299                         tex_w = 1 << (i+1);
 300                         break;
 301                 }
 302         }
 303
 304         for (i=0; i<16; i++ )   {
 305                 if ( (tex_h > (1<<i)) && (tex_h <= (1<<(i+1))) )        {
 306                         tex_h = 1 << (i+1);
 307                         break;
 308                 }
 309         }
 310
 311         // try to keep an 8:1 size ratio
 312         if (tex_w/tex_h > 8)
 313                 tex_h = tex_w/8;
 314         if (tex_h/tex_w > 8)
 315                 tex_w = tex_h/8;
 316
 317         if ( tex_w < GL_min_texture_width ) {
 318                 tex_w = GL_min_texture_width;
 319         } else if ( tex_w > GL_max_texture_width )     {
 320                 tex_w = GL_max_texture_width;
 321         }
 322
 323         if ( tex_h < GL_min_texture_height ) {
 324                 tex_h = GL_min_texture_height;
 325         } else if ( tex_h > GL_max_texture_height )    {
 326                 tex_h = GL_max_texture_height;
 327         }
 328
 329         // store the outgoing size
 330         *w_out = tex_w;
 331         *h_out = tex_h;
 332 }
 333
 334 // data == start of bitmap data
 335 // sx == x offset into bitmap
 336 // sy == y offset into bitmap
 337 // src_w == absolute width of section on source bitmap
 338 // src_h == absolute height of section on source bitmap
 339 // bmap_w == width of source bitmap
 340 // bmap_h == height of source bitmap
 341 // tex_w == width of final texture
 342 // tex_h == height of final texture
 343 static int opengl1_create_texture_sub(int bitmap_type, int texture_handle, ushort *data, int sx, int sy, int src_w, int src_h, int bmap_w, int bmap_h, int tex_w, int tex_h, tcache_slot_opengl *t, int reload, int resize, int fail_on_full)
 344 {
 345         int ret_val = 1;
 346         int size = 0;
 347         int i, j;
 348         ubyte *bmp_data = ((ubyte*)data);
 349         ubyte *texmem = NULL, *texmemp;
 350
 351         // bogus
 352         if((t == NULL) || (bmp_data == NULL)){
 353                 return 0;
 354         }
 355
 356         if ( t->used_this_frame == GL_frame_count )       {
 357                 mprintf(( "ARGHH!!! Texture already used this frame!  Cannot free it!\n" ));
 358                 return 0;
 359         }
 360         if ( !reload )  {
 361                 // gah
 362                 if(!opengl1_free_texture(t)){
 363                         return 0;
 364                 }
 365         }
 366
 367         switch (bitmap_type) {
 368                 case TCACHE_TYPE_AABITMAP:
 369                         t->u_scale = (float)bmap_w / (float)tex_w;
 370                         t->v_scale = (float)bmap_h / (float)tex_h;
 371                         break;
 372
 373                 case TCACHE_TYPE_BITMAP_INTERFACE:
 374                 case TCACHE_TYPE_BITMAP_SECTION:
 375                         t->u_scale = (float)src_w / (float)tex_w;
 376                         t->v_scale = (float)src_h / (float)tex_h;
 377                         break;
 378
 379                 default:
 380                         t->u_scale = 1.0f;
 381                         t->v_scale = 1.0f;
 382                         break;
 383         }
 384
 385         if (!reload) {
 386                 glGenTextures (1, &t->texture_handle);
 387         }
 388
 389         if (t->texture_handle == 0) {
 390                 nprintf(("Error", "!!DEBUG!! t->texture_handle == 0"));
 391                 return 0;
 392         }
 393
 394         GL_bound_texture = t;
 395
 396         GL_bound_texture->texture_mode = (gr_texture_source) -1;
 397
 398         glBindTexture (GL_TEXTURE_2D, t->texture_handle);
 399
 400         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 401         glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 402         glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
 403
 404         /* this should be set next anyway */
 405 //      if (GL_current_texture_source != TEXTURE_SOURCE_NONE) {
 406 //              gr_opengl_set_texture_state(GL_current_texture_source);
 407 //      }
 408
 409         switch (bitmap_type) {
 410                 case TCACHE_TYPE_AABITMAP:
 411                 {
 412                         texmem = (ubyte *) malloc (tex_w*tex_h);
 413                         texmemp = texmem;
 414
 415                         for (i=0;i<tex_h;i++)
 416                         {
 417                                 for (j=0;j<tex_w;j++)
 418                                 {
 419                                         if (i < bmap_h && j < bmap_w) {
 420                                                 *texmemp++ = GL_xlat[bmp_data[i*bmap_w+j]];
 421                                         } else {
 422                                                 *texmemp++ = 0;
 423                                         }
 424                                 }
 425                         }
 426
 427                         size = tex_w*tex_h;
 428
 429                         if (!reload) {
 430                                 glTexImage2D (GL_TEXTURE_2D, 0, GL_ALPHA, tex_w, tex_h, 0, GL_ALPHA, GL_UNSIGNED_BYTE, texmem);
 431                         } else {
 432                                 glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, tex_w, tex_h, GL_ALPHA, GL_UNSIGNED_BYTE, texmem);
 433                         }
 434
 435                         free (texmem);
 436
 437                         break;
 438                 }
 439
 440                 case TCACHE_TYPE_BITMAP_INTERFACE:
 441                 case TCACHE_TYPE_BITMAP_SECTION:
 442                 {
 443                         // if we aren't resizing in any way then we can just use bmp_data directly
 444                         if ( resize ) {
 445                                 texmem = (ubyte *) malloc (tex_w*tex_h*2);
 446                                 texmemp = texmem;
 447
 448                                 for (i=0;i<tex_h;i++) {
 449                                         for (j=0;j<tex_w;j++) {
 450                                                 if (i < src_h && j < src_w) {
 451                                                         *texmemp++ = bmp_data[((i+sy)*bmap_w+(j+sx))*2+0];
 452                                                         *texmemp++ = bmp_data[((i+sy)*bmap_w+(j+sx))*2+1];
 453                                                 } else {
 454                                                         *texmemp++ = 0;
 455                                                         *texmemp++ = 0;
 456                                                 }
 457                                         }
 458                                 }
 459                         }
 460
 461                         size = tex_w*tex_h*2;
 462
 463                         if (!reload) {
 464                                 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, tex_w, tex_h, 0, GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV, (resize) ? texmem : bmp_data);
 465                         } else {
 466                                 glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, tex_w, tex_h, GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV, (resize) ? texmem : bmp_data);
 467                         }
 468
 469                         if (texmem != NULL)
 470                                 free(texmem);
 471
 472                         break;
 473                 }
 474
 475                 default:
 476                 {
 477                         // if we aren't resizing then we can just use bmp_data directly
 478                         if ( resize ) {
 479                                 texmem = (ubyte *) malloc (tex_w*tex_h*2);
 480                                 texmemp = texmem;
 481
 482                                 SDL_assert( texmem != NULL );
 483
 484                                 fix u, utmp, v, du, dv;
 485
 486                                 u = v = 0;
 487
 488                                 du = ( (bmap_w-1)*F1_0 ) / tex_w;
 489                                 dv = ( (bmap_h-1)*F1_0 ) / tex_h;
 490
 491                                 for (j=0;j<tex_h;j++) {
 492                                         utmp = u;
 493                                         for (i=0;i<tex_w;i++) {
 494                                                 *texmemp++ = bmp_data[(f2i(v)*bmap_w+f2i(utmp))*2+0];
 495                                                 *texmemp++ = bmp_data[(f2i(v)*bmap_w+f2i(utmp))*2+1];
 496                                                 utmp += du;
 497                                         }
 498                                         v += dv;
 499                                 }
 500                         }
 501
 502                         size = tex_w*tex_h*2;
 503
 504                         if (!reload) {
 505                                 glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, tex_w, tex_h, 0, GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV, (resize) ? texmem : bmp_data);
 506                         } else {
 507                                 glTexSubImage2D (GL_TEXTURE_2D, 0, 0, 0, tex_w, tex_h, GL_BGRA, GL_UNSIGNED_SHORT_1_5_5_5_REV, (resize) ? texmem : bmp_data);
 508                         }
 509
 510                         if (texmem != NULL)
 511                                 free(texmem);
 512
 513                         break;
 514                 }
 515         }
 516
 517         t->bitmap_id = texture_handle;
 518         t->time_created = GL_frame_count;
 519         t->used_this_frame = 0;
 520         t->size = size;
 521         t->w = (ushort)tex_w;
 522         t->h = (ushort)tex_h;
 523
 524         if (!reload) {
 525                 Gr_textures_in += t->size;
 526         }
 527
 528         return ret_val;
 529 }
 530
 531 static int opengl1_create_texture(int bitmap_handle, int bitmap_type, tcache_slot_opengl *tslot, int fail_on_full)
 532 {
 533         ubyte flags;
 534         bitmap *bmp;
 535         int final_w, final_h;
 536         ubyte bpp = 16;
 537         int reload = 0;
 538         int resize = 0;
 539         int cull_size = 0;
 540
 541         // setup texture/bitmap flags
 542         flags = 0;
 543         switch(bitmap_type){
 544                 case TCACHE_TYPE_AABITMAP:
 545                         flags |= BMP_AABITMAP;
 546                         bpp = 8;
 547                         break;
 548                 case TCACHE_TYPE_NORMAL:
 549                         flags |= BMP_TEX_OTHER;
 550                         cull_size = 1;
 551                         break;
 552                 case TCACHE_TYPE_BITMAP_INTERFACE:
 553                 case TCACHE_TYPE_XPARENT:
 554                         flags |= BMP_TEX_XPARENT;
 555                         break;
 556                 default:
 557                         Int3();
 558                         return 0;
 559         }
 560
 561         // lock the bitmap into the proper format
 562         bmp = bm_lock(bitmap_handle, bpp, flags);
 563         if ( bmp == NULL ) {
 564                 mprintf(("Couldn't lock bitmap %d.\n", bitmap_handle ));
 565                 return 0;
 566         }
 567
 568         int max_w = bmp->w;
 569         int max_h = bmp->h;
 570
 571         if (cull_size) {
 572                 // if we are going to cull the size then we need to force a resize
 573                 if (Detail.hardware_textures < 4) {
 574                         resize = 1;
 575
 576                         // Detail.debris_culling goes from 0 to 4.
 577                         max_w /= (16 >> Detail.hardware_textures);
 578                         max_h /= (16 >> Detail.hardware_textures);
 579                 }
 580         }
 581
 582
 583         // get final texture size as it will be allocated as a DD surface
 584         opengl1_tcache_get_adjusted_texture_size(max_w, max_h, &final_w, &final_h);
 585
 586         if ( (final_w < 1) || (final_h < 1) ) {
 587                 mprintf(("Bitmap is too small at %dx%d.\n", final_w, final_h));
 588                 return 0;
 589         }
 590
 591         // if we don't have to resize the image (to get power of 2, etc.) then skip that extra work
 592         if ( (max_w != final_w) || (max_h != final_h) ) {
 593                 resize = 1;
 594         }
 595
 596         // if this tcache slot has no bitmap
 597         if ( tslot->bitmap_id < 0) {
 598                 reload = 0;
 599         }
 600         // different bitmap altogether - determine if the new one can use the old one's slot
 601         else if (tslot->bitmap_id != bitmap_handle)     {
 602                 if((final_w == tslot->w) && (final_h == tslot->h)){
 603                         reload = 1;
 604                         //ml_printf("Reloading texture %d\n", bitmap_handle);
 605                 } else {
 606                         reload = 0;
 607                 }
 608         }
 609
 610         // call the helper
 611         int ret_val = opengl1_create_texture_sub(bitmap_type, bitmap_handle, (ushort*)bmp->data, 0, 0, bmp->w, bmp->h, bmp->w, bmp->h, final_w, final_h, tslot, reload, resize, fail_on_full);
 612
 613         // unlock the bitmap
 614         bm_unlock(bitmap_handle);
 615
 616         return ret_val;
 617 }
 618
 619 static int opengl1_create_texture_sectioned(int bitmap_handle, int bitmap_type, tcache_slot_opengl *tslot, int sx, int sy, int fail_on_full)
 620 {
 621         ubyte flags;
 622         bitmap *bmp;
 623         int final_w, final_h;
 624         int section_x, section_y;
 625         int reload = 0;
 626         int resize = 1;
 627
 628         SDL_assert( gr_screen.use_sections );
 629
 630         // setup texture/bitmap flags
 631         SDL_assert(bitmap_type == TCACHE_TYPE_BITMAP_SECTION);
 632         if(bitmap_type != TCACHE_TYPE_BITMAP_SECTION){
 633                 bitmap_type = TCACHE_TYPE_BITMAP_SECTION;
 634         }
 635         flags = BMP_TEX_XPARENT;
 636
 637         // lock the bitmap in the proper format
 638         bmp = bm_lock(bitmap_handle, 16, flags);
 639         if ( bmp == NULL ) {
 640                 mprintf(("Couldn't lock bitmap %d.\n", bitmap_handle ));
 641                 return 0;
 642         }
 643         // determine the width and height of this section
 644         bm_get_section_size(bitmap_handle, sx, sy, &section_x, &section_y);
 645
 646         // get final texture size as it will be allocated as an opengl texture
 647         opengl1_tcache_get_adjusted_texture_size(section_x, section_y, &final_w, &final_h);
 648
 649         if ( (final_w < 1) || (final_h < 1) ) {
 650                 mprintf(("Bitmap is too small at %dx%d.\n", final_w, final_h));
 651                 return 0;
 652         }
 653
 654         // if we don't have to resize the image (to get power of 2, etc.) then skip that extra work
 655         if ( (bmp->sections.num_x == 1) && (bmp->sections.num_y == 1) && (section_x == final_w) && (section_y == final_h) ) {
 656                 resize = 0;
 657         }
 658
 659         // if this tcache slot has no bitmap
 660         if ( tslot->bitmap_id < 0) {
 661                 reload = 0;
 662         }
 663         // different bitmap altogether - determine if the new one can use the old one's slot
 664         else if (tslot->bitmap_id != bitmap_handle)     {
 665                 if((final_w == tslot->w) && (final_h == tslot->h)){
 666                         reload = 1;
 667                 } else {
 668                         reload = 0;
 669                 }
 670         }
 671
 672         // call the helper
 673         int ret_val = opengl1_create_texture_sub(bitmap_type, bitmap_handle, (ushort*)bmp->data, bmp->sections.sx[sx], bmp->sections.sy[sy], section_x, section_y, bmp->w, bmp->h, final_w, final_h, tslot, reload, resize, fail_on_full);
 674
 675         // unlock the bitmap
 676         bm_unlock(bitmap_handle);
 677
 678         return ret_val;
 679 }
 680
 681 int opengl1_tcache_set(int bitmap_id, int bitmap_type, float *u_scale, float *v_scale, int fail_on_full, int sx, int sy, int force)
 682 {
 683         bitmap *bmp = NULL;
 684
 685         int idx, s_idx;
 686         int ret_val = 1;
 687
 688         if (bitmap_id < 0)
 689         {
 690                 GL_last_bitmap_id = -1;
 691                 return 0;
 692         }
 693
 694         if ( GL_last_detail != Detail.hardware_textures )      {
 695                 GL_last_detail = Detail.hardware_textures;
 696                 opengl1_tcache_flush();
 697         }
 698
 699         if (vram_full) {
 700                 return 0;
 701         }
 702
 703         int n = bm_get_cache_slot (bitmap_id, 1);
 704         tcache_slot_opengl *t = &Textures[n];
 705
 706         if ( (GL_last_bitmap_id == bitmap_id) && (GL_last_bitmap_type==bitmap_type) && (t->bitmap_id == bitmap_id) && (GL_last_section_x == sx) && (GL_last_section_y == sy))       {
 707                 t->used_this_frame = GL_frame_count;
 708
 709                 // mark all children as used
 710                 if (gr_screen.use_sections) {
 711                         for(idx=0; idx<MAX_BMAP_SECTIONS_X; idx++){
 712                                 for(s_idx=0; s_idx<MAX_BMAP_SECTIONS_Y; s_idx++){
 713                                         if(t->data_sections[idx][s_idx] != NULL){
 714                                                 t->data_sections[idx][s_idx]->used_this_frame = GL_frame_count;
 715                                         }
 716                                 }
 717                         }
 718                 }
 719
 720                 *u_scale = t->u_scale;
 721                 *v_scale = t->v_scale;
 722                 return 1;
 723         }
 724
 725         if (bitmap_type == TCACHE_TYPE_BITMAP_SECTION){
 726                 SDL_assert( gr_screen.use_sections );
 727                 SDL_assert((sx >= 0) && (sy >= 0) && (sx < MAX_BMAP_SECTIONS_X) && (sy < MAX_BMAP_SECTIONS_Y));
 728                 if(!((sx >= 0) && (sy >= 0) && (sx < MAX_BMAP_SECTIONS_X) && (sy < MAX_BMAP_SECTIONS_Y))){
 729                         return 0;
 730                 }
 731
 732                 ret_val = 1;
 733
 734                 // if the texture sections haven't been created yet
 735                 if((t->bitmap_id < 0) || (t->bitmap_id != bitmap_id)){
 736
 737                         // lock the bitmap in the proper format
 738                         bmp = bm_lock(bitmap_id, 16, BMP_TEX_XPARENT);
 739                         bm_unlock(bitmap_id);
 740
 741                         // now lets do something for each texture
 742
 743                         for(idx=0; idx<bmp->sections.num_x; idx++){
 744                                 for(s_idx=0; s_idx<bmp->sections.num_y; s_idx++){
 745                                         // hmm. i'd rather we didn't have to do it this way...
 746                                         if(!opengl1_create_texture_sectioned(bitmap_id, bitmap_type, t->data_sections[idx][s_idx], idx, s_idx, fail_on_full)){
 747                                                 ret_val = 0;
 748                                         }
 749
 750                                         // not used this frame
 751                                         t->data_sections[idx][s_idx]->used_this_frame = 0;
 752                                 }
 753                         }
 754
 755                         // zero out pretty much everything in the parent struct since he's just the root
 756                         t->bitmap_id = bitmap_id;
 757                         t->texture_handle = 0;
 758                         t->time_created = t->data_sections[sx][sy]->time_created;
 759                         t->used_this_frame = 0;
 760                 }
 761
 762                 // argh. we failed to upload. free anything we can
 763                 if(!ret_val){
 764                         opengl1_free_texture(t);
 765                 }
 766                 // swap in the texture we want
 767                 else {
 768                         t = t->data_sections[sx][sy];
 769                 }
 770         }
 771         // all other "normal" textures
 772         else if((bitmap_id < 0) || (bitmap_id != t->bitmap_id)){
 773                 ret_val = opengl1_create_texture( bitmap_id, bitmap_type, t, fail_on_full );
 774         }
 775
 776         // everything went ok
 777         if(ret_val && (t->texture_handle) && !vram_full){
 778                 *u_scale = t->u_scale;
 779                 *v_scale = t->v_scale;
 780
 781                 GL_bound_texture = t;
 782
 783                 glBindTexture (GL_TEXTURE_2D, t->texture_handle );
 784
 785                 /* this should be set next anyway */
 786 //              if (GL_current_texture_source != TEXTURE_SOURCE_NONE) {
 787 //                      gr_opengl_set_texture_state(GL_current_texture_source);
 788 //              }
 789
 790                 GL_last_bitmap_id = t->bitmap_id;
 791                 GL_last_bitmap_type = bitmap_type;
 792                 GL_last_section_x = sx;
 793                 GL_last_section_y = sy;
 794
 795                 t->used_this_frame = GL_frame_count;
 796         }
 797         // gah
 798         else {
 799                 GL_last_bitmap_id = -1;
 800                 GL_last_bitmap_type = -1;
 801
 802                 GL_last_section_x = -1;
 803                 GL_last_section_y = -1;
 804
 805                 GL_bound_texture = NULL;
 806
 807                 glBindTexture (GL_TEXTURE_2D, 0);       // test - DDOI
 808                 return 0;
 809         }
 810
 811         return 1;
 812 }
 813
 814 void gr_opengl1_preload_init()
 815 {
 816 //      if (gr_screen.mode != GR_OPENGL) {
 817 //              return;
 818 //      }
 819
 820         opengl1_tcache_flush();
 821 }
 822
 823 int gr_opengl1_preload(int bitmap_num, int is_aabitmap)
 824 {
 825 //      if ( gr_screen.mode != GR_OPENGL) {
 826 //              return 0;
 827 //      }
 828
 829         if ( !GL_should_preload )      {
 830                 return 0;
 831         }
 832
 833         float u_scale, v_scale;
 834         int retval;
 835         int bitmap_type = TCACHE_TYPE_NORMAL;
 836
 837         if ( is_aabitmap )      {
 838                 bitmap_type = TCACHE_TYPE_AABITMAP;
 839         }
 840
 841         retval = opengl1_tcache_set(bitmap_num, bitmap_type, &u_scale, &v_scale, 1, -1, -1, 0 );
 842
 843         if ( !retval )  {
 844                 mprintf(("Texture upload failed!\n" ));
 845         }
 846
 847         return retval;
 848 }
 849
 850 void gr_opengl1_set_gamma(float gamma)
 851 {
 852         Gr_gamma = gamma;
 853         Gr_gamma_int = int (Gr_gamma*10);
 854
 855         // Create the Gamma lookup table
 856         int i;
 857         for (i=0;i<256; i++) {
 858                 int v = fl2i(pow(i2fl(i)/255.0f, 1.0f/Gr_gamma)*255.0f);
 859                 if ( v > 255 ) {
 860                         v = 255;
 861                 } else if ( v < 0 )     {
 862                         v = 0;
 863                 }
 864                 Gr_gamma_lookup[i] = v;
 865         }
 866
 867         // set the alpha gamma settings (for fonts)
 868         for (i=0; i<16; i++) {
 869                 GL_xlat[i] = (ubyte)Gr_gamma_lookup[(i*255)/15];
 870         }
 871
 872         GL_xlat[15] = GL_xlat[1];
 873
 874         for (; i<256; i++) {
 875                 GL_xlat[i] = GL_xlat[0];
 876         }
 877
 878         // Flush any existing textures
 879         opengl1_tcache_flush();
 880 }