예제 #1
0
파일: room.c 프로젝트: oitofelix/mininim
ALLEGRO_COLOR
selection_palette (ALLEGRO_COLOR c)
{
  unsigned char r, g, b, a;
  al_unmap_rgba (c, &r, &g, &b, &a);
  if (a == 0) return c;

  signed char d;
  if (vm == CGA && ! hgc) d = -128;
  else if (vm == CGA && hgc && em == DUNGEON) d = -96;
  else if (vm == VGA && em == PALACE) d = +32;
  else d = +64;

  r = add_char (r, d);
  g = add_char (g, d);
  b = add_char (b, d);
  return al_map_rgb (r, g, b);
}
예제 #2
0
void pp2_intro_setup(void)
{
	int i, j, r;
	ALLEGRO_COLOR color;
	unsigned char cr, cg, cb, ca;

	/* find all pixels */
	for(i = 0; i < 40; i++)
	{
		for(j = 0; j < 40; j++)
		{
			color = al_get_pixel(pp2_bitmap[PP2_BITMAP_T3_LOGO_MEMORY], j * 10 + 5, i * 10 + 5);
			al_unmap_rgba(color, &cr, &cg, &cb, &ca);
			if(ca == 255)
			{
				pp2_intro_pixel[pp2_intro_pixels].x = j * 10 + 120;
				pp2_intro_pixel[pp2_intro_pixels].y = i * 10 + 40;
				pp2_intro_pixel[pp2_intro_pixels].color = color;
				pp2_intro_pixel_list[pp2_intro_pixel_list_size] = pp2_intro_pixels;
				pp2_intro_pixel_list_size++;
				pp2_intro_pixels++;
			}
		}
	}

	/* place pixels */
	for(i = 0; i < pp2_intro_pixels; i++)
	{
		r = rand() % pp2_intro_pixel_list_size;
		pp2_intro_pixel[pp2_intro_pixel_list[r]].vz = 5.0 + (i * 0.05);
		pp2_intro_pixel[pp2_intro_pixel_list[r]].z = 0.0;
		for(j = 0; j < 120 + i / 10; j++)
		{
			pp2_intro_pixel[pp2_intro_pixel_list[r]].z -= pp2_intro_pixel[pp2_intro_pixel_list[r]].vz;
		}

		for(j = r; j < pp2_intro_pixel_list_size - 1; j++)
		{
			pp2_intro_pixel_list[j] = pp2_intro_pixel_list[j + 1];
		}
		pp2_intro_pixel_list_size--;
	}
	qsort(pp2_intro_pixel, pp2_intro_pixels, sizeof(PP2_INTRO_PIXEL), pixel_sorter);
}
예제 #3
0
/* get_dib_from_bitmap_32:
 *  Creates a Windows device-independent bitmap (DIB) from an Allegro BITMAP.
 *  You have to free the memory allocated by this function.
 *
 *  This version always creates a 32-bit DIB.
 */
