void count_colors(
idx nv,
typename Kokkos::View<color_type * , MyExecSpace> colors,
typename Kokkos::View<idx *, MyExecSpace> histogram,
color_type *numColors){
typedef Kokkos::View<color_type * , MyExecSpace> color_array_type;
typedef Kokkos::View<idx *, MyExecSpace> idx_array_type;
typedef Kokkos::RangePolicy<MyExecSpace> my_exec_space;
color_type nc = 0;
struct count_colors{
color_array_type colors_;
idx_array_type histogram_;
idx nvertex_;
idx increment;
count_colors(color_array_type cs, idx_array_type hs_, idx nv_):
colors_(cs), histogram_(hs_), nvertex_(nv_), increment(1){}
KOKKOS_INLINE_FUNCTION
void operator()(const idx ii, color_type &numCols) const {
idx val = Kokkos::atomic_fetch_add<idx>(&(histogram_[colors_[ii]]), increment);
if (val == 0) numCols++;
}
};
Kokkos::parallel_reduce(
my_exec_space(0, nv),
count_colors(colors, histogram, nv),
nc);
Kokkos::fence();
*numColors = nc;
}
void main(int argc, char *argv[])
{
printf("MKTEXTR 02/11/97\n");
if (argc < 6)
{
printf("MKTEXTR <pcx_file> <map_file>"
" <image_width> <image_height> <n_images>"
" [renumber] [trans_color]\n");
return;
}
pcx_file = argv[1];
out_file = argv[2];
textr_width = atoi(argv[3]);
textr_height = atoi(argv[4]);
ntextr = atoi(argv[5]);
if (argc >= 7)
renumber = atoi(argv[6]);
if (argc == 8)
textr_trans = atoi(argv[7]);
printf(" Input File: %s\n"
"Output File: %s\n"
" width: %d\n"
" height: %d\n"
" count: %d\n",
pcx_file,out_file,textr_width,textr_height,ntextr);
if (renumber != -1)
printf(" renumber: %d\n",renumber);
if (textr_trans != -1)
printf(" trans: %d\n",textr_trans);
loadpcx(pcx_file);
count_colors();
if (renumber != -1)
renumber_image(renumber);
make_maps(out_file);
}
static void reduceImage(uint8_t * image,uint8_t * found_colors,int row,unsigned offsetPal,Fl_Progress *progress,Fl_Window*pwin,unsigned maxCol,unsigned yuv,unsigned alg,bool isSprite=false,bool ditherBefore=true){
if(progress)
progress->maximum(1.0);
unsigned off2=offsetPal*2;
unsigned off3=offsetPal*3;
unsigned colors_found;
unsigned w,h;
unsigned maxPal=maxCol;
unsigned msprt=curSpritemeta;
if(isSprite){
w=currentProject->ms->sps[msprt].width(curSpritegroup);
h=currentProject->ms->sps[msprt].height(curSpritegroup);
currentProject->ms->sps[msprt].spriteGroupToImage(image,curSpritegroup,row,false);
}else{
w=currentProject->tms->maps[currentProject->curPlane].mapSizeW;
h=currentProject->tms->maps[currentProject->curPlane].mapSizeHA;
w*=currentProject->tileC->sizew;
h*=currentProject->tileC->sizeh;
currentProject->tms->maps[currentProject->curPlane].truecolor_to_image(image,row,false);
}
if(progress){
progress->label("Dithering to colorspace");
Fl::check();
}
if((!yuv)&&ditherBefore)
ditherImage(image,w,h,false,true);
if(progress){
progress->label("Quantizing image");
Fl::check();
}
colors_found=count_colors(image,w,h,&found_colors[0],false);
printf("Unique colors %d\n",colors_found);
if (colors_found <= maxCol){
printf("%d colors\n",colors_found);
unsigned offsetTmp=offsetPal;
for (unsigned x=0;x<colors_found;x++){
uint_fast8_t r,g,b;
againFun:
if (currentProject->pal->palType[offsetTmp]){
++offsetTmp;
if(offsetTmp>=maxPal)
goto actullyNeededReduction;
goto againFun;
}
r=found_colors[(x*3)];
g=found_colors[(x*3)+1];
b=found_colors[(x*3)+2];
printf("R=%d G=%d B=%d\n",r,g,b);
if(currentProject->pal->shouldAddCol(offsetTmp,r,g,b,isSprite)){
currentProject->pal->rgbToEntry(r,g,b,offsetTmp);
currentProject->pal->updateRGBindex(offsetTmp);
++offsetTmp;
}
}
if(currentProject->gameSystem==NES)
updateEmphesis();
if(window)
window->redraw();
}else{
actullyNeededReduction:
printf("More than %d colors reducing to %d colors\n",maxCol,maxCol);
uint8_t user_pal[3][256];
uint8_t rgb_pal2[768];
uint8_t rgb_pal3[768];
unsigned colorz=maxCol;
bool can_go_again=true;
uint8_t*imageuse;
uint8_t*output;
if(alg==1)
output=(uint8_t*)malloc(w*h*3);
if(yuv){
imageuse=(uint8_t*)malloc(w*h*3);
uint32_t x,y;
uint8_t*imageptr=image;
uint8_t*outptr=imageuse;
for(y=0;y<h;y++){
for(x=0;x<w;x++){
if(yuv==2){
outptr[0]=CRGB2Y(imageptr[0],imageptr[1],imageptr[2]);
outptr[1]=CRGB2Cb(imageptr[0],imageptr[1],imageptr[2]);
outptr[2]=CRGB2Cr(imageptr[0],imageptr[1],imageptr[2]);
}else{
outptr[0]=RGB2Y(imageptr[0],imageptr[1],imageptr[2]);
outptr[1]=RGB2U(imageptr[0],imageptr[1],imageptr[2]);
outptr[2]=RGB2V(imageptr[0],imageptr[1],imageptr[2]);
}
imageptr+=3;
outptr+=3;
}
}
}else
imageuse=image;
try_again_color:
switch(alg){
case 4:
dl1quant(imageuse,w,h,colorz,user_pal);
break;
case 3:
wu_quant(imageuse,w,h,colorz,user_pal);
break;
case 2:
NEU_wrapper(w,h,imageuse,colorz,user_pal);
break;
case 1:
scolorq_wrapper(imageuse,output,user_pal,w,h,colorz);
break;
default:
dl3quant(imageuse,w,h,colorz,user_pal,true,progress);/*this uses denesis lee's v3 color quant which is found at http://www.gnu-darwin.org/www001/ports-1.5a-CURRENT/graphics/mtpaint/work/mtpaint-3.11/src/quantizer.c*/
}
for (unsigned x=0;x<colorz;x++){
unsigned r,g,b;
if(yuv){
if(yuv==2){
r=CYCbCr2R(user_pal[0][x],user_pal[1][x],user_pal[2][x]);
g=CYCbCr2G(user_pal[0][x],user_pal[1][x],user_pal[2][x]);
b=CYCbCr2B(user_pal[0][x],user_pal[1][x],user_pal[2][x]);
}else{
r=YUV2R(user_pal[0][x],user_pal[1][x],user_pal[2][x]);
g=YUV2G(user_pal[0][x],user_pal[1][x],user_pal[2][x]);
b=YUV2B(user_pal[0][x],user_pal[1][x],user_pal[2][x]);
}
}else{
r=user_pal[0][x];
g=user_pal[1][x];
b=user_pal[2][x];
}
switch(currentProject->gameSystem){
case segaGenesis:
r=nearest_color_index(r);
g=nearest_color_index(g);
b=nearest_color_index(b);
rgb_pal2[(x*3)]=palTab[r];
rgb_pal2[(x*3)+1]=palTab[g];
rgb_pal2[(x*3)+2]=palTab[b];
break;
case NES:
{uint8_t temp=currentProject->pal->to_nes_color_rgb(r,g,b);
uint32_t temp_rgb = nesPalToRgb(temp);
rgb_pal2[(x*3)]=(temp_rgb>>16)&255;
rgb_pal2[(x*3)+1]=(temp_rgb>>8)&255;
rgb_pal2[(x*3)+2]=temp_rgb&255;}
break;
case masterSystem:
case gameGear:
{const uint8_t*palUseTab=currentProject->gameSystem==gameGear?palTabGameGear:palTabMasterSystem;
unsigned colsTab=currentProject->gameSystem==gameGear?16:4;
r=nearestOneChannel(r,palUseTab,colsTab);
g=nearestOneChannel(g,palUseTab,colsTab);
b=nearestOneChannel(b,palUseTab,colsTab);
rgb_pal2[(x*3)]=palUseTab[r];
rgb_pal2[(x*3)+1]=palUseTab[g];
rgb_pal2[(x*3)+2]=palUseTab[b];}
break;
default:
show_default_error
}
}
unsigned new_colors = count_colors(rgb_pal2,colorz,1,rgb_pal3);
printf("Unique colors in palette %u\n",new_colors);
if (new_colors < maxCol){
if (can_go_again == true){
if (colorz != 512)
colorz++;
else
can_go_again=false;
char tmp[1024];
snprintf(tmp,1024,"Found only %d colors trying again with %d",new_colors,colorz);
tmp[sizeof(tmp)-1]=0;
if(pwin){
pwin->copy_label(tmp);
Fl::check();
}
puts(tmp);
goto try_again_color;
}
}
if (new_colors > maxCol){
can_go_again=false;
if(pwin)
pwin->label("Too many colors");
colorz--;
goto try_again_color;
}
unsigned offsetTmp=offsetPal;
for (unsigned x=0;x<maxCol;x++){
againNerd:
if (currentProject->pal->palType[offsetTmp]){
++offsetTmp;
if(offsetTmp>(maxPal+offsetPal)){
if(maxCol>1){
--colorz;
printf("Needed to reduce colors generated due to locked colors %u\n",maxCol);
}else{
fl_alert("Cannot reduce maximum colors to make this happen...aborting");
return;
}
goto try_again_color;
}
goto againNerd;
}
unsigned r=rgb_pal3[x*3],g=rgb_pal3[x*3+1],b=rgb_pal3[x*3+2];
if(currentProject->pal->shouldAddCol(offsetTmp,r,g,b,isSprite)){
memcpy(currentProject->pal->rgbPal+(offsetTmp*3),rgb_pal3+(x*3),3);
currentProject->pal->rgbToEntry(r,g,b,offsetTmp);
++offsetTmp;
}
}
if(currentProject->gameSystem==NES)
updateEmphesis();
if(alg==1){
if(isSprite)
currentProject->ms->sps[msprt].spriteImageToTiles(output,curSpritegroup,row,false);
else
currentProject->tms->maps[currentProject->curPlane].truecolorimageToTiles(output,row,false);
free(output);
}
if(yuv)
free(imageuse);
}
}
void piggy_dump_all()
{
int i, xlat_offset;
PHYSFS_file * fp;
#ifndef RELEASE
PHYSFS_file * fp1;
PHYSFS_file * fp2;
#endif
char * filename;
int data_offset;
int org_offset;
DiskBitmapHeader bmh;
DiskSoundHeader sndh;
int header_offset;
char subst_name[32];
#ifdef NO_DUMP_SOUNDS
Num_sound_files = 0;
Num_sound_files_new = 0;
#endif
// {
// bitmap_index bi;
// bi.index = 614;
// PIGGY_PAGE_IN( bi );
// count_colors( bi.index, &GameBitmaps[bi.index] );
// key_getch();
// }
// {
// bitmap_index bi;
// bi.index = 478;
// PIGGY_PAGE_IN( bi );
// Int3();
// count_colors( bi.index, &GameBitmaps[bi.index] );
// key_getch();
// }
// {
// bitmap_index bi;
// bi.index = 1398;
// PIGGY_PAGE_IN( bi );
// count_colors( bi.index, &GameBitmaps[bi.index] );
// key_getch();
// }
// {
// bitmap_index bi;
// bi.index = 642;
// PIGGY_PAGE_IN( bi );
// count_colors( bi.index, &GameBitmaps[bi.index] );
// key_getch();
// }
// {
// bitmap_index bi;
// bi.index = 529;
// PIGGY_PAGE_IN( bi );
// count_colors( bi.index, &GameBitmaps[bi.index] );
// key_getch();
// }
// exit(0);
//
if ((Num_bitmap_files_new == 0) && (Num_sound_files_new == 0) )
return;
for (i=0; i < Num_bitmap_files; i++ ) {
bitmap_index bi;
bi.index = i;
PIGGY_PAGE_IN( bi );
}
piggy_close_file();
filename = SHAREPATH "descent.pig";
fp = PHYSFSX_openWriteBuffered( filename );
Assert( fp!=NULL );
#ifndef RELEASE
fp1 = PHYSFSX_openWriteBuffered( "piggy.lst" );
fp2 = PHYSFSX_openWriteBuffered( "piggy.all" );
#endif
i = 0;
PHYSFS_write( fp, &i, sizeof(int), 1 );
bm_write_all(fp);
xlat_offset = PHYSFS_tell(fp);
PHYSFS_write( fp, GameBitmapXlat, sizeof(ushort)*MAX_BITMAP_FILES, 1 );
i = PHYSFS_tell(fp);
PHYSFSX_fseek( fp, 0, SEEK_SET );
PHYSFS_write( fp, &i, sizeof(int), 1 );
PHYSFSX_fseek( fp, i, SEEK_SET );
Num_bitmap_files--;
PHYSFS_write( fp, &Num_bitmap_files, sizeof(int), 1 );
Num_bitmap_files++;
PHYSFS_write( fp, &Num_sound_files, sizeof(int), 1 );
header_offset = PHYSFS_tell(fp);
header_offset += ((Num_bitmap_files-1)*sizeof(DiskBitmapHeader)) + (Num_sound_files*sizeof(DiskSoundHeader));
data_offset = header_offset;
for (i=1; i < Num_bitmap_files; i++ ) {
int *size;
grs_bitmap *bmp;
{
char * p, *p1;
p = strchr(AllBitmaps[i].name,'#');
if (p) {
int n;
p1 = p; p1++;
n = atoi(p1);
*p = 0;
#ifndef RELEASE
if (n==0) {
PHYSFSX_printf( fp2, "%s.abm\n", AllBitmaps[i].name );
}
#endif
memcpy( bmh.name, AllBitmaps[i].name, 8 );
Assert( n <= 63 );
bmh.dflags = DBM_FLAG_ABM + n;
*p = '#';
}else {
#ifndef RELEASE
PHYSFSX_printf( fp2, "%s.bbm\n", AllBitmaps[i].name );
#endif
memcpy( bmh.name, AllBitmaps[i].name, 8 );
bmh.dflags = 0;
}
}
bmp = &GameBitmaps[i];
Assert( !(bmp->bm_flags&BM_FLAG_PAGED_OUT) );
#ifndef RELEASE
PHYSFSX_printf( fp1, "BMP: %s, size %d bytes", AllBitmaps[i].name, bmp->bm_rowsize * bmp->bm_h );
#endif
org_offset = PHYSFS_tell(fp);
bmh.offset = data_offset - header_offset;
PHYSFSX_fseek( fp, data_offset, SEEK_SET );
if ( bmp->bm_flags & BM_FLAG_RLE ) {
size = (int *)bmp->bm_data;
PHYSFS_write( fp, bmp->bm_data, sizeof(ubyte), *size );
data_offset += *size;
//bmh.data_length = *size;
#ifndef RELEASE
PHYSFSX_printf( fp1, ", and is already compressed to %d bytes.\n", *size );
#endif
} else {
PHYSFS_write( fp, bmp->bm_data, sizeof(ubyte), bmp->bm_rowsize * bmp->bm_h );
data_offset += bmp->bm_rowsize * bmp->bm_h;
//bmh.data_length = bmp->bm_rowsize * bmp->bm_h;
#ifndef RELEASE
PHYSFSX_printf( fp1, ".\n" );
#endif
}
PHYSFSX_fseek( fp, org_offset, SEEK_SET );
if ( GameBitmaps[i].bm_w > 255 ) {
Assert( GameBitmaps[i].bm_w < 512 );
bmh.width = GameBitmaps[i].bm_w - 256;
bmh.dflags |= DBM_FLAG_LARGE;
} else {
bmh.width = GameBitmaps[i].bm_w;
}
Assert( GameBitmaps[i].bm_h < 256 );
bmh.height = GameBitmaps[i].bm_h;
bmh.flags = GameBitmaps[i].bm_flags;
if (piggy_is_substitutable_bitmap( AllBitmaps[i].name, subst_name )) {
bitmap_index other_bitmap;
other_bitmap = piggy_find_bitmap( subst_name );
GameBitmapXlat[i] = other_bitmap.index;
bmh.flags |= BM_FLAG_PAGED_OUT;
} else {
#ifdef BUILD_PSX_DATA
count_colors( i, &GameBitmaps[i] );
#endif
bmh.flags &= ~BM_FLAG_PAGED_OUT;
}
bmh.avg_color=GameBitmaps[i].avg_color;
PHYSFS_write( fp, &bmh, sizeof(DiskBitmapHeader), 1 ); // Mark as a bitmap
}
for (i=0; i < Num_sound_files; i++ )
{
digi_sound *snd;
snd = &GameSounds[i];
strcpy( sndh.name, AllSounds[i].name );
#ifdef ALLEGRO
sndh.length = GameSounds[i].len;
#else
sndh.length = GameSounds[i].length;
#endif
sndh.offset = data_offset - header_offset;
org_offset = PHYSFS_tell(fp);
PHYSFSX_fseek( fp, data_offset, SEEK_SET );
sndh.data_length = sndh.length;
PHYSFS_write( fp, snd->data, sizeof(ubyte), sndh.length );
data_offset += sndh.length;
PHYSFSX_fseek( fp, org_offset, SEEK_SET );
PHYSFS_write( fp, &sndh, sizeof(DiskSoundHeader), 1 ); // Mark as a bitmap
#ifndef RELEASE
PHYSFSX_printf( fp1, "SND: %s, size %d bytes\n", AllSounds[i].name, sndh.length );
PHYSFSX_printf( fp2, "%s.raw\n", AllSounds[i].name );
#endif
}
PHYSFSX_fseek( fp, xlat_offset, SEEK_SET );
PHYSFS_write( fp, GameBitmapXlat, sizeof(ushort)*MAX_BITMAP_FILES, 1 );
PHYSFS_close(fp);
#ifndef RELEASE
PHYSFSX_printf( fp1, " Dumped %d assorted bitmaps.\n", Num_bitmap_files );
PHYSFSX_printf( fp1, " Dumped %d assorted sounds.\n", Num_sound_files );
PHYSFS_close(fp1);
PHYSFS_close(fp2);
#endif
#ifdef BUILD_PSX_DATA
fp = PHYSFSX_openWriteBuffered( "psx/descent.dat" );
PHYSFS_write( fp, &i, sizeof(int), 1 );
bm_write_all(fp);
PHYSFS_write( fp, GameBitmapXlat, sizeof(ushort)*MAX_BITMAP_FILES, 1 );
PHYSFS_close(fp);
#endif
// Never allow the game to run after building pig.
exit(0);
}
void piggy_dump_all()
{
int i, xlat_offset;
FILE * fp;
#ifndef RELEASE
FILE * fp1;
FILE * fp2;
#endif
char * filename;
int data_offset;
int org_offset;
DiskBitmapHeader bmh;
DiskSoundHeader sndh;
int header_offset;
char subst_name[32];
#ifdef NO_DUMP_SOUNDS
Num_sound_files = 0;
Num_sound_files_new = 0;
#endif
// {
// bitmap_index bi;
// bi.index = 614;
// PIGGY_PAGE_IN( bi );
// count_colors( bi.index, &GameBitmaps[bi.index] );
// key_getch();
// }
// {
// bitmap_index bi;
// bi.index = 478;
// PIGGY_PAGE_IN( bi );
// Int3();
// count_colors( bi.index, &GameBitmaps[bi.index] );
// key_getch();
// }
// {
// bitmap_index bi;
// bi.index = 1398;
// PIGGY_PAGE_IN( bi );
// count_colors( bi.index, &GameBitmaps[bi.index] );
// key_getch();
// }
// {
// bitmap_index bi;
// bi.index = 642;
// PIGGY_PAGE_IN( bi );
// count_colors( bi.index, &GameBitmaps[bi.index] );
// key_getch();
// }
// {
// bitmap_index bi;
// bi.index = 529;
// PIGGY_PAGE_IN( bi );
// count_colors( bi.index, &GameBitmaps[bi.index] );
// key_getch();
// }
// exit(0);
//
if ((Num_bitmap_files_new == 0) && (Num_sound_files_new == 0) )
return;
mprintf( (0, "Paging in all piggy bitmaps..." ));
for (i=0; i < Num_bitmap_files; i++ ) {
bitmap_index bi;
bi.index = i;
PIGGY_PAGE_IN( bi );
}
mprintf( (0, "\n" ));
piggy_close_file();
mprintf( (0, "Creating DESCENT.PIG..." ));
filename = "DESCENT.PIG";
if ( (i=FindArg( "-piggy" )) ) {
filename = Args[i+1];
mprintf( (0, "Dumping alternate pigfile, '%s'\n", filename ));
}
mprintf( (0, "\nDumping bitmaps..." ));
fp = fopen( filename, "wb" );
Assert( fp!=NULL );
#ifndef RELEASE
fp1 = fopen( "piggy.lst", "wt" );
fp2 = fopen( "piggy.all", "wt" );
#endif
i = 0;
fwrite( &i, sizeof(int), 1, fp );
bm_write_all(fp);
xlat_offset = ftell(fp);
fwrite( GameBitmapXlat, sizeof(ushort)*MAX_BITMAP_FILES, 1, fp );
i = ftell(fp);
fseek( fp, 0, SEEK_SET );
fwrite( &i, sizeof(int), 1, fp );
fseek( fp, i, SEEK_SET );
Num_bitmap_files--;
fwrite( &Num_bitmap_files, sizeof(int), 1, fp );
Num_bitmap_files++;
fwrite( &Num_sound_files, sizeof(int), 1, fp );
header_offset = ftell(fp);
header_offset += ((Num_bitmap_files-1)*sizeof(DiskBitmapHeader)) + (Num_sound_files*sizeof(DiskSoundHeader));
data_offset = header_offset;
for (i=1; i < Num_bitmap_files; i++ ) {
int *size;
grs_bitmap *bmp;
{
char * p, *p1;
p = strchr(AllBitmaps[i].name,'#');
if (p) {
int n;
p1 = p; p1++;
n = atoi(p1);
*p = 0;
#ifndef RELEASE
if (n==0) {
fprintf( fp2, "%s.abm\n", AllBitmaps[i].name );
}
#endif
memcpy( bmh.name, AllBitmaps[i].name, 8 );
Assert( n <= 63 );
bmh.dflags = DBM_FLAG_ABM + n;
*p = '#';
}else {
#ifndef RELEASE
fprintf( fp2, "%s.bbm\n", AllBitmaps[i].name );
#endif
memcpy( bmh.name, AllBitmaps[i].name, 8 );
bmh.dflags = 0;
}
}
bmp = &GameBitmaps[i];
Assert( !(bmp->bm_flags&BM_FLAG_PAGED_OUT) );
#ifndef RELEASE
fprintf( fp1, "BMP: %s, size %d bytes", AllBitmaps[i].name, bmp->bm_rowsize * bmp->bm_h );
#endif
org_offset = ftell(fp);
bmh.offset = data_offset - header_offset;
fseek( fp, data_offset, SEEK_SET );
if ( bmp->bm_flags & BM_FLAG_RLE ) {
size = (int *)bmp->bm_data;
fwrite( bmp->bm_data, sizeof(ubyte), *size, fp );
data_offset += *size;
//bmh.data_length = *size;
#ifndef RELEASE
fprintf( fp1, ", and is already compressed to %d bytes.\n", *size );
#endif
} else {
fwrite( bmp->bm_data, sizeof(ubyte), bmp->bm_rowsize * bmp->bm_h, fp );
data_offset += bmp->bm_rowsize * bmp->bm_h;
//bmh.data_length = bmp->bm_rowsize * bmp->bm_h;
#ifndef RELEASE
fprintf( fp1, ".\n" );
#endif
}
fseek( fp, org_offset, SEEK_SET );
if ( GameBitmaps[i].bm_w > 255 ) {
Assert( GameBitmaps[i].bm_w < 512 );
bmh.width = GameBitmaps[i].bm_w - 256;
bmh.dflags |= DBM_FLAG_LARGE;
} else {
bmh.width = GameBitmaps[i].bm_w;
}
Assert( GameBitmaps[i].bm_h < 256 );
bmh.height = GameBitmaps[i].bm_h;
bmh.flags = GameBitmaps[i].bm_flags;
if (piggy_is_substitutable_bitmap( AllBitmaps[i].name, subst_name )) {
bitmap_index other_bitmap;
other_bitmap = piggy_find_bitmap( subst_name );
GameBitmapXlat[i] = other_bitmap.index;
bmh.flags |= BM_FLAG_PAGED_OUT;
//mprintf(( 0, "Skipping bitmap %d\n", i ));
//mprintf(( 0, "Marking '%s' as substitutible\n", AllBitmaps[i].name ));
} else {
#ifdef BUILD_PSX_DATA
count_colors( i, &GameBitmaps[i] );
#endif
bmh.flags &= ~BM_FLAG_PAGED_OUT;
}
bmh.avg_color=GameBitmaps[i].avg_color;
fwrite( &bmh, sizeof(DiskBitmapHeader), 1, fp ); // Mark as a bitmap
}
mprintf( (0, "\nDumping sounds..." ));
for (i=0; i < Num_sound_files; i++ ) {
digi_sound *snd;
snd = &GameSounds[i];
strcpy( sndh.name, AllSounds[i].name );
sndh.length = GameSounds[i].length;
sndh.offset = data_offset - header_offset;
org_offset = ftell(fp);
fseek( fp, data_offset, SEEK_SET );
sndh.data_length = GameSounds[i].length;
fwrite( snd->data, sizeof(ubyte), snd->length, fp );
data_offset += snd->length;
fseek( fp, org_offset, SEEK_SET );
fwrite( &sndh, sizeof(DiskSoundHeader), 1, fp ); // Mark as a bitmap
#ifndef RELEASE
fprintf( fp1, "SND: %s, size %d bytes\n", AllSounds[i].name, snd->length );
fprintf( fp2, "%s.raw\n", AllSounds[i].name );
#endif
}
fseek( fp, xlat_offset, SEEK_SET );
fwrite( GameBitmapXlat, sizeof(ushort)*MAX_BITMAP_FILES, 1, fp );
fclose(fp);
mprintf( (0, "\n" ));
mprintf( (0, " Dumped %d assorted bitmaps.\n", Num_bitmap_files ));
mprintf( (0, " Dumped %d assorted sounds.\n", Num_sound_files ));
#ifndef RELEASE
fprintf( fp1, " Dumped %d assorted bitmaps.\n", Num_bitmap_files );
fprintf( fp1, " Dumped %d assorted sounds.\n", Num_sound_files );
fclose(fp1);
fclose(fp2);
#endif
#ifdef BUILD_PSX_DATA
fp = fopen( "psx/descent.dat", "wb" );
fwrite( &i, sizeof(int), 1, fp );
bm_write_all(fp);
fwrite( GameBitmapXlat, sizeof(ushort)*MAX_BITMAP_FILES, 1, fp );
fclose(fp);
#endif
// Never allow the game to run after building pig.
exit(0);
}
void remap_imagecolors(void)
{
int i;
/* if monochrome, return */
if (tool_cells <= 2 || appres.monochrome)
return;
npixels = 0;
/* first see if there are enough colorcells for all image colors */
usenet = False;
/* see if the total number of colors will fit without using the neural net */
ncolors = count_colors();
if (ncolors == 0)
return;
put_msg(REMAP_MSG);
set_temp_cursor(wait_cursor);
app_flush();
if (ncolors > appres.max_image_colors) {
if (appres.DEBUG)
fprintf(stderr,"More colors (%d) than allowed (%d), using neural net\n",
ncolors,appres.max_image_colors);
ncolors = appres.max_image_colors;
usenet = True;
}
/* if this is the first image, allocate the number of colorcells we need */
if (num_oldcolors != ncolors) {
if (num_oldcolors != -1) {
unsigned long pixels[MAX_USR_COLS];
for (i=0; i<num_oldcolors; i++)
pixels[i] = image_cells[i].pixel;
if (tool_vclass == PseudoColor)
XFreeColors(tool_d, tool_cm, pixels, num_oldcolors, 0);
}
alloc_imagecolors(ncolors);
/* hmm, we couldn't get that number of colors anyway; use the net, Luke */
if (ncolors > avail_image_cols) {
usenet = True;
if (appres.DEBUG)
fprintf(stderr,"More colors (%d) than available (%d), using neural net\n",
ncolors,avail_image_cols);
}
num_oldcolors = avail_image_cols;
if (avail_image_cols < 2 && ncolors >= 2) {
file_msg("Cannot allocate even 2 colors for pictures");
reset_cursor();
num_oldcolors = -1;
reset_cursor();
put_msg(REMAP_MSG2);
app_flush();
return;
}
}
reset_cursor();
if (usenet) {
int stat;
int mult = 1;
/* check if user pressed cancel button (in file preview) */
if (check_cancel())
return;
/* count total number of pixels in all the pictures */
npixels = count_pixels();
/* check if user pressed cancel button */
if (check_cancel())
return;
/* initialize the neural network */
/* -1 means can't alloc memory, -2 or more means must have that many times
as many pixels */
set_temp_cursor(wait_cursor);
if ((stat=neu_init(npixels)) <= -2) {
mult = -stat;
npixels *= mult;
/* try again with more pixels */
stat = neu_init2(npixels);
}
if (stat == -1) {
/* couldn't alloc memory for network */
fprintf(stderr,"Can't alloc memory for neural network\n");
reset_cursor();
put_msg(REMAP_MSG2);
app_flush();
return;
}
/* now add all pixels to the samples */
for (i=0; i<mult; i++)
add_all_pixels();
/* make a new colortable with the optimal colors */
avail_image_cols = neu_clrtab(avail_image_cols);
/* now change the color cells with the new colors */
/* clrtab[][] is the colormap produced by neu_clrtab */
for (i=0; i<avail_image_cols; i++) {
image_cells[i].red = (unsigned short) clrtab[i][N_RED] << 8;
image_cells[i].green = (unsigned short) clrtab[i][N_GRN] << 8;
image_cells[i].blue = (unsigned short) clrtab[i][N_BLU] << 8;
}
YStoreColors(tool_cm, image_cells, avail_image_cols);
reset_cursor();
/* check if user pressed cancel button */
if (check_cancel())
return;
/* get the new, mapped indices for the image colormap */
remap_image_colormap();
} else {
/*
* Extract the RGB values from the image's colormap and allocate
* the appropriate X colormap entries.
*/
scol = 0; /* global color counter */
set_temp_cursor(wait_cursor);
extract_cmap();
for (i=0; i<scol; i++) {
image_cells[i].flags = DoRed|DoGreen|DoBlue;
}
YStoreColors(tool_cm, image_cells, scol);
scol = 0; /* global color counter */
readjust_cmap();
if (appres.DEBUG)
fprintf(stderr,"Able to use %d colors without neural net\n",scol);
reset_cursor();
}
put_msg(REMAP_MSG2);
app_flush();
}
