implement BM_FLAG_RLE_BIG (cockpit support?)
authorBradley Bell <btb@icculus.org>
Sat, 17 Aug 2002 11:19:56 +0000 (11:19 +0000)
committerBradley Bell <btb@icculus.org>
Sat, 17 Aug 2002 11:19:56 +0000 (11:19 +0000)
2d/bitblt.c
2d/rle.c
arch/ogl/ogl.c

index 2847acc..5a54d34 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: bitblt.c,v 1.5 2002-07-17 21:55:19 bradleyb Exp $ */
+/* $Id: bitblt.c,v 1.6 2002-08-17 11:19:56 btb Exp $ */
 /*
 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
@@ -21,6 +21,7 @@ COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
 #include "gr.h"
 #include "grdef.h"
 #include "rle.h"
+#include "byteswap.h"   // because of rle code that has short for row offsets
 #include "error.h"
 
 #ifdef OGL
@@ -835,19 +836,26 @@ void gr_bm_ubitblt00_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitma
 {
        unsigned char * dbits;
        unsigned char * sbits;
+       int i, data_offset;
 
-       int i;
+       data_offset = 1;
+       if (src->bm_flags & BM_FLAG_RLE_BIG)
+               data_offset = 2;
+
+       sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
 
-       sbits = &src->bm_data[4 + src->bm_h];
        for (i=0; i<sy; i++ )
-               sbits += (int)src->bm_data[4+i];
+               sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
 
        dbits = dest->bm_data + (dest->bm_rowsize * dy) + dx;
 
        // No interlacing, copy the whole buffer.
        for (i=0; i < h; i++ )    {
                gr_rle_expand_scanline( dbits, sbits, sx, sx+w-1 );
-               sbits += (int)src->bm_data[4+i+sy];
+               if ( src->bm_flags & BM_FLAG_RLE_BIG )
+                       sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((i+sy)*data_offset)])));
+               else
+                       sbits += (int)(src->bm_data[4+i+sy]);
                dbits += dest->bm_rowsize << gr_bitblt_dest_step_shift;
        }
 }
@@ -856,19 +864,25 @@ void gr_bm_ubitblt00m_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitm
 {
        unsigned char * dbits;
        unsigned char * sbits;
+       int i, data_offset;
 
-       int i;
+       data_offset = 1;
+       if (src->bm_flags & BM_FLAG_RLE_BIG)
+               data_offset = 2;
 
-       sbits = &src->bm_data[4 + src->bm_h];
+       sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
        for (i=0; i<sy; i++ )
-               sbits += (int)src->bm_data[4+i];
+               sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
 
        dbits = dest->bm_data + (dest->bm_rowsize * dy) + dx;
 
        // No interlacing, copy the whole buffer.
        for (i=0; i < h; i++ )    {
                gr_rle_expand_scanline_masked( dbits, sbits, sx, sx+w-1 );
-               sbits += (int)src->bm_data[4+i+sy];
+               if ( src->bm_flags & BM_FLAG_RLE_BIG )
+                       sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((i+sy)*data_offset)])));
+               else
+                       sbits += (int)(src->bm_data[4+i+sy]);
                dbits += dest->bm_rowsize << gr_bitblt_dest_step_shift;
        }
 }
@@ -882,18 +896,24 @@ extern void gr_rle_expand_scanline_generic( grs_bitmap * dest, int dx, int dy, u
 void gr_bm_ubitblt0x_rle(int w, int h, int dx, int dy, int sx, int sy, grs_bitmap * src, 
        grs_bitmap * dest, int masked )
 {
-       int i;
+       int i, data_offset;
        register int y1;
        unsigned char * sbits;
 
-       sbits = &src->bm_data[4 + src->bm_h];
+       data_offset = 1;
+       if (src->bm_flags & BM_FLAG_RLE_BIG)
+               data_offset = 2;
+
+       sbits = &src->bm_data[4 + (src->bm_h*data_offset)];
        for (i=0; i<sy; i++ )
-               sbits += (int)src->bm_data[4+i];
+               sbits += (int)(INTEL_SHORT(src->bm_data[4+(i*data_offset)]));
 
        for (y1=0; y1 < h; y1++ )    {
-               gr_rle_expand_scanline_generic( dest, dx, dy+y1,  sbits, sx, sx+w-1, 
-                       masked );
-               sbits += (int)src->bm_data[4+y1+sy];
+               gr_rle_expand_scanline_generic( dest, dx, dy+y1,  sbits, sx, sx+w-1, masked  );
+               if ( src->bm_flags & BM_FLAG_RLE_BIG )
+                       sbits += (int)INTEL_SHORT(*((short *)&(src->bm_data[4+((y1+sy)*data_offset)])));
+               else
+                       sbits += (int)src->bm_data[4+y1+sy];
        }
 }
 
index b112439..015bdc0 100644 (file)
--- a/2d/rle.c
+++ b/2d/rle.c
@@ -1,4 +1,4 @@
-/* $Id: rle.c,v 1.6 2002-08-15 08:53:11 btb Exp $ */
+/* $Id: rle.c,v 1.7 2002-08-17 11:19:56 btb Exp $ */
 /*
 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
@@ -23,7 +23,7 @@ COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
 #endif
 
 #ifdef RCS
-static char rcsid[] = "$Id: rle.c,v 1.6 2002-08-15 08:53:11 btb Exp $";
+static char rcsid[] = "$Id: rle.c,v 1.7 2002-08-17 11:19:56 btb Exp $";
 #endif
 
 #include <stdlib.h>
@@ -442,26 +442,46 @@ int gr_bitmap_rle_compress( grs_bitmap * bmp )
        int y, d1, d;
        int doffset;
        ubyte *rle_data;
+       int large_rle = 0;
 
-       rle_data=d_malloc( (bmp->bm_w+1)* bmp->bm_h );
+       // first must check to see if this is large bitmap.
+
+       for (y=0; y<bmp->bm_h; y++ )    {
+               d1= gr_rle_getsize( bmp->bm_w, &bmp->bm_data[bmp->bm_w*y] );
+               if (d1 > 255) {
+                       large_rle = 1;
+                       break;
+               }
+       }
+
+       rle_data=d_malloc( (bmp->bm_w+1) * bmp->bm_h );
        if (rle_data==NULL) return 0;
-       doffset = 4 + bmp->bm_h;
+       if (!large_rle)
+               doffset = 4 + bmp->bm_h;
+       else
+               doffset = 4 + (2 * bmp->bm_h);          // each row of rle'd bitmap has short instead of byte offset now
+
        for (y=0; y<bmp->bm_h; y++ )    {
                d1= gr_rle_getsize( bmp->bm_w, &bmp->bm_data[bmp->bm_w*y] );
-               if ( ((doffset+d1) > bmp->bm_w*bmp->bm_h) || (d1 > 255 ) )      {
+               if ( ((doffset+d1) > bmp->bm_w*bmp->bm_h) || (d1 > (large_rle?32767:255) ) ) {
                        d_free(rle_data);
                        return 0;
                }
                d = gr_rle_encode( bmp->bm_w, &bmp->bm_data[bmp->bm_w*y], &rle_data[doffset] );
                Assert( d==d1 );
                doffset += d;
-               rle_data[y+4] = d;
+               if (large_rle)
+                       *((short *)&(rle_data[(y*2)+4])) = (short)d;
+               else
+                       rle_data[y+4] = d;
        }
        //mprintf( 0, "Bitmap of size %dx%d, (%d bytes) went down to %d bytes\n", bmp->bm_w, bmp->bm_h, bmp->bm_h*bmp->bm_w, doffset );
        memcpy(         rle_data, &doffset, 4 );
        memcpy(         bmp->bm_data, rle_data, doffset );
        d_free(rle_data);
        bmp->bm_flags |= BM_FLAG_RLE;
+       if (large_rle)
+               bmp->bm_flags |= BM_FLAG_RLE_BIG;
        return 1;
 }
 
index 544e994..6ff2b3d 100644 (file)
@@ -43,6 +43,7 @@
 #include "powerup.h"
 #include "polyobj.h"
 #include "gamefont.h"
+#include "byteswap.h"
 
 //change to 1 for lots of spew.
 #if 0
@@ -1375,7 +1376,8 @@ void tex_set_size(ogl_texture *tex){
 //In theory this could be a problem for repeating textures, but all real
 //textures (not sprites, etc) in descent are 64x64, so we are ok.
 //stores OpenGL textured id in *texid and u/v values required to get only the real data in *u/*v
-void ogl_loadtexture(unsigned char * data, int dxo,int dyo, ogl_texture *tex){
+void ogl_loadtexture(unsigned char * data, int dxo,int dyo, ogl_texture *tex)
+{
 //void ogl_loadtexture(unsigned char * data, int width, int height,int dxo,int dyo, int *texid,float *u,float *v,char domipmap,float prio){
 //     int internalformat=GL_RGBA;
 //     int format=GL_RGBA;
@@ -1432,8 +1434,11 @@ void ogl_loadtexture(unsigned char * data, int dxo,int dyo, ogl_texture *tex){
        glmprintf((0,"ogl_loadtexture(%p,%i,%i,%ix%i,%p):%i u=%f v=%f b=%i bu=%i (%i)\n",data,tex->tw,tex->th,dxo,dyo,tex,tex->handle,tex->u,tex->v,tex->bytes,tex->bytesu,r_texcount));
 
 }
+
 unsigned char decodebuf[512*512];
-void ogl_loadbmtexture_m(grs_bitmap *bm,int domipmap){
+
+void ogl_loadbmtexture_m(grs_bitmap *bm,int domipmap)
+{
        unsigned char *buf;
        while (bm->bm_parent)
                bm=bm->bm_parent;
@@ -1457,24 +1462,36 @@ void ogl_loadbmtexture_m(grs_bitmap *bm,int domipmap){
        if (bm->bm_flags & BM_FLAG_RLE){
                unsigned char * dbits;
                unsigned char * sbits;
-               int i;
-               sbits = &bm->bm_data[4 + bm->bm_h];
+               int i, data_offset;
+
+               data_offset = 1;
+               if (bm->bm_flags & BM_FLAG_RLE_BIG)
+                       data_offset = 2;
+
+               sbits = &bm->bm_data[4 + (bm->bm_h * data_offset)];
                dbits = decodebuf;
 
                for (i=0; i < bm->bm_h; i++ )    {
                        gr_rle_decode(sbits,dbits);
-                       sbits += (int)bm->bm_data[4+i];
+                       if ( bm->bm_flags & BM_FLAG_RLE_BIG )
+                               sbits += (int)INTEL_SHORT(*((short *)&(bm->bm_data[4+(i*data_offset)])));
+                       else
+                               sbits += (int)bm->bm_data[4+i];
                        dbits += bm->bm_w;
                }
                buf=decodebuf;
        }
        ogl_loadtexture(buf,0,0,bm->gltexture);
 }
-void ogl_loadbmtexture(grs_bitmap *bm){
+
+void ogl_loadbmtexture(grs_bitmap *bm)
+{
        ogl_loadbmtexture_m(bm,1);
 }
-void ogl_freetexture(ogl_texture *gltexture){
-       if (gltexture->handle>0){
+
+void ogl_freetexture(ogl_texture *gltexture)
+{
+       if (gltexture->handle>0) {
                r_texcount--;
                glmprintf((0,"ogl_freetexture(%p):%i (last rend %is) (%i left)\n",gltexture,gltexture->handle,(GameTime-gltexture->lastrend)/f1_0,r_texcount));
                glDeleteTextures( 1, &gltexture->handle );