static BYTE *get_dib_from_bitmap_32(ALLEGRO_BITMAP *bitmap)
{
   int w, h;
   int x, y;
   int pitch;
   BYTE *pixels;
   BYTE *dst;

   w = al_get_bitmap_width(bitmap);
   h = al_get_bitmap_height(bitmap);
   pitch = w * 4;

   pixels = (BYTE *) al_malloc(h * pitch);
   if (!pixels)
      return NULL;

   for (y = 0; y < h; y++) {
      dst = pixels + y * pitch;

      for (x = 0; x < w; x++) {
         ALLEGRO_COLOR col;
         unsigned char r, g, b, a;

         col = al_get_pixel(bitmap, x, y);
         al_unmap_rgba(col, &r, &g, &b, &a);

         /* BGR */
         dst[0] = b;
         dst[1] = g;
         dst[2] = r;
         dst[3] = a;

         dst += 4;
      }
   }

   return pixels;
}
예제 #4
0
파일: guard.c 프로젝트: allisson128/mininim
static ALLEGRO_COLOR
e_dark_red_palette (ALLEGRO_COLOR c)
{
    /* honor transparency */
    unsigned char r, g, b, a;
    al_unmap_rgba (c, &r, &g, &b, &a);
    if (a == 0) return c;

    /* KID */
    if (color_eq (c, E_KID_CLOTHES_COLOR_01)) return E_KID_SHADOW_CLOTHES_COLOR_01;
    if (color_eq (c, E_KID_CLOTHES_COLOR_02)) return E_KID_SHADOW_CLOTHES_COLOR_02;
    if (color_eq (c, E_KID_SKIN_COLOR)) return E_KID_SHADOW_SKIN_COLOR;
    if (color_eq (c, E_KID_HAIR_COLOR)) return E_KID_SHADOW_HAIR_COLOR;
    if (color_eq (c, E_KID_EYE_COLOR)) return E_KID_SHADOW_EYE_COLOR;

    /* SKELETON */
    if (color_eq (c, SKELETON_COLOR)) return E_SKELETON_COLOR;

    /* GUARD, FAT_GUARD, VIZIER */
    if (color_eq (c, GUARD_SHOES_COLOR)) return E_DARK_RED_GUARD_SHOES_COLOR;
    if (color_eq (c, GUARD_PANTS_COLOR_01)) return E_DARK_RED_GUARD_PANTS_COLOR_01;
    if (color_eq (c, GUARD_PANTS_COLOR_02)) return E_DARK_RED_GUARD_PANTS_COLOR_02;
    if (color_eq (c, GUARD_CAPE_COLOR_01)) return E_DARK_RED_GUARD_CAPE_COLOR_01;
    if (color_eq (c, GUARD_CAPE_COLOR_02)) return E_DARK_RED_GUARD_CAPE_COLOR_02;
    if (color_eq (c, GUARD_CAPE_COLOR_03)) return E_DARK_RED_GUARD_CAPE_COLOR_03;
    if (color_eq (c, GUARD_BELT_COLOR)) return E_DARK_RED_GUARD_BELT_COLOR;
    if (color_eq (c, GUARD_HAT_COLOR_01)) return E_DARK_RED_GUARD_HAT_COLOR_01;
    if (color_eq (c, GUARD_HAT_COLOR_02)) return E_DARK_RED_GUARD_HAT_COLOR_02;
    if (color_eq (c, GUARD_SKIN_COLOR_01)) return E_DARK_RED_GUARD_SKIN_COLOR_01;
    if (color_eq (c, GUARD_SKIN_COLOR_02)) return E_DARK_RED_GUARD_SKIN_COLOR_02;
    if (color_eq (c, GUARD_EYES_COLOR)) return E_DARK_RED_GUARD_EYES_COLOR;
    if (color_eq (c, GUARD_CLOSED_EYES_COLOR)) return E_DARK_RED_GUARD_CLOSED_EYES_COLOR;
    if (color_eq (c, GUARD_BLOOD_COLOR)) return E_DARK_RED_GUARD_BLOOD_COLOR;
    if (color_eq (c, GUARD_SPLASH_COLOR)) return E_DARK_RED_GUARD_SPLASH_COLOR;
    return c;
}
예제 #5
0
파일: buttons.c 프로젝트: 0ctobyte/speedrun
BUTTONPTR create_new_button(char *label, char *bimage_label,
                            char *text, ALLEGRO_FONT *font,
                            ALLEGRO_COLOR text_color, ALLEGRO_COLOR button_color,
                            float x, float y, float limit,
                            CBANIMATIONS aflags, BPROPERTIES bflags,
                            _Bool add_to_list)
{
    BUTTONPTR newptr;
    BIMAGESPTR bcurrentptr = search_button_image_list_for_element(bitoptr, bimage_label);
    unsigned char r, g, b, a;
    if((newptr = (BUTTONPTR)malloc(sizeof(BUTTON))) == NULL) return NULL;

    newptr->blabel = label;
    newptr->bimage = bcurrentptr;
    newptr->btext.text = text;
    newptr->btext.text_f = font;
    newptr->btext.text_c = text_color;
    newptr->bdata.x = x;
    newptr->bdata.y = y;
    newptr->bdata.ox = x;
    newptr->bdata.oy = y;
    newptr->bdata.limit = limit;
    newptr->bdata.b_color = button_color;
    newptr->bdata.sflags = 0;
    newptr->bdata.aflags = aflags;
    newptr->bdata.bflags = bflags;

    al_unmap_rgba(newptr->bdata.b_color, &r, &g, &b, &a);

    newptr->bdata.alpha = a;

    if(add_to_list)
        add_element_to_button_list(&newptr);

    return newptr;
}
예제 #6
0
Color::Color(ALLEGRO_COLOR color)
{
	al_unmap_rgba(color, &r, &g, &b, &a);
}
예제 #7
0
/* [gtk thread] */
static GtkWidget *build_menu_item(ALLEGRO_MENU_ITEM *aitem)
{
   GtkWidget *gitem;
   
   if (!aitem->caption) {
      gitem = gtk_separator_menu_item_new();
   }
   else {
      ALLEGRO_USTR *caption = al_ustr_dup(aitem->caption);
      
      /* convert & to _ using unprintable chars as placeholders */
      al_ustr_find_replace_cstr(caption, 0, "_", "\x01\x02");
      al_ustr_find_replace_cstr(caption, 0, "&", "_");
      al_ustr_find_replace_cstr(caption, 0, "\x01\x02", "__");
      
      if (aitem->flags & ALLEGRO_MENU_ITEM_CHECKBOX) {
         gitem = gtk_check_menu_item_new_with_mnemonic(al_cstr(caption));
         gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gitem), aitem->flags & ALLEGRO_MENU_ITEM_CHECKED);
         g_signal_connect_swapped (gitem, "toggled", G_CALLBACK(checkbox_on_toggle),
            (gpointer) aitem);
      }
      else {
         /* always create an image menu item, in case the user ever sets an icon */
         gitem = gtk_image_menu_item_new_with_mnemonic(al_cstr(caption));
         
         if (aitem->icon) {
            const int w = al_get_bitmap_width(aitem->icon), h = al_get_bitmap_height(aitem->icon);
            const int stride = w * 4;
            int x, y, i;
            GdkPixbuf *pixbuf;
            uint8_t *data = al_malloc(stride * h);
            
            if (data) {
               for (y = 0, i = 0; y < h; ++y) {
                  for (x = 0; x < w; ++x, i += 4) {
                     al_unmap_rgba(al_get_pixel(aitem->icon, x, y),
                        &data[i],
                        &data[i + 1],
                        &data[i + 2],
                        &data[i + 3]
                     );
                  }
               }
               
               pixbuf = gdk_pixbuf_new_from_data (data, GDK_COLORSPACE_RGB, TRUE, 8,
                  w, h, stride, destroy_pixbuf, NULL);
               
               aitem->extra2 = gtk_image_new_from_pixbuf(pixbuf);
               
               gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(gitem), aitem->extra2);
               
               /* Subtract the main reference. the image still holds a reference, so the
                * pixbuf won't be destroyed until the image itself is. */
               g_object_unref(pixbuf);
            }
         }
      }
      
      al_ustr_free(caption);
      
      gtk_widget_set_sensitive(gitem, !(aitem->flags & ALLEGRO_MENU_ITEM_DISABLED));
      
      aitem->extra1 = gitem;
      
      if (aitem->popup) {
         GtkWidget *gsubmenu = gtk_menu_new();
         build_menu(gsubmenu, aitem->popup);
         aitem->popup->extra1 = gsubmenu;
         gtk_widget_show(gsubmenu);
         gtk_menu_item_set_submenu(GTK_MENU_ITEM(gitem), gsubmenu);
      }
      else if (aitem->id) {
         g_signal_connect_swapped (gitem, "activate",
            G_CALLBACK(menuitem_response), (gpointer) aitem);
      }
   }
      
   gtk_widget_show(gitem);
   
   return gitem;
}
예제 #8
0
static bool init_nine_patch_side(NINE_PATCH_SIDE *ps, ALLEGRO_BITMAP *bmp, int vertical)
{
	const int len = vertical ? al_get_bitmap_height(bmp) : al_get_bitmap_width(bmp);
	int i, s, t, n, z;
	ALLEGRO_COLOR c;

	int alloc = 8;

	ps->m = al_malloc(alloc * sizeof(*ps->m));

	for (i = 1, s = -1, t = 0, n = 0, z = -1; i < len; ++i)
	{
		int zz;
		uint8_t r, g, b, a;
		c = vertical ? al_get_pixel(bmp, 0, i) : al_get_pixel(bmp, i, 0);
		al_unmap_rgba(c, &r, &g, &b, &a);

		if (i == len - 1)
			zz = -1;
		else if (r == 0 && g == 0 && b == 0 && a == 255)
			zz = 0;
		else if (a == 0 || r + g + b + a == 255 * 4)
			zz = 1;
		else
			return false;

		if (z != zz)
		{
			if (s != -1)
			{
				ps->m[n].offset = s;
				ps->m[n].length = i - s;
				if (z == 0)
				{
					ps->m[n].ratio = 1;
					t += ps->m[n].length;
				}
				else
				{
					ps->m[n].ratio = 0;
				}
				++n;
			}
			s = i;
			z = zz;
		}

		if (n == alloc)
		{
			alloc *= 2;
			ps->m = al_realloc(ps->m, alloc * sizeof(*ps->m));
		}
	}

	if (n != alloc)
	{
		ps->m = al_realloc(ps->m, n * sizeof(*ps->m));
	}

	ps->count = n;

	ps->fix = len - 2 - t;
	for (i = 0; i < n; ++i)
	{
		if (ps->m[i].ratio)
			ps->m[i].ratio = ps->m[i].length / (float) t;
	}

	return true;
}
예제 #9
0
파일: Color.hpp 프로젝트: SpaceManiac/ALX
 /**
     assignment from allegro color.
     @param color color.
     @return reference to this.
  */
 Color &operator = (const ALLEGRO_COLOR &color) {
     al_unmap_rgba(color, &m_color.m_red, &m_color.m_green, &m_color.m_blue, &m_color.m_alpha);
     return *this;
 }
