int main(int argc, char **argv)
{
char *replace;
int i,len;
printf("Removing Walls from File %s\n",argv[1]);
Input=fopen(argv[1],"rb+");
fseek(Input,0,SEEK_END);
FileSize=ftell(Input);
NewFileSize=FileSize;
File=new char[FileSize];
fseek(Input,0,SEEK_SET);
fread(File,1,FileSize,Input);
Change=0;
FindMCNKs();
FixFlags();
fclose(Input);
delete File;
}
long wxsSizerFlagsProperty::ParseString(const wxString& String)
{
long Flags = 0;
wxStringTokenizer Tkn(String, _T("| \t\n"), wxTOKEN_STRTOK);
while ( Tkn.HasMoreTokens() )
{
wxString Flag = Tkn.GetNextToken();
if ( Flag == _T("wxTOP") ) Flags |= BorderTop;
else if ( Flag == _T("wxNORTH") ) Flags |= BorderTop;
else if ( Flag == _T("wxBOTTOM") ) Flags |= BorderBottom;
else if ( Flag == _T("wxSOUTH") ) Flags |= BorderBottom;
else if ( Flag == _T("wxLEFT") ) Flags |= BorderLeft;
else if ( Flag == _T("wxWEST") ) Flags |= BorderLeft;
else if ( Flag == _T("wxRIGHT") ) Flags |= BorderRight;
else if ( Flag == _T("wxEAST") ) Flags |= BorderLeft;
else if ( Flag == _T("wxALL") ) Flags |= BorderMask;
else if ( Flag == _T("wxEXPAND") ) Flags |= Expand;
else if ( Flag == _T("wxGROW") ) Flags |= Expand;
else if ( Flag == _T("wxSHAPED") ) Flags |= Shaped;
else if ( Flag == _T("wxFIXED_MINSIZE") ) Flags |= FixedMinSize;
else if ( Flag == _T("wxALIGN_CENTER") ) Flags |= AlignCenterHorizontal | AlignCenterVertical;
else if ( Flag == _T("wxALIGN_CENTRE") ) Flags |= AlignCenterHorizontal | AlignCenterVertical;
else if ( Flag == _T("wxALIGN_LEFT") ) Flags |= AlignLeft;
else if ( Flag == _T("wxALIGN_RIGHT") ) Flags |= AlignRight;
else if ( Flag == _T("wxALIGN_TOP") ) Flags |= AlignTop;
else if ( Flag == _T("wxALIGN_BOTTOM") ) Flags |= AlignBottom;
else if ( Flag == _T("wxALIGN_CENTER_HORIZONTAL") ) Flags |= AlignCenterHorizontal;
else if ( Flag == _T("wxALIGN_CENTRE_HORIZONTAL") ) Flags |= AlignCenterHorizontal;
else if ( Flag == _T("wxALIGN_CENTER_VERTICAL") ) Flags |= AlignCenterVertical;
else if ( Flag == _T("wxALIGN_CENTRE_VERTICAL") ) Flags |= AlignCenterVertical;
}
FixFlags(Flags);
return Flags;
}
FILENODE *ReadFile(char pre)
{
FILE *fpin;
FILENODE *fbase, *fn, *fp=NULL;
char ln[512], rout[256], auth[256], cc[256], ccflags[512];
char *pcc, *pccflags;
int i, n, ID, alpha, beta, incX, incY;
sprintf(ln, "%caxpby.dsc", pre);
fpin = fopen(ln, "r");
assert(fpin);
assert(fgets(ln, 512, fpin) != NULL);
sscanf(ln, " %d", &n);
for (i=0; i < n; i++)
{
assert(fgets(ln, 512, fpin) != NULL);
assert(sscanf(ln, " %d %d %d %d %d %s \"%[^\"]",
&ID, &alpha, &beta, &incX, &incY, rout, auth) == 7);
if (pre == 's' || pre == 'd')
{
if (alpha != -1 && alpha != 1) alpha = AlphaX;
}
else if (alpha != -1 && alpha != 1 && alpha != 0) alpha = AlphaX;
if (pre == 's' || pre == 'd')
{
if (beta != -1 && beta != 1) beta = AlphaX;
}
else if (beta != -1 && beta != 1 && beta != 0) beta = AlphaX;
if (LineIsCont(ln))
{
assert(fgets(cc, 256, fpin) != NULL);
assert(fgets(ccflags, 512, fpin) != NULL);
FixFlags(cc);
FixFlags(ccflags);
pcc = cc;
pccflags = ccflags;
}
else pcc = pccflags = NULL;
fn = AllocFN(ID, incX, incY, alpha, beta, rout, auth, pcc, pccflags);
if (fp) fp->next = fn;
else fbase = fn;
fp = fn;
}
PrintFN(fbase);
return(fbase);
}
bool wxsSizerFlagsProperty::PropStreamRead(wxsPropertyContainer* Object,wxsPropertyStream* Stream)
{
if ( Stream->GetLong(GetDataName(),FLAGS,AlignTop|AlignLeft) )
{
FixFlags(FLAGS);
return true;
}
return false;
}
int GetStorageRequirements( int width, int height, int flags )
{
// fix any bad flags
flags = FixFlags( flags );
// compute the storage requirements
int blockcount = ( ( width + 3 )/4 ) * ( ( height + 3 )/4 );
int blocksize = ( ( flags & kDxt1 ) != 0 ) ? 8 : 16;
return blockcount*blocksize;
}
void CompressImage( u8 const* rgb, u8 a, int width, int height, void* blocks, int flags )
{
// fix any bad flags
flags = FixFlags( flags );
// initialise the block output
u8* targetBlock = reinterpret_cast< u8* >( blocks );
int bytesPerBlock = ( ( flags & kDxt1 ) != 0 ) ? 8 : 16;
// loop over blocks
for( int y = 0; y < height; y += 4 )
{
for( int x = 0; x < width; x += 4 )
{
// build the 4x4 block of pixels
u8 sourceRgba[16*4];
u8* targetPixel = sourceRgba;
int mask = 0;
for( int py = 0; py < 4; ++py )
{
for( int px = 0; px < 4; ++px )
{
// get the source pixel in the image
int sx = x + px;
int sy = y + py;
// enable if we're in the image
if( sx < width && sy < height )
{
// copy the rgba value
u8 const* sourcePixel = rgb + 3*( width*sy + sx );
for( int i = 0; i < 3; ++i )
*targetPixel++ = *sourcePixel++;
*targetPixel++ = a;
// enable this pixel
mask |= ( 1 << ( 4*py + px ) );
}
else
{
// skip this pixel as its outside the image
targetPixel += 4;
}
}
}
// compress it into the output
CompressMasked( sourceRgba, mask, targetBlock, flags );
// advance
targetBlock += bytesPerBlock;
}
}
}
void DecompressImage( u8* rgba, int width, int height, void const* blocks, int flags )
{
// fix any bad flags
flags = FixFlags( flags );
// initialise the block input
u8 const* sourceBlock = reinterpret_cast< u8 const* >( blocks );
int bytesPerBlock = ( ( flags & kDxt1 ) != 0 ) ? 8 : 16;
// loop over blocks
for( int y = 0; y < height; y += 4 )
{
for( int x = 0; x < width; x += 4 )
{
// decompress the block
u8 targetRgba[4*16];
Decompress( targetRgba, sourceBlock, flags );
// write the decompressed pixels to the correct image locations
u8 const* sourcePixel = targetRgba;
for( int py = 0; py < 4; ++py )
{
for( int px = 0; px < 4; ++px )
{
// get the target location
int sx = x + px;
int sy = y + py;
if( sx < width && sy < height )
{
u8* targetPixel = rgba + 4*( width*sy + sx );
targetPixel[0] = sourcePixel[0];
targetPixel[1] = sourcePixel[1];
targetPixel[2] = sourcePixel[2];
targetPixel[3] = sourcePixel[3];
targetPixel+=4;
sourcePixel+=4;
}
else
{
// skip this pixel as its outside the image
sourcePixel += 4;
}
}
}
// advance
sourceBlock += bytesPerBlock;
}
}
}
FILENODE *ReadFile(char pre)
{
FILE *fpin;
FILENODE *fbase, *fn, *fp=NULL;
char ln[512], rout[256], auth[256], cc[256], ccflags[256];
char *pcc, *pccflags;
int i, n, ID, alpha, beta, incX, incY;
sprintf(ln, "%cnrm2.dsc", pre);
fpin = fopen(ln, "r");
assert(fpin);
assert(fgets(ln, 512, fpin) != NULL);
sscanf(ln, " %d", &n);
for (i=0; i < n; i++)
{
assert(fgets(ln, 512, fpin) != NULL);
assert(sscanf(ln, " %d %d %s \"%[^\"]", &ID, &incX, rout, auth) == 4);
incY = 0;
alpha = beta = AlphaX;
if ( (pre == 'c' || pre == 'z') && incX == 1 ) continue;
if (LineIsCont(ln))
{
assert(fgets(cc, 256, fpin) != NULL);
assert(fgets(ccflags, 512, fpin) != NULL);
FixFlags(cc);
FixFlags(ccflags);
pcc = cc;
pccflags = ccflags;
}
else pcc = pccflags = NULL;
fn = AllocFN(ID, incX, incY, alpha, beta, rout, auth, pcc, pccflags);
if (fp) fp->next = fn;
else fbase = fn;
fp = fn;
}
PrintFN(fbase);
return(fbase);
}
void Compress( u8 const* rgba, void* block, int flags )
{
// fix any bad flags
flags = FixFlags( flags );
// get the block locations
void* colourBlock = block;
void* alphaBock = block;
if( ( flags & ( kDxt3 | kDxt5 ) ) != 0 )
colourBlock = reinterpret_cast< u8* >( block ) + 8;
// create the minimal point set
ColourSet colours( rgba, flags );
// check the compression type and compress colour
if( colours.GetCount() == 1 )
{
// always do a single colour fit
SingleColourFit fit;
fit.SetColourSet( &colours, flags );
fit.Compress( colourBlock );
}
else if( ( flags & kColourRangeFit ) != 0 )
{
// do a range fit
RangeFit fit;
fit.SetColourSet( &colours, flags );
fit.Compress( colourBlock );
}
else
{
// default to a cluster fit
ClusterFit fit;
fit.SetColourSet( &colours, flags );
fit.SetMetric( 1.0f, 1.0f, 1.0f );
fit.Compress( colourBlock );
}
// compress alpha separately if necessary
if( ( flags & kDxt3 ) != 0 )
CompressAlphaDxt3( rgba, alphaBock );
else if( ( flags & kDxt5 ) != 0 )
CompressAlphaDxt5( rgba, alphaBock );
}
void CompressImage( u8 const* rgba, int width, int height, void* blocks, int flags )
{
// fix any bad flags
flags = FixFlags( flags );
// initialise the block output
u8* targetBlock = reinterpret_cast< u8* >( blocks );
int bytesPerBlock = ( ( flags & kDxt1 ) != 0 ) ? 8 : 16;
int bh = std::min(width, 4);
int bw = std::min(height, 4);
// loop over blocks
for( int y = 0; y < height; y += 4 )
{
for( int x = 0; x < width; x += 4 )
{
// build the 4x4 block of pixels
u8 sourceRgba[16*4];
u8* targetPixel = sourceRgba;
for( int py = 0; py < 4; ++py )
{
for( int px = 0; px < 4; ++px )
{
// get the source pixel in the image
int sx = x + (px % bw);
int sy = y + (py % bh);
// copy the rgba value
u8 const* sourcePixel = rgba + 4*( width*sy + sx );
for( int i = 0; i < 4; ++i )
*targetPixel++ = *sourcePixel++;
}
}
// compress it into the output
Compress( sourceRgba, targetBlock, flags );
// advance
targetBlock += bytesPerBlock;
}
}
}
void Decompress( u8* rgba, void const* block, int flags )
{
// fix any bad flags
flags = FixFlags( flags );
// get the block locations
void const* colourBlock = block;
void const* alphaBock = block;
if( ( flags & ( kDxt3 | kDxt5 ) ) != 0 )
colourBlock = reinterpret_cast< u8 const* >( block ) + 8;
// decompress colour
DecompressColour( rgba, colourBlock, ( flags & kDxt1 ) != 0 );
// decompress alpha separately if necessary
if( ( flags & kDxt3 ) != 0 )
DecompressAlphaDxt3( rgba, alphaBock );
else if( ( flags & kDxt5 ) != 0 )
DecompressAlphaDxt5( rgba, alphaBock );
}
void DecompressImage( u8* rgba, int width, int height, void const* blocks, int flags, ProgressFn progressFn )
{
// fix any bad flags
flags = FixFlags( flags );
// initialise the block input
u8 const* source = reinterpret_cast< u8 const* >( blocks );
int bytesPerBlock = ( ( flags & kDxt1 ) != 0 ) ? 8 : 16;
int progress = 0;
if (progressFn != NULL)
{
progressFn(height, height);
}
// loop over blocks
#ifdef SQUISH_USE_OPENMP
#pragma omp parallel for shared(progress)
#endif
for( int y = 0; y < height; y += 4 )
{
for( int x = 0; x < width; x += 4 )
{
// decompress the block
int blockNum = (((width + 3) / 4) * (y / 4)) + (x / 4);
u8 const* sourceBlock = source + (bytesPerBlock * blockNum);
u8 targetRgba[4*16];
Decompress( targetRgba, sourceBlock, flags );
// write the decompressed pixels to the correct image locations
u8 const* sourcePixel = targetRgba;
for( int py = 0; py < 4; ++py )
{
for( int px = 0; px < 4; ++px )
{
// get the target location
int sx = x + px;
int sy = y + py;
if( sx < width && sy < height )
{
u8* targetPixel = rgba + 4*( width*sy + sx );
// copy the rgba value
for( int i = 0; i < 4; ++i )
*targetPixel++ = *sourcePixel++;
}
else
{
// skip this pixel as its outside the image
sourcePixel += 4;
}
}
}
#ifdef SQUISH_USE_OPENMP
#pragma omp atomic
#endif
progress += 4;
if (progressFn != NULL)
{
progressFn(progress, height);
}
}
}
if (progressFn != NULL)
{
progressFn(height, height);
}
}
void CompressImage( u8 const* rgba, int width, int height, void* blocks, int flags, ProgressFn progressFn )
{
// fix any bad flags
flags = FixFlags( flags );
// initialise the block output
u8* targetBlock = reinterpret_cast< u8* >( blocks );
int bytesPerBlock = ( ( flags & kDxt1 ) != 0 ) ? 8 : 16;
int progress = 0;
if (progressFn != NULL)
{
progressFn(0, height);
}
// loop over blocks
#ifdef SQUISH_USE_OPENMP
#pragma omp parallel for shared(progress)
#endif
for( int y = 0; y < height; y += 4 )
{
for( int x = 0; x < width; x += 4 )
{
// build the 4x4 block of pixels
u8 sourceRgba[16*4];
u8* targetPixel = sourceRgba;
int mask = 0;
for( int py = 0; py < 4; ++py )
{
for( int px = 0; px < 4; ++px )
{
// get the source pixel in the image
int sx = x + px;
int sy = y + py;
// enable if we're in the image
if( sx < width && sy < height )
{
// copy the rgba value
u8 const* sourcePixel = rgba + 4*( width*sy + sx );
for( int i = 0; i < 4; ++i )
*targetPixel++ = *sourcePixel++;
// enable this pixel
mask |= ( 1 << ( 4*py + px ) );
}
else
{
// skip this pixel as its outside the image
targetPixel += 4;
}
}
}
// compress it into the output
int blockNum = (((width + 3) / 4) * (y / 4)) + (x / 4);
u8* outputBlock = targetBlock + (bytesPerBlock * blockNum);
CompressMasked( sourceRgba, mask, outputBlock, flags );
}
#ifdef SQUISH_USE_OPENMP
#pragma omp atomic
#endif
progress += 4;
if (progressFn != NULL)
{
progressFn(progress, height);
}
}
if (progressFn != NULL)
{
progressFn(height, height);
}
}
