VECBITMAP<unsigned char> *bitmap_to_patches(Params *p, BITMAP *a) {
//int n = -1, d = -1;
//unsigned char *data = im2patches_ub(a, p->patch_w, n, d);
//VECBITMAP<unsigned char> *ans = new VECBITMAP<unsigned char>();
//ans->w = a->w;
//ans->h = a->h;
//ans->n = d;
//ans->data = data;
if (p->vec_len != p->patch_w*p->patch_w*3) { fprintf(stderr, "vec_len (%d) != 3*patch_w**2 (%d)\n", p->vec_len, p->patch_w*p->patch_w*3); exit(1); }
VECBITMAP<unsigned char> *ans = new VECBITMAP<unsigned char>(a->w, a->h, p->vec_len);
unsigned char *ptr = ans->data;
for (int y = 0; y < a->h; y++) {
for (int x = 0; x < a->w; x++) {
for (int dy = 0; dy < p->patch_w; dy++) {
for (int dx = 0; dx < p->patch_w; dx++) {
int xp = x+dx, yp = y+dy;
if (xp >= a->w) { xp = a->w - 1; }
if (yp >= a->h) { yp = a->h - 1; }
int c = _getpixel32(a, xp, yp);
*ptr++ = getr32(c);
*ptr++ = getg32(c);
*ptr++ = getb32(c);
}
}
}
}
int npatches = ptr - ans->data;
int n = a->w * a->h * p->vec_len;
if (n != npatches) { fprintf(stderr, "n != npatches (%d != %d)\n", n, npatches); exit(1); }
return ans;
}
/* save_rgba:
* Core save routine for 32 bpp images.
*/
static int save_rgba(png_structp png_ptr, BITMAP *bmp)
{
unsigned char *rowdata;
int x, y;
ASSERT(bitmap_color_depth(bmp) == 32);
rowdata = (unsigned char *)malloc(bmp->w * 4);
if (!rowdata)
return 0;
for (y=0; y<bmp->h; y++) {
unsigned char *p = rowdata;
for (x=0; x<bmp->w; x++) {
int c = getpixel(bmp, x, y);
*p++ = getr32(c);
*p++ = getg32(c);
*p++ = getb32(c);
*p++ = geta32(c);
}
png_write_row(png_ptr, rowdata);
}
free(rowdata);
return 1;
}
/* save_truecolour:
* Core save routine for 32 bpp images.
*/
static int save_truecolour(png_structp png_ptr, BITMAP *bmp)
{
unsigned char *row, *p;
int i, j, c;
// [OMAR]
row = malloc(bmp->w * 3);
//row = malloc(bmp->w * 4);
if (!row)
return 0;
for (i=0; i<bmp->h; i++) {
p = row;
for (j = 0; j < bmp->w; j++) {
c = getpixel(bmp, j, i);
*p++ = getr32(c);
*p++ = getg32(c);
*p++ = getb32(c);
// [OMAR]
//*p++ = geta32(c);
}
png_write_row(png_ptr, row);
}
free(row);
return 1;
}
/* worker function for changing the type of an image */
static int do_changetype(DATAFILE *dat, int *param, int type)
{
BITMAP *bmp;
RLE_SPRITE *spr;
int x, y, c, r, g, b;
if ((dat->type != DAT_BITMAP) && (dat->type != DAT_RLE_SPRITE) &&
(dat->type != DAT_C_SPRITE) && (dat->type != DAT_XC_SPRITE)) {
(*param)++;
return D_O_K;
}
if (dat->type == type)
return D_O_K;
if (dat->type == DAT_RLE_SPRITE) {
spr = (RLE_SPRITE *)dat->dat;
bmp = create_bitmap_ex(spr->color_depth, spr->w, spr->h);
clear_to_color(bmp, bmp->vtable->mask_color);
draw_rle_sprite(bmp, spr, 0, 0);
dat->dat = bmp;
destroy_rle_sprite(spr);
}
else if (type == DAT_RLE_SPRITE) {
bmp = (BITMAP *)dat->dat;
spr = get_rle_sprite(bmp);
dat->dat = spr;
destroy_bitmap(bmp);
}
else if ((type == DAT_C_SPRITE) || (type == DAT_XC_SPRITE)) {
bmp = (BITMAP *)dat->dat;
if (bitmap_color_depth(bmp) == 32) {
for (y=0; y<bmp->h; y++) {
for (x=0; x<bmp->w; x++) {
c = getpixel(bmp, x, y);
r = getr32(c);
g = getg32(c);
b = getb32(c);
putpixel(bmp, x, y, makecol32(r, g, b));
}
}
}
}
dat->type = type;
return D_REDRAW;
}
static BITMAP *convert_bitmap_alpha(BITMAP *bmp_orig, bool keep_alpha)
{
if (!bmp_orig) return NULL;
// Non 32bpp bitmap just can't contain alpha channel
if (bitmap_color_depth(bmp_orig) != 32) return bmp_orig;
// Try to detect alpha channel in the bitmap
bool has_alpha = false;
bool has_trans = false;
bool has_opaque = false;
for (int y = 0; y < bmp_orig->h; y++) {
const uint32 *line = (const uint32 *)bmp_orig->line[y];
for (int x = 0; x < bmp_orig->w; x++) {
uint32 a = line[x] & 0xFF000000;
if (a == 0)
has_trans = true;
else if (a == 0xFF000000)
has_opaque = true;
else
has_alpha = true;
}
}
if (has_alpha || keep_alpha) {
for (int x = 0; x < bmp_orig->w; x++)
for (int y = 0; y < bmp_orig->h; y++) {
int c = getpixel(bmp_orig, x, y);
if (geta32(c) == 0)
putpixel(bmp_orig, x, y, MASK_COLOR_32);
}
return bmp_orig;
} else {
bool has_1bit_alpha = has_trans && has_opaque;
BITMAP *bmp = create_bitmap(bmp_orig->w, bmp_orig->h);
clear_to_color(bmp, bitmap_mask_color(bmp));
for (int x = 0; x < bmp_orig->w; x++)
for (int y = 0; y < bmp_orig->h; y++) {
int c = getpixel(bmp_orig, x, y);
if (!has_1bit_alpha || geta32(c) != 0) {
putpixel(bmp, x, y, makeacol(getr32(c), getg32(c), getb32(c), 255));
}
}
destroy_bitmap(bmp_orig);
return bmp;
}
}
/* getg_depth:
* Extracts the green component (ranging 0-255) from a pixel in the format
* being used by the specified color depth.
*/
int getg_depth(int color_depth, int c)
{
switch (color_depth) {
case 8:
return getg8(c);
case 15:
return getg15(c);
case 16:
return getg16(c);
case 24:
return getg24(c);
case 32:
return getg32(c);
}
return 0;
}
void VariableWidthSpriteFontRenderer::Draw(BITMAP *src, BITMAP *dest, int destx, int desty, int srcx, int srcy, int width, int height)
{
long srcWidth, srcHeight, destWidth, destHeight, srcColDepth, destColDepth;
unsigned char **srccharbuffer = _engine->GetRawBitmapSurface (src); //8bit
unsigned short **srcshortbuffer = (unsigned short**)srccharbuffer; //16bit;
unsigned long **srclongbuffer = (unsigned long**)srccharbuffer; //32bit
unsigned char **destcharbuffer = _engine->GetRawBitmapSurface (dest); //8bit
unsigned short **destshortbuffer = (unsigned short**)destcharbuffer; //16bit;
unsigned long **destlongbuffer = (unsigned long**)destcharbuffer; //32bit
int transColor = _engine->GetBitmapTransparentColor(src);
_engine->GetBitmapDimensions(src, &srcWidth, &srcHeight, &srcColDepth);
_engine->GetBitmapDimensions(dest, &destWidth, &destHeight, &destColDepth);
if (srcy + height > srcHeight || srcx + width > srcWidth || srcx < 0 || srcy < 0) return;
if (width + destx > destWidth) width = destWidth - destx;
if (height + desty > destHeight) height = destHeight - desty;
int startx = MAX(0, (-1 * destx));
int starty = MAX(0, (-1 * desty));
int srca, srcr, srcg, srcb, desta, destr, destg, destb, finalr, finalg, finalb, finala, col;
for(int x = startx; x < width; x ++)
{
for(int y = starty; y < height; y ++)
{
int srcyy = y + srcy;
int srcxx = x + srcx;
int destyy = y + desty;
int destxx = x + destx;
if (destColDepth == 8)
{
if (srccharbuffer[srcyy][srcxx] != transColor) destcharbuffer[destyy][destxx] = srccharbuffer[srcyy][srcxx];
}
else if (destColDepth == 16)
{
if (srcshortbuffer[srcyy][srcxx] != transColor) destshortbuffer[destyy][destxx] = srcshortbuffer[srcyy][srcxx];
}
else if (destColDepth == 32)
{
//if (srclongbuffer[srcyy][srcxx] != transColor) destlongbuffer[destyy][destxx] = srclongbuffer[srcyy][srcxx];
srca = (geta32(srclongbuffer[srcyy][srcxx]));
if (srca != 0) {
srcr = getr32(srclongbuffer[srcyy][srcxx]);
srcg = getg32(srclongbuffer[srcyy][srcxx]);
srcb = getb32(srclongbuffer[srcyy][srcxx]);
destr = getr32(destlongbuffer[destyy][destxx]);
destg = getg32(destlongbuffer[destyy][destxx]);
destb = getb32(destlongbuffer[destyy][destxx]);
desta = geta32(destlongbuffer[destyy][destxx]);
finalr = srcr;
finalg = srcg;
finalb = srcb;
finala = 255-(255-srca)*(255-desta)/255;
finalr = srca*finalr/finala + desta*destr*(255-srca)/finala/255;
finalg = srca*finalg/finala + desta*destg*(255-srca)/finala/255;
finalb = srca*finalb/finala + desta*destb*(255-srca)/finala/255;
col = makeacol32(finalr, finalg, finalb, finala);
destlongbuffer[destyy][destxx] = col;
}
}
}
}
_engine->ReleaseBitmapSurface(src);
_engine->ReleaseBitmapSurface(dest);
}
void game_init(int ai)
{
static int once = 1;
int x, y;
BITMAP *tmp;
int bc = makecol(200, 150, 50);
clear_to_color(screen, makecol(0, 0, 0));
textout_centre(screen, font, "Generating&Caching Data", SCREEN_W / 2, 0, -1);
textout_centre(screen, font, "May take a while", SCREEN_W / 2, SCREEN_H / 2, -1);
textout_centre(screen, font, "(about 10 minutes for first run,", SCREEN_W / 2, SCREEN_H / 2 + 20, -1);
textout_centre(screen, font, "about 1 minute every first game,", SCREEN_W / 2, SCREEN_H / 2 + 40, -1);
textout_centre(screen, font, "few seconds else)", SCREEN_W / 2, SCREEN_H / 2 + 60, -1);
if (once) {
once = 0;
animdata[0] = load_gfx("gravburn", 48);
animdata[1] = load_gfx("shock", 48);
animdata[2] = load_gfx("fireball", 48);
animdata[3] = load_gfx("wheel", 48);
animdata[4] = load_gfx("glow", 32);
{
int a;
for (a = 0; a < ANIMS; a++) {
anim[a] = 0;
animlen[a] = dat_length(animdata[a]);
}
}
tower = dat[TOWER_BMP].dat;
explosion = dat[EXPLOSION_WAV].dat;
radiating = dat[RADIATING_WAV].dat;
teleport = dat[TELEPORT_WAV].dat;
bonus = dat[BONUS_WAV].dat;
nuclearegg = dat[NUCLEAREGG_BMP].dat;
launcher = dat[LAUNCHER_BMP].dat;
bonuspic[0] = dat[BONUS0_BMP].dat;
bonuspic[1] = dat[BONUS1_BMP].dat;
bonuspic[2] = dat[BONUS2_BMP].dat;
map = create_bitmap(SCREEN_W, SCREEN_H);
}
ignore[0] = 0;
ignore[1] = 0;
think[0] = 0;
think[1] = 0;
memorized[0] = 0;
memorized[1] = 0;
AI[0] = 0;
if (ai) AI[1] = 1; else AI[1] = 0;
power[0] = 0;
power[1] = 0;
bonusnum = 0;
life[0] = 100;
life[1] = 100;
go = 0;
turn = 0;
tmp = create_bitmap_ex(32, SCREEN_W, SCREEN_H);
draw_back(tmp);
for (y = 0; y < 16; y++) {
for (x = 0; x < 16; x++) {
hills[y][x] = rnd();
}
}
basex[0] = 4 * TW + TW / 2;
basey[0] = 4 * TH + TH / 2;
basex[1] = 12 * TW + TW / 2;
basey[1] = 12 * TH + TH / 2;
hills[4][4] = 1;
hills[5][4] = 1;
hills[5][5] = 1;
hills[4][5] = 1;
hills[12][12] = 1;
hills[13][12] = 1;
hills[13][13] = 1;
hills[12][13] = 1;
x = rnd() * 16;
y = rnd() * 16;
for (y = 0; y < MH; y++) {
for (x = 0; x < MW; x++) {
int c = 0;
int t;
float height = get_height(x, y);
float h = 0, z = height * ZZZ;
for (h = height, t = 0; z > 0 && t < 2; z--, h -= 1.0 / (float)ZZZ, t++) {
int r, g, b;
float l;
if (h < 0.2) {
float p = h / 0.2;
r = 0;
g = 100 * p;
b = 155 + 100 * p;
} else if (h < 0.5) {
float p = (h - 0.2) / 0.3;
r = 0;
g = 100 + 155 * p;
b = 255 - 155 * p;
} else if (h < 0.8) {
float p = (h - 0.5) / 0.3;
r = 200 * p;
g = 255 - 155 * p;
b = 100;
} else {
float p = (h - 0.8) / 0.2;
r = 200;
g = 100 + 100 * p;
b = 100 + 100 * p;
}
l = get_height(x + 1, y) - get_height(x, y + 1);
r = r + l * 2000 + (rnd() - 0.5) * 20;
g = g + l * 2000 + (rnd() - 0.5) * 20;
b = b + l * 2000 + (rnd() - 0.5) * 20;
c = makecol32(M(r), M(g), M(b));
if (y == MH - 1 && h < height) c = bc;
putpixel(tmp, 88 + x, y + WINT - z, c);
}
}
}
{
float filter[3][3] = {
{0.025, 0.145, 0.025},
{0.145, 0.320, 0.145},
{0.025, 0.145, 0.025}
};
for (y = 0; y < SCREEN_H; y++) {
for (x = 0; x < SCREEN_W; x++) {
int i = 0, j = 0;
float r = 0, g = 0, b = 0;
for (i = -1; i <= 1; i++) {
for (j = -1; j <= 1; j++) {
int c = getpixel(tmp, x + j, y + i);
if (c < 0) c = makecol32(0, 0, 0);
r += getr32(c) * filter[1 + i][1 + j];
g += getg32(c) * filter[1 + i][1 + j];
b += getb32(c) * filter[1 + i][1 + j];
}
}
putpixel(map, x, y, makecol(r, g, b));
}
}
}
destroy_bitmap(tmp);
ballx = 240;
bally = 240;
balldx = 0;
balldy = 0;
}
/* main:
* Guess what this function does.
*/
int main(int argc, char *argv[])
{
PACKFILE *f;
CFURLRef cf_url_ref;
FSRef fs_ref;
FSSpec fs_spec;
IconFamilyHandle icon_family;
Handle raw_data;
char datafile[MAX_STRING_SIZE];
char bundle[MAX_STRING_SIZE];
char bundle_dir[MAX_STRING_SIZE];
char bundle_contents_dir[MAX_STRING_SIZE];
char bundle_contents_resources_dir[MAX_STRING_SIZE];
char bundle_contents_macos_dir[MAX_STRING_SIZE];
char bundle_contents_frameworks_dir[MAX_STRING_SIZE];
char *bundle_exe = NULL;
char bundle_plist[MAX_STRING_SIZE];
char bundle_pkginfo[MAX_STRING_SIZE];
char bundle_icns[MAX_STRING_SIZE];
char bundle_version[MAX_STRING_SIZE];
char bundle_long_version[MAX_STRING_SIZE];
char *buffer = NULL;
int arg, type = 0, result = 0;
int i, size, x, y, mask_bit, mask_byte;
unsigned char *data;
install_allegro(SYSTEM_NONE, &errno, &atexit);
set_color_depth(32);
set_color_conversion(COLORCONV_TOTAL | COLORCONV_KEEP_TRANS);
if (argc < 2)
usage();
datafile[0] = '\0';
bundle[0] = '\0';
select_palette(black_palette);
/* Parse command line and load any given resource */
for (arg = 2; arg < argc; arg++) {
if (!strcmp(argv[arg], "-m"))
flags |= F_MOVE;
else if (!strcmp(argv[arg], "-e"))
flags |= F_EMBED_FRAMEWORK;
else if (!strcmp(argv[arg], "-o")) {
if ((argc < arg + 2) || (bundle[0] != '\0'))
usage();
strcpy(bundle, argv[++arg]);
}
else if (!strcmp(argv[arg], "-v")) {
if (argc < arg + 2)
usage();
flags |= F_GOT_VERSION;
strcpy(bundle_version, argv[++arg]);
}
else if (!strcmp(argv[arg], "-V")) {
if (argc < arg + 2)
usage();
flags |= F_GOT_LONG_VERSION;
strcpy(bundle_long_version, argv[++arg]);
}
else if (!strcmp(argv[arg], "-d")) {
if (argc < arg + 2)
usage();
strcpy(datafile, argv[++arg]);
}
else if ((!strcmp(argv[arg], "-16")) || (!strcmp(argv[arg], "-32")) ||
(!strcmp(argv[arg], "-48")) || (!strcmp(argv[arg], "-128"))) {
if (argc < arg + 2)
usage();
switch (atoi(&argv[arg][1])) {
case 16: type = 0; break;
case 32: type = 1; break;
case 48: type = 2; break;
case 128: type = 3; break;
}
if (load_resource(datafile, argv[++arg], &icon_data[type])) {
result = -1;
goto exit_error;
}
}
else {
if (load_resource(datafile, argv[arg], NULL)) {
result = -1;
goto exit_error;
}
}
}
buffer = malloc(4096);
if (!buffer) {
result = -1;
goto exit_error_bundle;
}
bundle_exe = argv[1];
if (!exists(bundle_exe)) {
fprintf(stderr, "Cannot locate executable file '%s'\n", bundle_exe);
result = -1;
goto exit_error;
}
if (bundle[0] == '\0')
strcpy(bundle, bundle_exe);
replace_extension(bundle_dir, bundle, "app", MAX_STRING_SIZE);
strcpy(bundle_contents_dir, bundle_dir);
strcat(bundle_contents_dir, "/Contents");
strcpy(bundle_contents_resources_dir, bundle_contents_dir);
strcat(bundle_contents_resources_dir, "/Resources");
strcpy(bundle_contents_macos_dir, bundle_contents_dir);
strcat(bundle_contents_macos_dir, "/MacOS");
strcpy(bundle_contents_frameworks_dir, bundle_contents_dir);
strcat(bundle_contents_frameworks_dir, "/Frameworks");
bundle_icns[0] = '\0';
bundle_plist[0] = '\0';
bundle_pkginfo[0] = '\0';
/* Create bundle structure */
if ((mkdir(bundle_dir, 0777) && (errno != EEXIST)) ||
(mkdir(bundle_contents_dir, 0777) && (errno != EEXIST)) ||
(mkdir(bundle_contents_resources_dir, 0777) && (errno != EEXIST)) ||
(mkdir(bundle_contents_macos_dir, 0777) && (errno != EEXIST))) {
fprintf(stderr, "Cannot create %s\n", bundle_dir);
result = -1;
goto exit_error_bundle;
}
/* Copy/move executable into the bundle */
if (copy_file(bundle_exe, bundle_contents_macos_dir)) {
fprintf(stderr, "Cannot create %s\n", bundle_contents_macos_dir);
result = -1;
goto exit_error_bundle;
}
strcat(bundle_contents_macos_dir, "/");
strcat(bundle_contents_macos_dir, get_filename(bundle_exe));
chmod(bundle_contents_macos_dir, 0755);
if (flags & F_MOVE)
unlink(bundle_exe);
/* Embed Allegro framework if requested */
if (flags & F_EMBED_FRAMEWORK) {
if (!file_exists("/Library/Frameworks/Allegro.framework", FA_RDONLY | FA_DIREC, NULL)) {
fprintf(stderr, "Cannot find Allegro framework\n");
result = -1;
goto exit_error_bundle;
}
if (!exists("/Library/Frameworks/Allegro.framework/Resources/Embeddable")) {
fprintf(stderr, "Cannot embed system wide Allegro framework; install embeddable version first!\n");
result = -1;
goto exit_error_bundle;
}
sprintf(buffer, "/Developer/Tools/pbxcp -exclude .DS_Store -exclude CVS -resolve-src-symlinks /Library/Frameworks/Allegro.framework %s", bundle_contents_frameworks_dir);
if ((mkdir(bundle_contents_frameworks_dir, 0777) && (errno != EEXIST)) ||
(system(buffer))) {
fprintf(stderr, "Cannot create %s\n", bundle_contents_frameworks_dir);
result = -1;
goto exit_error_bundle;
}
}
/* Setup the .icns resource */
if (flags & F_ICONS_DEFINED) {
strcat(bundle_contents_resources_dir, "/");
strcat(bundle_contents_resources_dir, get_filename(bundle));
replace_extension(bundle_icns, bundle_contents_resources_dir, "icns", MAX_STRING_SIZE);
icon_family = (IconFamilyHandle)NewHandle(0);
for (i = 0; i < 4; i++) {
if (flags & icon_data[i].defined) {
/* Set 32bit RGBA data */
raw_data = NewHandle(icon_data[i].size * icon_data[i].size * 4);
data = *(unsigned char **)raw_data;
for (y = 0; y < icon_data[i].size; y++) {
for (x = 0; x < icon_data[i].size; x++) {
*data++ = geta32(((unsigned int *)(icon_data[i].scaled->line[y]))[x]);
*data++ = getr32(((unsigned int *)(icon_data[i].scaled->line[y]))[x]);
*data++ = getg32(((unsigned int *)(icon_data[i].scaled->line[y]))[x]);
*data++ = getb32(((unsigned int *)(icon_data[i].scaled->line[y]))[x]);
}
}
if (SetIconFamilyData(icon_family, icon_data[i].data, raw_data) != noErr) {
DisposeHandle(raw_data);
fprintf(stderr, "Error setting %dx%d icon resource RGBA data\n", icon_data[i].size, icon_data[i].size);
result = -1;
goto exit_error_bundle;
}
DisposeHandle(raw_data);
/* Set 8bit mask */
raw_data = NewHandle(icon_data[i].size * icon_data[i].size);
data = *(unsigned char **)raw_data;
for (y = 0; y < icon_data[i].size; y++) {
for (x = 0; x < icon_data[i].size; x++) {
*data++ = geta32(((unsigned int *)(icon_data[i].scaled->line[y]))[x]);
}
}
if (SetIconFamilyData(icon_family, icon_data[i].mask8, raw_data) != noErr) {
DisposeHandle(raw_data);
fprintf(stderr, "Error setting %dx%d icon resource 8bit mask\n", icon_data[i].size, icon_data[i].size);
result = -1;
goto exit_error_bundle;
}
DisposeHandle(raw_data);
/* Set 1bit mask */
if (icon_data[i].mask1) {
size = ((icon_data[i].size * icon_data[i].size) + 7) / 8;
raw_data = NewHandle(size * 2);
data = *(unsigned char **)raw_data;
mask_byte = 0;
mask_bit = 7;
for (y = 0; y < icon_data[i].size; y++) {
for (x = 0; x < icon_data[i].size; x++) {
if (geta32(((unsigned int *)(icon_data[i].scaled->line[y]))[x]) >= 0xfd)
mask_byte |= (1 << mask_bit);
mask_bit--;
if (mask_bit < 0) {
*data++ = mask_byte;
mask_byte = 0;
mask_bit = 7;
}
}
}
memcpy(*raw_data + size, *raw_data, size);
if (SetIconFamilyData(icon_family, icon_data[i].mask1, raw_data) != noErr) {
DisposeHandle(raw_data);
fprintf(stderr, "Error setting %dx%d icon resource 1bit mask\n", icon_data[i].size, icon_data[i].size);
result = -1;
goto exit_error_bundle;
}
DisposeHandle(raw_data);
}
}
}
f = pack_fopen(bundle_icns, F_WRITE);
if (!f) {
fprintf(stderr, "Cannot create %s\n", bundle_icns);
result = -1;
goto exit_error_bundle;
}
pack_fclose(f);
cf_url_ref = CFURLCreateWithBytes(kCFAllocatorDefault, (unsigned char *)bundle_icns, strlen(bundle_icns), 0, NULL);
if (!cf_url_ref) {
fprintf(stderr, "Cannot create %s\n", bundle_icns);
result = -1;
goto exit_error_bundle;
}
CFURLGetFSRef(cf_url_ref, &fs_ref);
CFRelease(cf_url_ref);
if ((FSGetCatalogInfo(&fs_ref, kFSCatInfoNone, NULL, NULL, &fs_spec, NULL)) ||
(WriteIconFile(icon_family, &fs_spec) != noErr)) {
fprintf(stderr, "Cannot create %s\n", bundle_icns);
result = -1;
goto exit_error_bundle;
}
DisposeHandle((Handle)icon_family);
}
/* Setup Info.plist */
sprintf(bundle_plist, "%s/Info.plist", bundle_contents_dir);
f = pack_fopen(bundle_plist, F_WRITE);
if (!f) {
fprintf(stderr, "Cannot create %s\n", bundle_plist);
result = -1;
goto exit_error_bundle;
}
sprintf(buffer, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<!DOCTYPE plist PUBLIC \"-//Apple Computer//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
"<plist version=\"1.0\">\n"
"<dict>\n"
"\t<key>CFBundleExecutable</key>\n"
"\t<string>%s</string>\n"
"\t<key>CFBundleInfoDictionaryVersion</key>\n"
"\t<string>6.0</string>\n"
"\t<key>CFBundlePackageType</key>\n"
"\t<string>APPL</string>\n"
"\t<key>CFBundleSignature</key>\n"
"\t<string>%s</string>\n"
"\t<key>CFBundleVersion</key>\n"
"\t<string>%s</string>\n"
"\t<key>CFBundleDocumentTypes</key>\n"
"\t<array>\n"
"\t\t<dict>\n"
"\t\t\t<key>CFBundleTypeExtensions</key>\n"
"\t\t\t<array>\n"
"\t\t\t\t<string>*</string>\n"
"\t\t\t</array>\n"
"\t\t\t<key>CFBundleTypeName</key>\n"
"\t\t\t<string>NSStringPboardType</string>\n"
"\t\t\t<key>CFBundleTypeOSTypes</key>\n"
"\t\t\t<array>\n"
"\t\t\t\t<string>****</string>\n"
"\t\t\t</array>\n"
"\t\t\t<key>CFBundleTypeRole</key>\n"
"\t\t\t<string>Viewer</string>\n"
"\t\t</dict>\n"
"\t</array>\n",
get_filename(bundle_exe), "????", (flags & F_GOT_VERSION) ? bundle_version : "1.0");
pack_fputs(buffer, f);
if (flags & F_GOT_LONG_VERSION) {
sprintf(buffer, "\t<key>CFBundleGetInfoString</key>\n"
"\t<string>%s</string>\n", bundle_long_version);
pack_fputs(buffer, f);
}
if (flags & F_ICONS_DEFINED) {
sprintf(buffer, "\t<key>CFBundleIconFile</key>\n"
"\t<string>%s</string>\n", get_filename(bundle_icns));
pack_fputs(buffer, f);
}
pack_fputs("</dict>\n</plist>\n", f);
pack_fclose(f);
/* Setup PkgInfo */
sprintf(bundle_pkginfo, "%s/PkgInfo", bundle_contents_dir);
f = pack_fopen(bundle_pkginfo, F_WRITE);
if (!f) {
fprintf(stderr, "Cannot create %s\n", bundle_pkginfo);
result = -1;
goto exit_error_bundle;
}
pack_fputs("APPL????", f);
pack_fclose(f);
exit_error:
if (buffer)
free(buffer);
for (i = 0; i < 4; i++) {
if (icon_data[i].original)
destroy_bitmap(icon_data[i].original);
if (icon_data[i].workspace)
destroy_bitmap(icon_data[i].workspace);
if (icon_data[i].scaled)
destroy_bitmap(icon_data[i].scaled);
}
return result;
exit_error_bundle:
sprintf(buffer, "%s/%s", bundle_contents_macos_dir, get_filename(bundle_exe));
unlink(buffer);
unlink(bundle_plist);
unlink(bundle_pkginfo);
unlink(bundle_icns);
rmdir(bundle_dir);
rmdir(bundle_contents_dir);
rmdir(bundle_contents_resources_dir);
rmdir(bundle_contents_macos_dir);
goto exit_error;
}
static int scale_icon(ICON_DATA *icon)
{
BITMAP *shape;
int size, x_ofs = 2, y_ofs = 2;
int x, y, m, n;
int i_x, i_y;
float k, f_x, f_y, a, b, r1, r2;
float red, green, blue, alpha;
unsigned int color;
if (icon->original->w > icon->original->h) {
size = 4 + icon->original->w;
y_ofs = 2 + ((icon->original->w - icon->original->h) / 2);
}
else {
size = 4 + icon->original->h;
x_ofs = 2 + ((icon->original->h - icon->original->w) / 2);
}
k = (float)(size - 4) / (float)icon->size;
icon->workspace = create_bitmap_ex(32, size, size);
if (!icon->workspace)
return -1;
icon->scaled = create_bitmap_ex(32, icon->size, icon->size);
if (!icon->scaled)
return -1;
shape = create_bitmap_ex(32, icon->original->w, icon->original->h);
if (!shape)
return -1;
blit(icon->original, shape, 0, 0, 0, 0, icon->original->w, icon->original->h);
clear_to_color(icon->workspace, makeacol32(0, 0, 0, 255));
shape->vtable->mask_color = makeacol32(255, 0, 255, 0);
masked_blit(shape, icon->workspace, 0, 0, x_ofs, y_ofs, shape->w, shape->h);
destroy_bitmap(shape);
for (y = 0; y < icon->size; y++) {
f_y = (float)y * k;
i_y = (int)floor(f_y);
a = f_y - floor(f_y);
for (x = 0; x < icon->size; x++) {
f_x = (float)x * k;
i_x = (int)floor(f_x);
b = f_x - floor(f_x);
red = green = blue = alpha = 0.0;
for (m = -1; m < 3; m++) {
r1 = cubic_bspline((float)m - a);
for (n = -1; n < 3; n++) {
r2 = cubic_bspline(b - (float)n);
color = ((unsigned int *)(icon->workspace->line[i_y + m + 2]))[i_x + n + 2];
red += ((float)getr32(color) * r1 * r2);
green += ((float)getg32(color) * r1 * r2);
blue += ((float)getb32(color) * r1 * r2);
alpha += ((float)geta32(color) * r1 * r2);
}
}
color = makeacol32((int)floor(red), (int)floor(green), (int)floor(blue), 255 - (int)floor(alpha));
((unsigned int *)(icon->scaled->line[y]))[x] = color;
}
}
return 0;
}