예제 #10
0
int main(int argc, char **argv)
{
	al_init();
	al_init_image_addon();

	al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP | ALLEGRO_NO_PREMULTIPLIED_ALPHA);
	al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ZERO);

	ALLEGRO_BITMAP *tilemap = al_load_bitmap(argv[1]);
	ALLEGRO_BITMAP *result = al_create_bitmap(1024, 1024);

	al_set_target_bitmap(result);
	al_clear_to_color(al_map_rgba(0, 0, 0, 0));

	int tx = 0, ty = 0;
	int mx = 0, my = 0;

	int mapping[(512/16)*(2048/16)];
	memset(mapping, 0, sizeof(mapping));
	int i = 0;
	mapping[i++] = 0;
	mx = 16;

	for (int y = 0; y < 2048/16; y++) {
		int x;
		if (y == 0) x = 1;
		else x = 0;
		for (; x < 512/16; x++) { // 1 == skip first alpha img
			int ox = x * 16;
			int oy = y * 16;
			bool all_alpha = true;
			// FIXME: tile index 96 is all alpha and still in the packed.png. keep for legacy reasons.
			if (i == 96) {
				all_alpha = false;
			}
			else {
				for (int py = 0; py < 16; py++) {
					for (int px = 0; px < 16; px++) {
						ALLEGRO_COLOR pix = al_get_pixel(tilemap, px+ox, py+oy);
						unsigned char r, g, b, a;
						al_unmap_rgba(pix, &r, &g, &b, &a);
						if (!(a == 0)) {
							all_alpha = false;
							break;
						}
					}
					if (!all_alpha) break;
				}
			}
			if (!all_alpha) {
				mapping[(y*32)+x] = i++;
				if (ox == 0 && oy == (3*16)) {
				}
				else {
					al_draw_bitmap_region(tilemap, ox, oy,
						16, 16, mx, my, 0);
				}
				mx += 16;
				if (mx == 1024) {
					mx = 0;
					my += 16;
				}
			}
		}
	}

	printf("int mapping[4096] = {\n\t");
	for (int i = 0; i < 4096; i++) {
		if ((i % 10) == 0)
			printf(",\n\t");
		else
			printf(", ");
		printf("%4d", mapping[i]);
	}
	printf("\n};\n");

	al_save_bitmap("packed.png", result);
}
예제 #11
0
파일: buttons.c 프로젝트: 0ctobyte/speedrun
BUTTONPTR standard_button_animations(BUTTONPTR button)
{
    const int dx = 1, dy = 1, limit = 20;
    unsigned char r, g, b, a;
    al_unmap_rgba(button->bdata.b_color, &r, &g, &b, &a);
    if((button->bdata.bflags & BMOUSEOVER))
    {
        button->bdata.b_color = BCOLOR(r, g, b, 255);
        switch(sb)
        {
            default:
            case SBLEFT:
            case SBRIGHT:
            case SBUP:
            case SBDOWN:
            case SBNONE:
            break;
            case BBOUNCEHORZ:
            {
                if(button->bdata.sflags == SBRIGHT)
                    button->bdata.x += dx;
                else if(button->bdata.sflags == SBLEFT)
                    button->bdata.x -= dx;
                if(button->bdata.x >= button->bdata.ox+limit)
                    button->bdata.sflags = SBLEFT;
                if(button->bdata.x <= button->bdata.ox-limit)
                    button->bdata.sflags = SBRIGHT;
                if(button->bdata.sflags == 0)
                    button->bdata.sflags = SBRIGHT;
            }
            break;
            case BSHIFTRIGHT:
            {
                if(button->bdata.x < button->bdata.ox+limit)
                    button->bdata.x += 1;
            }
            break;
            case BSHIFTLEFT:
            {
                if(button->bdata.x > button->bdata.ox-limit)
                    button->bdata.x -= 1;
            }
            break;
            case BBOUNCEVERT:
            {
                if(button->bdata.sflags == SBDOWN)
                    button->bdata.y += dy;
                else if(button->bdata.sflags == SBUP)
                    button->bdata.y -= dy;
                if(button->bdata.y >= button->bdata.oy+limit)
                    button->bdata.sflags = SBUP;
                if(button->bdata.y <= button->bdata.oy-limit)
                    button->bdata.sflags = SBDOWN;
                if(button->bdata.sflags == 0)
                    button->bdata.sflags = SBDOWN;
            }
        }
    }
    else
    {
       button->bdata.b_color = BCOLOR(r, g, b, button->bdata.alpha);
       button->bdata.sflags = 0;
       if(button->bdata.x > button->bdata.ox)
            button->bdata.x -= 1;
       if(button->bdata.x < button->bdata.ox)
            button->bdata.x += 1;
       if(button->bdata.y > button->bdata.oy)
            button->bdata.y -= 1;
       if(button->bdata.y < button->bdata.oy)
            button->bdata.y += 1;
    }
    return button;
}
예제 #12
0
HICON _al_win_create_icon(HWND wnd,
   ALLEGRO_BITMAP *sprite, int xfocus, int yfocus, bool is_cursor, bool resize)
{
   int x, y;
   int sys_sm_cx, sys_sm_cy;
   HDC h_dc;
   HDC h_and_dc;
   HDC h_xor_dc;
   ICONINFO iconinfo;
   HBITMAP and_mask;
   HBITMAP xor_mask;
   HBITMAP hOldAndMaskBitmap;
   HBITMAP hOldXorMaskBitmap;
   HICON icon;

   if (resize) {
      if (is_cursor) {
         /* Get allowed cursor size - Windows can't make cursors of arbitrary size */
         sys_sm_cx = GetSystemMetrics(SM_CXCURSOR);
         sys_sm_cy = GetSystemMetrics(SM_CYCURSOR);
      }
      else {
         sys_sm_cx = GetSystemMetrics(SM_CXICON);
         sys_sm_cy = GetSystemMetrics(SM_CYICON);
      }

      if ((sprite->w > sys_sm_cx) || (sprite->h > sys_sm_cy)) {
         return NULL;
      }
   }
   else {
      sys_sm_cx = al_get_bitmap_width(sprite);
      sys_sm_cy = al_get_bitmap_height(sprite);
   }

   /* Create bitmap */
   h_dc = GetDC(wnd);
   h_xor_dc = CreateCompatibleDC(h_dc);
   h_and_dc = CreateCompatibleDC(h_dc);

   /* Prepare AND (monochrome) and XOR (colour) mask */
   and_mask = CreateBitmap(sys_sm_cx, sys_sm_cy, 1, 1, NULL);
   xor_mask = CreateCompatibleBitmap(h_dc, sys_sm_cx, sys_sm_cy);
   hOldAndMaskBitmap = (HBITMAP) SelectObject(h_and_dc, and_mask);
   hOldXorMaskBitmap = (HBITMAP) SelectObject(h_xor_dc, xor_mask);

   /* Create transparent cursor */
   for (y = 0; y < sys_sm_cy; y++) {
      for (x = 0; x < sys_sm_cx; x++) {
	 SetPixel(h_and_dc, x, y, WINDOWS_RGB(255, 255, 255));
	 SetPixel(h_xor_dc, x, y, WINDOWS_RGB(0, 0, 0));
      }
   }

   local_draw_to_hdc(h_xor_dc, sprite, 0, 0);

   /* Make cursor background transparent */
   for (y = 0; y < sprite->h; y++) {
      for (x = 0; x < sprite->w; x++) {
         ALLEGRO_COLOR c;
         unsigned char r, g, b, a;

         c = al_get_pixel(sprite, x, y);
         al_unmap_rgba(c, &r, &g, &b, &a);
         if (a != 0) {
	    /* Don't touch XOR value */
	    SetPixel(h_and_dc, x, y, 0);
	 }
	 else {
	    /* No need to touch AND value */
	    SetPixel(h_xor_dc, x, y, WINDOWS_RGB(0, 0, 0));
	 }
      }
   }

   SelectObject(h_and_dc, hOldAndMaskBitmap);
   SelectObject(h_xor_dc, hOldXorMaskBitmap);
   DeleteDC(h_and_dc);
   DeleteDC(h_xor_dc);
   ReleaseDC(wnd, h_dc);

   iconinfo.fIcon = is_cursor ? false : true;
   iconinfo.xHotspot = xfocus;
   iconinfo.yHotspot = yfocus;
   iconinfo.hbmMask = and_mask;
   iconinfo.hbmColor = xor_mask;

   icon = CreateIconIndirect(&iconinfo);

   DeleteObject(and_mask);
   DeleteObject(xor_mask);

   return icon;
}