This is the online documentation for Colossus Entertainments Pixie Game Engine

RLEBitmap.cpp Go to the documentation of this file. #include "RLEBitmap.h" #include "Image.h" #include "Asset.h" #include "Bitmap.h" #include "AlphaBitmap.h" #define max(a,b) (((a) > (b)) ? (a) : (b)) #define min(a,b) (((a) < (b)) ? (a) : (b)) const char* Pixie_Rle_Header="PIXIE_RLE"; //*** Constructor *** RLEBitmap::RLEBitmap(): usesMask_(0), xOffset_(0), yOffset_(0), activeWidth_(0), activeHeight_(0), width_(0), height_(0), opaqueSize_(0), opaqueData_(0), alphaSize_(0), alphaData_(0), colorCount_(0), palette_(0), modulatedPalette_(0), currentPalette_(0) { } //*** Constructor *** RLEBitmap::RLEBitmap(const Image& image): usesMask_(0), xOffset_(0), yOffset_(0), activeWidth_(0), activeHeight_(0), width_(0), height_(0), opaqueSize_(0), opaqueData_(0), alphaSize_(0), alphaData_(0), colorCount_(0), palette_(0), modulatedPalette_(0), currentPalette_(0) { CreateFromImage(&image); } //*** Constructor *** RLEBitmap::RLEBitmap(const Asset& asset): usesMask_(0), xOffset_(0), yOffset_(0), activeWidth_(0), activeHeight_(0), width_(0), height_(0), opaqueSize_(0), opaqueData_(0), alphaSize_(0), alphaData_(0), colorCount_(0), palette_(0), modulatedPalette_(0), currentPalette_(0) { Load(asset); } //*** Destructor *** RLEBitmap::~RLEBitmap() { if (opaqueData_) { Free(opaqueData_); } if (alphaData_) { Free(alphaData_); } if (palette_) { Free(palette_); } if (modulatedPalette_) { Free(modulatedPalette_); } } //*** ReadFromAsset *** void RLEBitmap::ReadFromAsset(const Asset* asset) { asset->Read(&width_); asset->Read(&height_); asset->Read(&activeWidth_); asset->Read(&activeHeight_); asset->Read(&colorCount_); palette_=(unsigned short*)Malloc(sizeof(unsigned short)*colorCount_); asset->Read(palette_,colorCount_); asset->Read(&usesMask_); asset->Read(&opaqueSize_); if (opaqueSize_>0) { opaqueData_=(unsigned char*)Malloc(opaqueSize_); asset->Read(opaqueData_,opaqueSize_); } asset->Read(&alphaSize_); if (alphaSize_>0) { alphaData_=(unsigned char*)Malloc(alphaSize_); asset->Read(alphaData_,alphaSize_); } asset->Read(&xOffset_,1); asset->Read(&yOffset_,1); } //*** WriteToAsset *** void RLEBitmap::WriteToAsset(Asset* asset) { asset->Write(&width_); asset->Write(&height_); asset->Write(&activeWidth_); asset->Write(&activeHeight_); asset->Write(&colorCount_); asset->Write(palette_,colorCount_); asset->Write(&usesMask_); asset->Write(&opaqueSize_); if (opaqueSize_>0 && opaqueData_) { asset->Write(opaqueData_,opaqueSize_); } asset->Write(&alphaSize_); if (alphaSize_>0 && alphaData_) { asset->Write(alphaData_,alphaSize_); } asset->Write(&xOffset_); asset->Write(&yOffset_); } //*** calculateDiff *** int calculateDiff(unsigned short a, unsigned short b) { unsigned char ar=(unsigned char)((a & 0xf800)>>11); unsigned char ag=(unsigned char)((a & 0x7e0)>>5); unsigned char ab=(unsigned char)((a & 0x1f)); unsigned char br=(unsigned char)((b & 0xf800)>>11); unsigned char bg=(unsigned char)((b & 0x7e0)>>5); unsigned char bb=(unsigned char)((b & 0x1f)); // Diff int dr=Abs(ar-br); int dg=Abs(ab-bb); int db=Abs(ag-bg); return dr+dg+db; } //*** FindGetRidOfDiff *** void RLEBitmap::FindGetRidOfDiff(unsigned short* palette, int usedPaletteEntries,int& diff, int& a, int& b) { // Find best match int bestPairA=0; int bestPairB=1; int bestDiff=calculateDiff(palette[bestPairA],palette[bestPairB]); for (int i=0; i<usedPaletteEntries-1; i++) { for (int j=i+1; j<usedPaletteEntries; j++) { int diff=calculateDiff(palette[i],palette[j]); if (diff<bestDiff) { bestDiff=diff; bestPairA=i; bestPairB=j; } } } a=bestPairA; b=bestPairB; diff=bestDiff; } //*** GetRidOfColor *** void RLEBitmap::GetRidOfColor(unsigned char* data, int size, unsigned short* palette, int& usedPaletteEntries,unsigned int* timesUsed, int bestDiff, int bestPairA, int bestPairB) { // Remove color if (timesUsed[bestPairB]>timesUsed[bestPairA]) { int temp=bestPairB; bestPairB=bestPairA; bestPairA=temp; } timesUsed[bestPairA]+=timesUsed[bestPairB]; for (int i=0; i<size; i++) { if (data[i]==bestPairB) { data[i]=(unsigned char)bestPairA; } } // Move last color to free slot palette[bestPairB]=palette[usedPaletteEntries-1]; for (int i=0; i<size; i++) { if (data[i]==(usedPaletteEntries-1)) data[i]=(unsigned char)bestPairB; } // Reduce number of used colors usedPaletteEntries--; } //*** FindBestColor *** unsigned char RLEBitmap::FindBestColor(unsigned char* data, int size, unsigned short* palette, int& usedPaletteEntries,unsigned int* timesUsed, unsigned char r, unsigned char g, unsigned char b) { unsigned short color=(r<<11)|(g<<5)|(b); for (int i=0; i<usedPaletteEntries; i++) { if (palette[i]==color) { timesUsed[i]++; return (unsigned char)i; } } if (usedPaletteEntries==254) { // Find best match int bestMatch=0; int bestDiff=calculateDiff(color,palette[bestMatch]); for (int i=1; i<usedPaletteEntries; i++) { int diff=calculateDiff(color,palette[i]); if (diff<bestDiff) { bestDiff=diff; bestMatch=i; } } int ridPairA=0; int ridPairB=0; int ridDiff=0; FindGetRidOfDiff(palette,usedPaletteEntries,ridDiff,ridPairA,ridPairB); if (bestDiff<=ridDiff) { timesUsed[bestMatch]++; return (unsigned char)bestMatch; } GetRidOfColor(data,size,palette,usedPaletteEntries,timesUsed,ridDiff,ridPairA,ridPairB); } Assert(usedPaletteEntries<254,"Palette full!"); palette[usedPaletteEntries]=color; timesUsed[usedPaletteEntries]=0; usedPaletteEntries++; return (unsigned char)(usedPaletteEntries-1); } //*** CreateFromImage *** void RLEBitmap::CreateFromImage(const Image* image) { width_=(unsigned short)image->GetWidth(); height_=(unsigned short)image->GetHeight(); int minX=0; int minY=0; int maxX=0; int maxY=0; // Crop image Crop(image,&minX,&minY,&maxX,&maxY); if (maxX<minX || maxY<minY) { return; } activeWidth_=(unsigned short)(maxX-minX+1); activeHeight_=(unsigned short)(maxY-minY+1); xOffset_=(unsigned short)minX; yOffset_=(unsigned short)minY; // First, create palettized version unsigned char* data=0; unsigned char* mask=0; Palettize(image,&data,&mask,&palette_,&colorCount_); if (mask) usesMask_=1; else usesMask_=0; // Create RLE data opaqueSize_=GetRLESize(data,mask); if (opaqueSize_>0) { opaqueData_=(unsigned char*)Malloc(opaqueSize_); CreateRLE(data,mask,opaqueData_); } // Create RLE mask if (mask) { alphaSize_=GetRLESize_Alpha(data,mask); if (alphaSize_>0) { alphaData_=(unsigned char*)Malloc(alphaSize_); CreateRLE_Alpha(data,mask,alphaData_); } } // Release temp stuff if (data) { Free(data); } if (mask) { Free(mask); } } //*** GetRunLength *** int RLEBitmap::GetRunLength(unsigned char* data, unsigned char* mask,int size) { int length=0; int currCol=*data; if (mask && *mask<255) { currCol=255; } int c=currCol; while ((currCol==c) && size>0) { length++; data++; if (mask) { mask++; } size--; currCol=*data; if (mask && *mask<255) { currCol=255; } } return length; } //*** GetUniquesLength *** int RLEBitmap::GetUniquesLength(unsigned char* data, unsigned char* mask,int size) { int length=0; while (GetRunLength(data,mask,size)<=2 && size>0) { length++; data++; if (mask) { mask++; } size--; } return length; } //*** GetRLESize *** int RLEBitmap::GetRLESize(unsigned char* data,unsigned char* mask) { return CreateRLE(data,mask,0); } //*** CreateRLE *** int RLEBitmap::CreateRLE(unsigned char* source, unsigned char* mask, unsigned char* destination) { int size=activeWidth_*activeHeight_; int result=0; int xleft=activeWidth_; while (size>0) { unsigned char len=(unsigned char)GetRunLength(source,mask,min(127,min(size,xleft))); if (len<=2) { unsigned char len=(unsigned char)GetUniquesLength(source,mask,min(127,min(size,xleft))); result++; // Count value if (destination) { *destination=(len | 0x80); // Top bit set to indicate run of unique colors destination++; } result+=len; // Unique colors if (destination) { unsigned char* colorsource=source; unsigned char* maskvalue=mask; for (int i=0; i<len; i++) { if (mask && *maskvalue<255) *destination=255; // Transparent or semitransparent pixel else *destination=*colorsource; destination++; colorsource++; if (mask) maskvalue++; } } if (mask) mask+=len; source+=len; xleft-=len; Assert(xleft>=0,"Inavlid run length"); if (xleft==0) xleft=activeWidth_; size-=len; } else { result++; // Count value if (destination) { *destination=len; // Top bit not set to indicate run of same color destination++; } result++; // Repeated color if (destination) { if (mask && *mask<255) *destination=255; // Transparent or semitransparent pixel else *destination=*source; destination++; } source+=len; xleft-=len; Assert(xleft>=0,"Inavlid run length"); if (xleft==0) xleft=activeWidth_; if (mask) mask+=len; size-=len; } } return result; } //*** GetRunLength_Alpha *** int RLEBitmap::GetRunLength_Alpha(unsigned char* data, unsigned char* mask,int size) { int length=0; int currCol=*data; int currMask=*mask; if (currMask==0 || currMask==255) { currMask=0; currCol=255; } int c=currCol; int m=currMask; while ((currCol==c) && (currMask==m) && size>0) { length++; data++; mask++; size--; currCol=*data; currMask=*mask; if (currMask==0 || currMask==255) { currMask=0; currCol=255; } } return length; } //*** GetUniquesLength_Alpha *** int RLEBitmap::GetUniquesLength_Alpha(unsigned char* data, unsigned char* mask,int size) { int length=0; while (GetRunLength_Alpha(data,mask,size)<=2 && size>0) { length++; data++; mask++; size--; } return length; } //*** GetRLESize_Alpha *** int RLEBitmap::GetRLESize_Alpha(unsigned char* data,unsigned char* mask) { return CreateRLE_Alpha(data,mask,0); } //*** CreateRLE_Alpha *** int RLEBitmap::CreateRLE_Alpha(unsigned char* source, unsigned char* mask, unsigned char* destination) { int size=activeWidth_*activeHeight_; int result=0; int xleft=activeWidth_; while (size>0) { unsigned char len=(unsigned char)GetRunLength_Alpha(source,mask,min(127,min(size,xleft))); if (len<=2) { unsigned char len=(unsigned char)GetUniquesLength_Alpha(source,mask,min(127,min(size,xleft))); result++; // Count value if (destination) { *destination=(len | 0x80); // Top bit set to indicate run of unique colors destination++; } // Unique colors unsigned char* colorsource=source; unsigned char* maskvalue=mask; for (int i=0; i<len; i++) { if (*maskvalue==0 || *maskvalue==255) { if (destination) { *destination=0; // Fully transparent pixel destination++; *destination=0; destination++; } result+=2; } else { if (destination) { *destination=*maskvalue; // Semi-transparent pixel destination++; *destination=*colorsource; destination++; } result+=2; } colorsource++; maskvalue++; } mask+=len; source+=len; xleft-=len; Assert(xleft>=0,"Invalid run length"); if (xleft==0) xleft=activeWidth_; size-=len; } else { result++; // Count value if (destination) { *destination=len; // Top bit not set to indicate run of same color destination++; } // Repeated color if (*mask==0 || *mask==255) { if (destination) { *destination=0; // Fully transparent pixel destination++; *destination=0; destination++; } result+=2; } else { if (destination) { *destination=*mask; destination++; *destination=*source; destination++; } result+=2; } source+=len; xleft-=len; Assert(xleft>=0,"Invalid run length"); if (xleft==0) xleft=activeWidth_; mask+=len; size-=len; } } return result; } //*** Palettize *** void RLEBitmap::Palettize(const Image* image,unsigned char** data, unsigned char** mask, unsigned short** palette, unsigned char* colorCount) { static unsigned short pal[256]; static unsigned int timesUsed[256]; int usedPaletteEntries=0; *data=(unsigned char*)Malloc(sizeof(unsigned char)*activeWidth_*activeHeight_); *mask=(unsigned char*)Malloc(sizeof(unsigned char)*activeWidth_*activeHeight_); unsigned char* img=*data; unsigned char* maskimg=*mask; bool maskUsed=false; bool maskUsedTrans=false; for (int y=0; y<activeHeight_; y++) { for (int x=0; x<activeWidth_; x++) { unsigned int color=image->GetPixel(xOffset_+x,yOffset_+y); unsigned short color16=RGB32TO16(color); unsigned char a=((unsigned char)((color&0xff000000)>>24)); unsigned char r=((unsigned char)((color16 & 0xf800)>>11)); unsigned char g=((unsigned char)((color16 & 0x07e0)>>5)); unsigned char b=((unsigned char)((color16 & 0x1f))); *img=FindBestColor(*data,(int)(img-*data),pal,usedPaletteEntries,timesUsed,r,g,b); img++; *maskimg=a; maskimg++; if (a<255) { maskUsed=true; if (a>0) { maskUsedTrans=true; } } } } if (!maskUsed) { Free(*mask); *mask=0; } *palette=(unsigned short*)Malloc(sizeof(unsigned short)*usedPaletteEntries); MemCpy(*palette,pal,sizeof(unsigned short)*usedPaletteEntries); *colorCount=(unsigned char)usedPaletteEntries; } //*** Crop *** void RLEBitmap::Crop(const Image* image, int* minX, int* minY, int* maxX, int* maxY) { *minX=image->GetWidth(); *minY=image->GetHeight(); *maxX=0; *maxY=0; for (int y=0; y<image->GetHeight(); y++) { for (int x=0; x<image->GetWidth(); x++) { unsigned int color=image->GetPixel(x,y); if (color>>24) { if (y<*minY) *minY=y; if (x<*minX) *minX=x; if (y>*maxY) *maxY=y; if (x>*maxX) *maxX=x; } } } } //*** Blit *** void RLEBitmap::Blit(Bitmap* target,int x, int y,unsigned short modulate, unsigned char alpha) const { Blit(0,0,activeWidth_-1,activeHeight_-1,target,x,y,modulate,alpha); } //*** Blit *** void RLEBitmap::Blit(int x1, int y1, int x2, int y2, Bitmap* target,int x, int y, unsigned short modulate, unsigned char alpha) const { // Check for empty bitmap if (!opaqueData_ && !alphaData_) { return; } if (alpha==0) { return; } int clipX1=x+xOffset_; int clipY1=y+yOffset_; int clipX2=x+xOffset_+(x2-x1); int clipY2=y+yOffset_+(y2-y1); x-=x1; y-=y1; if (clipX1<0) clipX1=0; if (clipY1<0) clipY1=0; if (clipX2>=target->GetWidth()) clipX2=target->GetWidth()-1; if (clipY2>=target->GetHeight()) clipY2=target->GetHeight()-1; // Set up palette currentPalette_=palette_; if (modulate!=0xffff) { if (!modulatedPalette_) { modulatedPalette_=(unsigned short*)Malloc(sizeof(unsigned short)*colorCount_); } for (int i=0; i<colorCount_; i++) { int c=palette_[i]; unsigned int r=(c & 0xf800)>>11; unsigned int g=(c & 0x7e0)>>5; unsigned int b=(c & 0x1f); unsigned int mr=(modulate & 0xf800)>>11; unsigned int mg=(modulate & 0x7e0)>>5; unsigned int mb=(modulate & 0x1f); r*=mr; g*=mg; b*=mb; r>>=5; g>>=6; b>>=5; modulatedPalette_[i]=(unsigned short)((r<<11)|(g<<5)|(b)); } currentPalette_=modulatedPalette_; } int targetDelta=target->GetWidth()-activeWidth_; int tx1=x+xOffset_; int ty1=y+yOffset_; int tx2=tx1+activeWidth_-1; int ty2=ty1+activeHeight_-1; unsigned short* data=&(target->GetData())[tx1+ty1*target->GetWidth()]; // Do we need to clip? if (tx1>=clipX1 && ty1>=clipY1 && tx2<=clipX2 && ty2<=clipY2) { // Render opaque part if (opaqueData_) { if (usesMask_) { if (alpha==255) { Blit_Opaque_Unclipped_Masked(data,targetDelta,tx1,ty1); } else { Blit_Opaque_Unclipped_Masked_Transparent(data,targetDelta,tx1,ty1,alpha); } } else { if (alpha==255) { Blit_Opaque_Unclipped_Unmasked(data,targetDelta,tx1,ty1); } else { Blit_Opaque_Unclipped_Unmasked_Transparent(data,targetDelta,tx1,ty1,alpha); } } } // Render alpha part if (alphaData_) { if (alpha==255) { Blit_Alpha_Unclipped(data,targetDelta,tx1,ty1); } else { Blit_Alpha_Unclipped_Transparent(data,targetDelta,tx1,ty1,alpha); } } } else // Yes, clipping required { // Trivial rejection test if (tx2<clipX1 || ty2<clipY1 || tx1>clipX2 || ty1>clipY2) return; // Calculate visible part int xStart=0; int yStart=0; int xEnd=0; int yEnd=0; if (tx1<clipX1) { xStart=clipX1-tx1; } if (ty1<clipY1) { yStart=clipY1-ty1; } if (tx2>clipX2) { xEnd=tx2-clipX2+1; } if (ty2>clipY2) { yEnd=ty2-clipY2+1; } // Render opaque part if (opaqueData_) { if (usesMask_) { if (alpha==255) { Blit_Opaque_Clipped_Masked(data,targetDelta,tx1,ty1,xStart,yStart,xEnd,yEnd); } else { Blit_Opaque_Clipped_Masked_Transparent(data,targetDelta,tx1,ty1,xStart,yStart,xEnd,yEnd,alpha); } } else { if (alpha==255) { Blit_Opaque_Clipped_Unmasked(data,targetDelta,tx1,ty1,xStart,yStart,xEnd,yEnd); } else { Blit_Opaque_Clipped_Unmasked_Transparent(data,targetDelta,tx1,ty1,xStart,yStart,xEnd,yEnd,alpha); } } } // Render alpha part if (alphaData_) { Blit_Alpha_Clipped(data,targetDelta,tx1,ty1,xStart,yStart,xEnd,yEnd); } } } //*** Blit *** void RLEBitmap::Blit(AlphaBitmap* target,int x, int y) const { Blit(0,0,activeWidth_-1,activeHeight_-1,target,x,y); } //*** Blit *** void RLEBitmap::Blit(int x1, int y1, int x2, int y2, AlphaBitmap* target, int x, int y) const { // Check for empty bitmap if (!opaqueData_ && !alphaData_) { return; } x-=x1; y-=y1; int clipX1=x+xOffset_; int clipY1=y+yOffset_; int clipX2=x+xOffset_+(x2-x1); int clipY2=y+yOffset_+(y2-y1); if (clipX1<0) clipX1=0; if (clipY1<0) clipY1=0; if (clipX2>=target->GetWidth()) clipX2=target->GetWidth()-1; if (clipY2>=target->GetHeight()) clipY2=target->GetHeight()-1; currentPalette_=palette_; int targetDelta=target->GetWidth()-activeWidth_; int tx1=x+xOffset_; int ty1=y+yOffset_; int tx2=tx1+activeWidth_-1; int ty2=ty1+activeHeight_-1; unsigned short* colorData=&(target->GetColorData())[tx1+ty1*target->GetWidth()]; unsigned char* alphaData=&(target->GetAlphaData())[tx1+ty1*target->GetWidth()]; // Do we need to clip? if (tx1>=clipX1 && ty1>=clipY1 && tx2<=clipX2 && ty2<=clipY2) { // Render opaque part if (opaqueData_) { if (usesMask_) { PreserveAlpha_Blit_Opaque_Unclipped_Masked(colorData, alphaData, targetDelta, tx1, ty1); } else { PreserveAlpha_Blit_Opaque_Unclipped_Unmasked(colorData, alphaData, targetDelta, tx1, ty1); } } // Render alpha part if (alphaData_) { PreserveAlpha_Blit_Alpha_Unclipped(colorData, alphaData, targetDelta, tx1, ty1); } } else // Yes, clipping required { // Trivial rejection test if (tx2<clipX1 || ty2<clipY1 || tx1>clipX2 || ty1>clipY2) return; // Calculate visible part int xStart=0; int yStart=0; int xEnd=0; int yEnd=0; if (tx1<clipX1) { xStart=clipX1-tx1; } if (ty1<clipY1) { yStart=clipY1-ty1; } if (tx2>clipX2) { xEnd=tx2-clipX2+1; } if (ty2>clipY2) { yEnd=ty2-clipY2+1; } // Render opaque part if (opaqueData_) { if (usesMask_) { PreserveAlpha_Blit_Opaque_Clipped_Masked(colorData, alphaData, targetDelta, tx1, ty1, xStart, yStart, xEnd, yEnd); } else { PreserveAlpha_Blit_Opaque_Clipped_Unmasked(colorData, alphaData, targetDelta, tx1, ty1, xStart, yStart, xEnd, yEnd); } } // Render alpha part if (alphaData_) { PreserveAlpha_Blit_Alpha_Clipped(colorData, alphaData, targetDelta, tx1, ty1, xStart, yStart, xEnd, yEnd); } } } //*** Fill *** __forceinline void Fill(unsigned short* data, unsigned short color, int len) { for (int i=0; i<len; ++i) { *data=color; data++; } } //*** Blend *** __forceinline void Blend(unsigned short* destination, unsigned int color, unsigned int alpha) { if (alpha==255) { *destination=(unsigned short)color; } else { unsigned int inva=255-alpha; unsigned int s=*destination; unsigned int sr=(s & 0xf800)>>11; unsigned int sg=(s & 0x7e0)>>5; unsigned int sb=(s & 0x1f); unsigned int dr=(color & 0xf800)>>11; unsigned int dg=(color & 0x7e0)>>5; unsigned int db=(color & 0x1f); unsigned int r=((sr*inva)+dr*alpha)>>8; unsigned int g=((sg*inva)+dg*alpha)>>8; unsigned int b=((sb*inva)+db*alpha)>>8; unsigned int c=(r<<11)|(g<<5)|b; *destination=(unsigned short)c; } } //*** FillTransparent *** __forceinline void FillTransparent(unsigned short* data, unsigned short color, int len, unsigned char alpha) { for (int i=0; i<len; ++i) { Blend(data,color,alpha); data++; } } //*** BurstFill *** // This is to make sure we fill on 4 byte alignment as much as possible __forceinline void BurstFill(unsigned short* data, unsigned short color, int len) { int len2=len; #pragma warning (push) #pragma warning( disable: 4311) #ifdef _WIN32 if (((int)data)!=(((int)data)&(0xfffffffc))) #else if (((long long)data)!=(((long long)data)&(0xfffffffffffffffc))) #endif #pragma warning (pop) { *data=color; ++data; --len2; if (len2==1) { *data=color; ++data; --len2; } } if (len2) { unsigned int color32=color | (color<<16); int halflen=len2/2; unsigned int* data32=(unsigned int*)data; for (int i=0; i<halflen; ++i) { *data32=color32; ++data32; } data=(unsigned short*)data32; if (len2-halflen*2) { *data=color; ++data; } } } //*** DoOpaqueUnclippedUnmasked *** __forceinline void DoOpaqueUnclippedUnmasked(int len,unsigned short* data, unsigned char** source, unsigned short* palette) { unsigned char* dataRLE=*source; if (len&0x80) { len&=0x7f; // Unique values for (int i=0; i<len; ++i) { *data=palette[*dataRLE]; ++data; ++(dataRLE); } } else { // Run of values #ifdef _DEBUG Fill(data,palette[*dataRLE],len); #else BurstFill(data,palette[*dataRLE],len); #endif ++(dataRLE); } *source=dataRLE; } //*** DoOpaqueUnclippedUnmaskedTransparent *** __forceinline void DoOpaqueUnclippedUnmaskedTransparent(int len,unsigned short* data, unsigned char** source, unsigned short* palette, unsigned char alpha) { unsigned char* dataRLE=*source; if (len&0x80) { len&=0x7f; // Unique values for (int i=0; i<len; ++i) { Blend(data,palette[*dataRLE],alpha); ++data; ++(dataRLE); } } else { // Run of values FillTransparent(data,palette[*dataRLE],len,alpha); ++(dataRLE); } *source=dataRLE; } //*** DoOpaqueClippedMasked *** __forceinline void DoOpaqueClippedMasked(int len,unsigned short* data, unsigned char** source, unsigned short* palette, int clipStart, int clipEnd) { unsigned char* dataRLE=*source; int x=0; if (len&0x80) { len&=0x7f; // Unique values for (int i=0; i<len; ++i) { if ((*dataRLE)<255 && x>=clipStart && x<=clipEnd) *data=palette[*dataRLE]; ++x; ++data; ++(dataRLE); } } else { // Run of values int colorIndex=*dataRLE; if(colorIndex<255) { unsigned short color=palette[colorIndex]; for (int i=0; i<len; ++i) { if (colorIndex<255 && x>=clipStart && x<=clipEnd) { *data=color; } ++x; ++data; } } else { x+=len; data+=len; } ++(dataRLE); } *source=dataRLE; } //*** DoOpaqueClippedMaskedTransparent *** __forceinline void DoOpaqueClippedMaskedTransparent(int len,unsigned short* data, unsigned char** source, unsigned short* palette, int clipStart, int clipEnd, unsigned char alpha) { unsigned char* dataRLE=*source; int x=0; if (len&0x80) { len&=0x7f; // Unique values for (int i=0; i<len; ++i) { if ((*dataRLE)<255 && x>=clipStart && x<=clipEnd) { Blend(data,palette[*dataRLE],alpha); } ++x; ++data; ++(dataRLE); } } else { // Run of values int colorIndex=*dataRLE; if(colorIndex<255) { unsigned short color=palette[colorIndex]; for (int i=0; i<len; ++i) { if (colorIndex<255 && x>=clipStart && x<=clipEnd) { Blend(data,color,alpha); } ++x; ++data; } } else { x+=len; data+=len; } ++(dataRLE); } *source=dataRLE; } //*** DoOpaqueUnclippedMasked *** __forceinline void DoOpaqueUnclippedMasked(int len,unsigned short* data, unsigned char** source, unsigned short* palette) { unsigned char* dataRLE=*source; if (len&0x80) { len&=0x7f; // Unique values for (int i=0; i<len; ++i) { if ((*dataRLE)<255) { *data=palette[*dataRLE]; } ++data; ++(dataRLE); } } else { // Run of values if ((*dataRLE)<255) { #ifdef _DEBUG Fill(data,palette[*dataRLE],len); #else BurstFill(data,palette[*dataRLE],len); #endif } ++(dataRLE); } *source=dataRLE; } //*** DoOpaqueUnclippedMaskedTransparent *** __forceinline void DoOpaqueUnclippedMaskedTransparent(int len,unsigned short* data, unsigned char** source, unsigned short* palette, unsigned char alpha) { unsigned char* dataRLE=*source; if (len&0x80) { len&=0x7f; // Unique values for (int i=0; i<len; ++i) { if ((*dataRLE)<255) { Blend(data,palette[*dataRLE],alpha); } ++data; ++(dataRLE); } } else { // Run of values if ((*dataRLE)<255) { FillTransparent(data,palette[*dataRLE],len,alpha); } ++(dataRLE); } *source=dataRLE; } //*** IgnoreOpaque *** __forceinline void IgnoreOpaque(int len, unsigned char** source) { unsigned char* dataRLE=*source; if (len&0x80) { len&=0x7f; dataRLE+=len; } else { ++dataRLE; } *source=dataRLE; } //*** IgnoreAlpha *** __forceinline void IgnoreAlpha(int len, unsigned char** source) { unsigned char* dataRLE=*source; if (len&0x80) { len&=0x7f; dataRLE+=len*2; } else { dataRLE+=2; } *source=dataRLE; } //*** Blit_Opaque_Unclipped_Unmasked *** void RLEBitmap::Blit_Opaque_Unclipped_Unmasked(unsigned short* data, int backBufferDelta,int x, int y) const { unsigned char* dataRLE=opaqueData_; for (int yi=0; yi<activeHeight_; ++yi) { int xi=0; while (xi<activeWidth_) { // Get run length int len=*dataRLE; ++dataRLE; DoOpaqueUnclippedUnmasked(len,data,&dataRLE,currentPalette_); len&=0x7f; data+=len; xi+=len; } data+=backBufferDelta; } } //*** Blit_Opaque_Unclipped_Unmasked_Transparent *** void RLEBitmap::Blit_Opaque_Unclipped_Unmasked_Transparent(unsigned short* data, int backBufferDelta,int x, int y, unsigned char alpha) const { unsigned char* dataRLE=opaqueData_; for (int yi=0; yi<activeHeight_; ++yi) { int xi=0; while (xi<activeWidth_) { // Get run length int len=*dataRLE; ++dataRLE; DoOpaqueUnclippedUnmaskedTransparent(len,data,&dataRLE,currentPalette_,alpha); len&=0x7f; data+=len; xi+=len; } data+=backBufferDelta; } } //*** Blit_Opaque_Unclipped_Masked *** void RLEBitmap::Blit_Opaque_Unclipped_Masked(unsigned short* data, int backBufferDelta,int x, int y) const { unsigned char* dataRLE=opaqueData_; for (int yi=0; yi<activeHeight_; ++yi) { int xi=0; while (xi<activeWidth_) { // Get run length int len=*dataRLE; ++dataRLE; DoOpaqueUnclippedMasked(len,data,&dataRLE,currentPalette_); len&=0x7f; data+=len; xi+=len; } data+=backBufferDelta; } } //*** Blit_Opaque_Unclipped_Masked_Transparent *** void RLEBitmap::Blit_Opaque_Unclipped_Masked_Transparent(unsigned short* data, int backBufferDelta,int x, int y, unsigned char alpha) const { unsigned char* dataRLE=opaqueData_; for (int yi=0; yi<activeHeight_; ++yi) { int xi=0; while (xi<activeWidth_) { // Get run length int len=*dataRLE; ++dataRLE; DoOpaqueUnclippedMaskedTransparent(len,data,&dataRLE,currentPalette_,alpha); len&=0x7f; data+=len; xi+=len; } data+=backBufferDelta; } } //*** Blit_Opaque_Clipped_Masked *** void RLEBitmap::Blit_Opaque_Clipped_Masked(unsigned short* data, int backBufferDelta,int x, int y, int xStart, int yStart, int xEnd, int yEnd) const { if (yStart>activeHeight_-yEnd) return; if (xStart>activeWidth_-xEnd) return; unsigned char* dataRLE=opaqueData_; // Skip clipped rows for (int i=0; i<yStart; i++) { int xi=0; while (xi<activeWidth_) { // Get run length int len=*dataRLE; ++dataRLE; IgnoreOpaque(len,&dataRLE); len&=0x7f; xi+=len; } } data+=yStart*(backBufferDelta+activeWidth_); for (int yi=yStart; yi<(activeHeight_-yEnd); ++yi) { int xi=0; while (xi<activeWidth_) { // Get run length int len=*dataRLE; ++dataRLE; // Are we on the edge? int runLength=(len&0x7f); if (xi<xStart || (xi+runLength)>(activeWidth_-xEnd)) { // yes, on the edge, but is the whole segment off screen? if ((xi+runLength)<xStart || xi>(activeWidth_-xEnd)) { // Yes, whole segment is out of view, so ignore IgnoreOpaque(len,&dataRLE); } else { // No, only part of the segment is out of view, so need to draw with clipping int clipStart=xStart-xi; int clipEnd=(activeWidth_-xEnd)-xi; DoOpaqueClippedMasked(len,data,&dataRLE,currentPalette_,clipStart,clipEnd); } } else // nope, not near edge, so just barge ahead { DoOpaqueUnclippedMasked(len,data,&dataRLE,currentPalette_); } len&=0x7f; data+=len; xi+=len; } data+=backBufferDelta; } } //*** Blit_Opaque_Clipped_Masked_Transparent *** void RLEBitmap::Blit_Opaque_Clipped_Masked_Transparent(unsigned short* data, int backBufferDelta,int x, int y, int xStart, int yStart, int xEnd, int yEnd, unsigned char alpha) const { if (yStart>activeHeight_-yEnd) return; if (xStart>activeWidth_-xEnd) return; unsigned char* dataRLE