static ALLEGRO_BITMAP *example_bitmap(int w, int h) { int i, j; float mx = w * 0.5; float my = h * 0.5; ALLEGRO_STATE state; ALLEGRO_BITMAP *pattern = al_create_bitmap(w, h); al_store_state(&state, ALLEGRO_STATE_TARGET_BITMAP); al_set_target_bitmap(pattern); al_lock_bitmap(pattern, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_WRITEONLY); for (i = 0; i < w; i++) { for (j = 0; j < h; j++) { float a = atan2(i - mx, j - my); float d = sqrt(pow(i - mx, 2) + pow(j - my, 2)); float sat = pow(1.0 - 1 / (1 + d * 0.1), 5); float hue = 3 * a * 180 / ALLEGRO_PI; hue = (hue / 360 - floorf(hue / 360)) * 360; al_put_pixel(i, j, al_color_hsv(hue, sat, 1)); } } al_put_pixel(0, 0, al_map_rgb(0, 0, 0)); al_unlock_bitmap(pattern); al_restore_state(&state); return pattern; }
void _al_point_2d(ALLEGRO_BITMAP* texture, ALLEGRO_VERTEX* v) { int shade = 1; int op, src_mode, dst_mode, op_alpha, src_alpha, dst_alpha; ALLEGRO_COLOR vc; int clip_min_x, clip_min_y, clip_max_x, clip_max_y; int x = (int)floorf(v->x); int y = (int)floorf(v->x); al_get_clipping_rectangle(&clip_min_x, &clip_min_y, &clip_max_x, &clip_max_y); clip_max_x += clip_min_x; clip_max_y += clip_min_y; if(x < clip_min_x || x >= clip_max_x || y < clip_min_y || y >= clip_max_y) return; vc = v->color; al_get_separate_blender(&op, &src_mode, &dst_mode, &op_alpha, &src_alpha, &dst_alpha); if (_AL_DEST_IS_ZERO && _AL_SRC_NOT_MODIFIED) { shade = 0; } if (texture) { float U = fix_var(v->u, al_get_bitmap_width(texture)); float V = fix_var(v->v, al_get_bitmap_height(texture)); ALLEGRO_COLOR color = al_get_pixel(texture, U, V); if(vc.r != 1 || vc.g != 1 || vc.b != 1 || vc.a != 1) { color.r *= vc.r; color.g *= vc.g; color.b *= vc.b; color.a *= vc.a; } if (shade) { al_put_blended_pixel(v->x, v->y, color); } else { al_put_pixel(v->x, v->y, color); } } else { ALLEGRO_COLOR color = al_map_rgba_f(vc.r, vc.g, vc.b, vc.a); if (shade) { al_put_blended_pixel(v->x, v->y, color); } else { al_put_pixel(v->x, v->y, color); } } }
void redrawCells(ALLEGRO_BITMAP* pBuffer, bool** pCells, bool** pNextCells, short int iWidth, short int iHeight, ALLEGRO_COLOR oCellColor, ALLEGRO_COLOR oBackColor) { al_lock_bitmap(pBuffer, al_get_bitmap_format(pBuffer), ALLEGRO_LOCK_WRITEONLY); al_set_target_bitmap(pBuffer); for (short int i = 0; i < iWidth; i++) { for (short int j = 0; j < iHeight; j++) { if (pCells[i][j] == true) { al_put_pixel(i, j, oCellColor); } else { al_put_pixel(i, j, oBackColor); } } } al_unlock_bitmap(pBuffer); }
ALLEGRO_BITMAP *create_pixel_pattern_3(ALLEGRO_COLOR pixel1_color, ALLEGRO_COLOR pixel2_color, int x_distance, int y_distance) { int bitmap_size_x = x_distance * 8; int bitmap_size_y = y_distance * 8; ALLEGRO_BITMAP *surface = al_create_bitmap(bitmap_size_x, bitmap_size_y); ALLEGRO_STATE state; al_store_state(&state, ALLEGRO_STATE_TARGET_BITMAP); al_set_target_bitmap(surface); // clear to the back color al_clear_to_color(pixel2_color); // begin drawing the surface int slope = (int)(x_distance * 1.5); al_lock_bitmap(surface, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_WRITEONLY); // is ALLEGRO_PIXEL_FORMAT_ANY correct? for (int y=0; y<bitmap_size_y; y+=y_distance) for (int x=0; x<bitmap_size_x; x+=x_distance) { al_put_pixel(x + (y*slope)%x_distance, y, pixel1_color); } al_unlock_bitmap(surface); al_restore_state(&state); return surface; }
void special_effects_update_before (void) { return; t_skin *skin = Skins_GetCurrentSkin(); al_lock_bitmap(gui_buffer, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_READWRITE); al_set_target_bitmap(gui_buffer); switch (skin->effect) { // BLOOD DROPS ------------------------------------------------------------- case SKIN_EFFECT_BLOOD: for (int i = 0; i < MAX_BLOOD_DROP; i ++) { t_skinfx_particle* p = &g_skinfx_particles[i]; if (p->v && p->save.a != 0) al_put_pixel(p->x, p->y, p->save); } break; case SKIN_EFFECT_HEARTS: // Save old graphics -------------------------------------------------- const int w = al_get_bitmap_width(Graphics.Misc.Heart1); const int h = al_get_bitmap_height(Graphics.Misc.Heart1); for (int i = 0; i < MAX_HEARTS; i ++) { t_skinfx_particle* p = &g_skinfx_particles[i]; al_draw_bitmap_region(hearts_save[i], 0, 0, w, h, p->x, p->y, 0x0000); } break; } al_unlock_bitmap(gui_buffer); }
ALLEGRO_BITMAP *create_pixel_pattern_4(ALLEGRO_COLOR pixel1_color, ALLEGRO_COLOR pixel2_color, int x_distance, float slope) { //TODO this function is not complete, and may not return expected results when other values than the default values are given. // Further development is needed to provide this flexibility to the function, but at the default values, it returns the intended // pattern int bitmap_size_x = x_distance * 8; int bitmap_size_y = x_distance * 8; ALLEGRO_BITMAP *surface = al_create_bitmap(bitmap_size_x, bitmap_size_y); ALLEGRO_STATE state; al_store_state(&state, ALLEGRO_STATE_TARGET_BITMAP); al_set_target_bitmap(surface); if (x_distance < 0) { al_restore_state(&state); return surface; } while (slope < 0) { slope += x_distance; } // clear to the back color al_clear_to_color(pixel2_color); // begin drawing the surface al_lock_bitmap(surface, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_WRITEONLY); // is ALLEGRO_PIXEL_FORMAT_ANY correct? for (int y=0; y<bitmap_size_y; y+=1) for (int x=0; x<bitmap_size_x; x+=x_distance) { al_put_pixel(x + ((int)(y*slope))%x_distance, y, pixel1_color); } al_unlock_bitmap(surface); al_restore_state(&state); return surface; }
ALLEGRO_BITMAP * apply_palette (ALLEGRO_BITMAP *bitmap, palette p) { if (! bitmap) return NULL; ALLEGRO_BITMAP *cached = get_cached_palette (bitmap, p); if (cached) return cached; int x, y; ALLEGRO_BITMAP *rbitmap = clone_bitmap (bitmap); int w = al_get_bitmap_width (bitmap); int h = al_get_bitmap_height (bitmap); al_lock_bitmap (rbitmap, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_READWRITE); set_target_bitmap (rbitmap); for (y = 0; y < h; y++) for (x = 0; x < w; x++) al_put_pixel (x, y, p (al_get_pixel (rbitmap, x, y))); al_unlock_bitmap (rbitmap); struct palette_cache pc; pc.ib = bitmap; pc.pal = p; pc.ob = rbitmap; palette_cache = add_to_array (&pc, 1, palette_cache, &palette_cache_nmemb, palette_cache_nmemb, sizeof (pc)); qsort (palette_cache, palette_cache_nmemb, sizeof (pc), compare_palette_caches); return rbitmap; }
ALLEGRO_BITMAP *create_pixel_pattern_1(ALLEGRO_COLOR pixel1_color, ALLEGRO_COLOR pixel2_color, int checker_size) { int bitmap_size = 64; ALLEGRO_BITMAP *surface = al_create_bitmap(bitmap_size, bitmap_size); ALLEGRO_STATE state; al_store_state(&state, ALLEGRO_STATE_TARGET_BITMAP); al_set_target_bitmap(surface); // clear to the back color al_clear_to_color(pixel2_color); // begin drawing the surface al_lock_bitmap(surface, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_WRITEONLY); // is ALLEGRO_PIXEL_FORMAT_ANY correct? int num_rows_cols = bitmap_size / checker_size; for (int row=0; row<num_rows_cols; row++) for (int col=0; col<num_rows_cols; col++) { if ((row+col) % 2 == 1) continue; // skip if the square is even // draw a square of n x n size, at (x, y) for (int yy=0; yy<checker_size; yy++) for (int xx=0; xx<checker_size; xx++) { al_put_pixel(col*checker_size + xx, row*checker_size + yy, pixel1_color); } } al_unlock_bitmap(surface); al_restore_state(&state); return surface; }
/* Function: al_convert_mask_to_alpha */ void al_convert_mask_to_alpha(ALLEGRO_BITMAP *bitmap, ALLEGRO_COLOR mask_color) { ALLEGRO_LOCKED_REGION *lr; int x, y; ALLEGRO_COLOR pixel; ALLEGRO_COLOR alpha_pixel; ALLEGRO_STATE state; if (!(lr = al_lock_bitmap(bitmap, ALLEGRO_PIXEL_FORMAT_ANY, 0))) { ALLEGRO_ERROR("Couldn't lock bitmap."); return; } al_store_state(&state, ALLEGRO_STATE_TARGET_BITMAP); al_set_target_bitmap(bitmap); alpha_pixel = al_map_rgba(0, 0, 0, 0); for (y = 0; y < bitmap->h; y++) { for (x = 0; x < bitmap->w; x++) { pixel = al_get_pixel(bitmap, x, y); if (memcmp(&pixel, &mask_color, sizeof(ALLEGRO_COLOR)) == 0) { al_put_pixel(x, y, alpha_pixel); } } } al_unlock_bitmap(bitmap); al_restore_state(&state); }
ALLEGRO_BITMAP *generate_noise_bitmap(float w, float h, float min_intensity, float max_intensity) { // set everything up ALLEGRO_BITMAP *surface = al_create_bitmap(w, h); ALLEGRO_STATE state; al_store_state(&state, ALLEGRO_STATE_TARGET_BITMAP); // set the drawing surface al_set_target_bitmap(surface); // write the (randomly colored) pixels al_lock_bitmap(surface, ALLEGRO_PIXEL_FORMAT_ARGB_8888, ALLEGRO_LOCK_WRITEONLY); for (int x=0; x<w; x++) { for (int y=0; y<h; y++) { float val = random_float(min_intensity, max_intensity); al_put_pixel(x, y, al_map_rgba_f(val, val, val, 1.0)); } } al_unlock_bitmap(surface); // return everything back to the way it was al_restore_state(&state); // return the generated image return surface; }
void Block::DrawPixel(int drawx, int drawy) { ALLEGRO_COLOR temp; if( tileShapeBasic==tiletype_shape_basic::Floor || tileShapeBasic==tiletype_shape_basic::Wall || tileShapeBasic==tiletype_shape_basic::Ramp || tileShapeBasic==tiletype_shape_basic::Stair ) { al_put_pixel(drawx, drawy, lookupMaterialColor(this->material.type, this->material.index)); } if(this->water.index) { if(this->water.type == 0) //water al_draw_pixel(drawx, drawy, al_map_rgba_f(0.6f, 0.85f, 0.92f, (float)water.index / 7.0f)); else al_draw_pixel(drawx, drawy, al_map_rgba_f(1.0f, 0.5f, 0.15f, (float)water.index / 7.0f)); } //Grass if(grasslevel > 0 && ( (tileMaterial == tiletype_material::GRASS_DARK) || (tileMaterial == tiletype_material::GRASS_DARK) || (tileMaterial == tiletype_material::GRASS_DRY) || (tileMaterial == tiletype_material::GRASS_DEAD))) { temp = lookupMaterialColor(WOOD, grassmat); al_draw_pixel(drawx, drawy, al_map_rgba_f(temp.r,temp.g, temp.b, (float)grasslevel/100.0f)); } }
int main(void) { ALLEGRO_DISPLAY *display; ALLEGRO_BITMAP *icons[NUM_ICONS]; ALLEGRO_EVENT_QUEUE *queue; int u, v; if (!al_init()) { abort_example("Could not init Allegro.\n"); } al_install_keyboard(); al_init_image_addon(); display = al_create_display(320, 200); if (!display) { abort_example("Error creating display\n"); } al_clear_to_color(al_map_rgb_f(0, 0, 0)); al_flip_display(); /* First icon 16x16: Read from file. */ icons[0] = al_load_bitmap("data/cursor.tga"); if (!icons[0]) { abort_example("icons.tga not found\n"); } /* Second icon 32x32: Create it. */ al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP); icons[1] = al_create_bitmap(32, 32); al_set_target_bitmap(icons[1]); for (v = 0; v < 32; v++) { for (u = 0; u < 32; u++) { al_put_pixel(u, v, al_map_rgb_f(u / 31.0, v / 31.0, 1)); } } al_set_target_backbuffer(display); al_set_display_icons(display, NUM_ICONS, icons); queue = al_create_event_queue(); al_register_event_source(queue, al_get_keyboard_event_source()); al_register_event_source(queue, al_get_display_event_source(display)); for (;;) { ALLEGRO_EVENT event; al_wait_for_event(queue, &event); if (event.type == ALLEGRO_EVENT_KEY_DOWN && event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) { break; } if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) { break; } } al_uninstall_system(); return 0; }
void draw_star (struct star *s, struct stars_bitmap *sb, enum vm vm) { al_lock_bitmap (sb->b, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_READWRITE); al_set_target_bitmap (sb->b); al_put_pixel (s->x - sb->c.x, s->y - sb->c.y, get_star_color (s->color, vm)); al_unlock_bitmap (sb->b); }
void* Gamestate_Load(struct Game *game, void (*progress)(struct Game*)) { struct GamestateResources *data = malloc(sizeof(struct GamestateResources)); data->timeline = TM_Init(game, "main"); data->bitmap = al_create_bitmap(game->viewport.width, game->viewport.height); data->checkerboard = al_create_bitmap(game->viewport.width, game->viewport.height); data->pixelator = al_create_bitmap(game->viewport.width, game->viewport.height); al_set_target_bitmap(data->checkerboard); al_lock_bitmap(data->checkerboard, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_WRITEONLY); int x, y; for (x = 0; x < al_get_bitmap_width(data->checkerboard); x=x+2) { for (y = 0; y < al_get_bitmap_height(data->checkerboard); y=y+2) { al_put_pixel(x, y, al_map_rgba(0,0,0,64)); al_put_pixel(x+1, y, al_map_rgba(0,0,0,0)); al_put_pixel(x, y+1, al_map_rgba(0,0,0,0)); al_put_pixel(x+1, y+1, al_map_rgba(0,0,0,0)); } } al_unlock_bitmap(data->checkerboard); al_set_target_backbuffer(game->display); (*progress)(game); data->font = al_load_ttf_font(GetDataFilePath(game, "fonts/DejaVuSansMono.ttf"), (int)(game->viewport.height*0.1666 / 8) * 8 ,0 ); (*progress)(game); data->sample = al_load_sample( GetDataFilePath(game, "dosowisko.flac") ); data->sound = al_create_sample_instance(data->sample); al_attach_sample_instance_to_mixer(data->sound, game->audio.music); al_set_sample_instance_playmode(data->sound, ALLEGRO_PLAYMODE_ONCE); (*progress)(game); data->kbd_sample = al_load_sample( GetDataFilePath(game, "kbd.flac") ); data->kbd = al_create_sample_instance(data->kbd_sample); al_attach_sample_instance_to_mixer(data->kbd, game->audio.fx); al_set_sample_instance_playmode(data->kbd, ALLEGRO_PLAYMODE_ONCE); (*progress)(game); data->key_sample = al_load_sample( GetDataFilePath(game, "key.flac") ); data->key = al_create_sample_instance(data->key_sample); al_attach_sample_instance_to_mixer(data->key, game->audio.fx); al_set_sample_instance_playmode(data->key, ALLEGRO_PLAYMODE_ONCE); (*progress)(game); return data; }
void draw_star (struct stars *stars, int i, enum vm vm) { al_lock_bitmap (stars->b, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_READWRITE); set_target_bitmap (stars->b); al_put_pixel (stars->s[i].x - stars->c.x, stars->s[i].y - stars->c.y, get_star_color (stars->s[i].color, vm)); al_unlock_bitmap (stars->b); }
static void shader_solid_any_draw_opaque(uintptr_t state, int x1, int y, int x2) { state_solid_any_2d* s = (state_solid_any_2d*)state; int x; for (x = x1; x <= x2; x++) { al_put_pixel(x, y - 1, s->cur_color); } }
//Draw the mask, DEBUG ONLY void mask_draw(Mask *temp, int x, int y) { int j, k; for(j = 0; j < temp->widht; j++) { for(k = 0; k < temp->height; k++) { if (!temp->bits[j][k]) al_put_pixel(x + j, y + k, al_map_rgba_f(0.75, 0, 0.75, 0.75)); } } }
static mrb_value put_pixel(mrb_state *mrb, mrb_value self) { mrb_int x; mrb_int y; ALLEGRO_COLOR *c; mrb_get_args(mrb, "iio", &x, &y, &c, &mrbal_color_data_type); al_put_pixel(mrbal_clamp_int(x), mrbal_clamp_int(y), *c); return mrb_nil_value(); }
// Draw void particle::draw(){ if( type == PIXEL){ al_put_pixel( x, y, color); } else if( type == SQUARE){ al_draw_rectangle( x, y, x + size, y + size, color, 1); } else if( type == CIRCLE){ al_draw_circle( x, y, size, color, 1); } }
BOOST_FIXTURE_TEST_CASE(can_set_the_alpha_threshold, Fixture) { ALLEGRO_BITMAP *bmp = al_create_bitmap(1, 1); UISurfaceAreaBitmapAlpha surface_area = UISurfaceAreaBitmapAlpha(0, 0, bmp); surface_area.placement.align = vec2d(0, 0); al_set_target_bitmap(bmp); float alpha = 0.5; surface_area.set_alpha_threshold(alpha); al_put_pixel(0, 0, al_map_rgba_f(1.0, 1.0, 1.0, alpha - 0.01)); BOOST_CHECK_EQUAL(false, surface_area.collides(0.5, 0.5)); al_put_pixel(0, 0, al_map_rgba_f(1.0, 1.0, 1.0, alpha + 0.01)); BOOST_CHECK_EQUAL(true, surface_area.collides(0.5, 0.5)); alpha = 0.1; surface_area.set_alpha_threshold(alpha); al_put_pixel(0, 0, al_map_rgba_f(1.0, 1.0, 1.0, alpha - 0.01)); BOOST_CHECK_EQUAL(false, surface_area.collides(0.5, 0.5)); al_put_pixel(0, 0, al_map_rgba_f(1.0, 1.0, 1.0, alpha + 0.01)); BOOST_CHECK_EQUAL(true, surface_area.collides(0.5, 0.5)); alpha = 0.9; surface_area.set_alpha_threshold(alpha); al_put_pixel(0, 0, al_map_rgba_f(1.0, 1.0, 1.0, alpha - 0.01)); BOOST_CHECK_EQUAL(false, surface_area.collides(0.5, 0.5)); al_put_pixel(0, 0, al_map_rgba_f(1.0, 1.0, 1.0, alpha + 0.01)); BOOST_CHECK_EQUAL(true, surface_area.collides(0.5, 0.5)); }
void draw_pattern (ALLEGRO_BITMAP *bitmap, int ox, int oy, int w, int h, ALLEGRO_COLOR color_0, ALLEGRO_COLOR color_1) { int x, y; set_target_bitmap (bitmap); al_lock_bitmap (bitmap, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_READWRITE); for (y = oy; y < oy + h; y++) for (x = ox; x < ox + w; x++) al_put_pixel (x, y, (x % 2 != y % 2) ? color_0 : color_1); al_unlock_bitmap (bitmap); }
ALLEGRO_BITMAP * t3f_resize_bitmap(ALLEGRO_BITMAP * bp, int w, int h) { ALLEGRO_BITMAP * rbp = NULL; int start_w = al_get_bitmap_width(bp); int start_h = al_get_bitmap_height(bp); int x, y; float pixx, pixx_f, pixy, pixy_f; ALLEGRO_COLOR a, b, c, d, ab, cd, result; ALLEGRO_STATE old_state; /* don't resize if size is already correct */ if(w == start_w && h == start_h) { return al_clone_bitmap(bp); } /* scale with software filtering */ rbp = al_create_bitmap(w, h); if(!rbp) { printf("failed to create return bitmap\n"); return NULL; } al_lock_bitmap(rbp, ALLEGRO_LOCK_READWRITE, ALLEGRO_PIXEL_FORMAT_ANY); al_store_state(&old_state, ALLEGRO_STATE_TARGET_BITMAP); al_set_target_bitmap(rbp); for(y = 0; y < h; y++) { pixy = ((float)y / h) * ((float)start_h - 1); pixy_f = floor(pixy); for(x = 0; x < w; x++) { pixx = ((float)x / w) * ((float)start_w - 1); pixx_f = floor(pixx); a = al_get_pixel(bp, pixx_f, pixy_f); b = al_get_pixel(bp, pixx_f + 1, pixy_f); c = al_get_pixel(bp, pixx_f, pixy_f + 1); d = al_get_pixel(bp, pixx_f + 1, pixy_f + 1); ab = interpolate(a, b, pixx - pixx_f); cd = interpolate(c, d, pixx - pixx_f); result = interpolate(ab, cd, pixy - pixy_f); al_put_pixel(x, y, result); } } al_unlock_bitmap(rbp); al_restore_state(&old_state); return rbp; }
void shal_put_pixel(int x, int y, float color_r, float color_g, float color_b, float color_a) { ALLEGRO_COLOR color; color.r = color_r; color.g = color_g; color.b = color_b; color.a = color_a; return al_put_pixel(x, y, color); }
void WhiteNoise(struct Game *game) { ALLEGRO_BITMAP *bitmap = al_get_target_bitmap(); al_lock_bitmap(bitmap, ALLEGRO_LOCK_WRITEONLY, 0); float val; int width, height; width = al_get_bitmap_width(bitmap); height = al_get_bitmap_height(bitmap); for (int i=0; i < width; i++) { for (int j=0; j < height; j++) { val = (float)rand()/(float)RAND_MAX; al_put_pixel(i, j, al_map_rgb_f(val, val, val)); } } al_unlock_bitmap(bitmap); }
bool parseFile(const std::string &filename, int &w, int &h) { std::string line; std::ifstream myfile(filename.c_str()); int i = 0; int x = 0; int y = 0; if (myfile.is_open()) { while (myfile.good()) { std::getline(myfile, line); if (i == 0) { std::string tk1, tk2; std::stringstream ss(line); ss >> tk1; ss >> tk2; if (tk2.size() < 1) return false; w = std::atoi(tk1.c_str()); h = std::atoi(tk2.c_str()); if (w <= 0 || h <= 0) return false; if (!al_create_display(w, h)) return false; } else { std::vector<std::string> list; splitString(list, line); std::vector<std::string>::iterator it = list.begin(); x = 0; while (it != list.end()) { int r, g, b; getColor(r, g, b, (*it)); al_put_pixel(x, y, al_map_rgb(r, g, b)); ++it; ++x; } ++y; } ++i; }
void KinectPlayer::Render() { // if (!mPlayerPresent) { // return; // } std::vector<UserData> users; mUserTracking.GetUsers(users); if (users.empty()) { return; } al_set_target_bitmap(mBitmap); al_clear_to_color(al_map_rgb(0x00, 0x00, 0x00)); al_convert_mask_to_alpha(mBitmap, al_map_rgb(0x00, 0x00, 0x00)); xn::SceneMetaData scene_meta; mUserTracking.GetUserPixels(users[0], scene_meta); const XnRGB24Pixel* pRgbBuf = mKinect.GetImageData(); const XnLabel* pLabelBuf = scene_meta.Data(); ALLEGRO_LOCKED_REGION* lock = al_lock_bitmap(mBitmap, al_get_bitmap_format(mBitmap), ALLEGRO_LOCK_WRITEONLY); al_set_target_bitmap(mBitmap); for (int y = 0; y < mBitmapHeight; y++) { for (int x = 0; x < mBitmapWidth; x++, pLabelBuf++, pRgbBuf++) { if (*pLabelBuf == users[0].GetId()) { al_put_pixel(x, y, al_map_rgb(pRgbBuf->nRed, pRgbBuf->nGreen, pRgbBuf->nBlue)); } } } al_unlock_bitmap(mBitmap); const int screen_x_res = al_get_display_width(al_get_current_display()); const int screen_y_res = al_get_display_height(al_get_current_display()); al_set_target_bitmap(al_get_backbuffer(al_get_current_display())); al_draw_scaled_bitmap(mBitmap, 0, 0, mBitmapWidth, mBitmapHeight, GetXPos(), GetYPos(), GetWidth(), GetHeight(), 0); }
static void shader_grad_any_draw_opaque(uintptr_t state, int x1, int y, int x2) { state_grad_any_2d* s = (state_grad_any_2d*)state; ALLEGRO_COLOR color = s->solid.cur_color; int x; for (x = x1; x <= x2; x++) { al_put_pixel(x, y - 1, color); color.r += s->color_dx.r; color.g += s->color_dx.g; color.b += s->color_dx.b; color.a += s->color_dx.a; } }
ALLEGRO_BITMAP * Starfield::makeStarfield(int numStars, ALLEGRO_DISPLAY *display) { ALLEGRO_BITMAP * bit = al_create_bitmap(ScreenWidth, ScreenHeight); al_set_target_bitmap(bit); //al_clear_to_color(al_map_rgb(0, 0, 0)); int i; for(i = 0; i < numStars; i++) { al_put_pixel(qrand() % ScreenWidth, qrand() % ScreenHeight, al_map_rgb(255,255,255)); } al_set_target_bitmap(al_get_backbuffer(display)); return bit; }
static void shader_texture_solid_any_draw_opaque_white(uintptr_t state, int x1, int y, int x2) { state_texture_solid_any_2d* s = (state_texture_solid_any_2d*)state; float u = s->u; float v = s->v; int x; ALLEGRO_COLOR color; for (x = x1; x <= x2; x++) { color = al_get_pixel(s->texture, fix_var(u, s->w), fix_var(v, s->h)); al_put_pixel(x, y - 1, color); u += s->du_dx; v += s->dv_dx; } }
// unused void convert_grayscale(ALLEGRO_BITMAP *bmp) { ALLEGRO_BITMAP *dispbuf = al_get_target_bitmap(); int x, y, w, h, lum; unsigned char r, g, b; w = al_get_bitmap_width(bmp); h = al_get_bitmap_height(bmp); al_set_target_bitmap(bmp); al_lock_bitmap(bmp, ALLEGRO_PIXEL_FORMAT_ABGR_8888, ALLEGRO_LOCK_READWRITE); for (y = 0; y < h; y++) { for (x = 0; x < w; x++) { al_unmap_rgb(al_get_pixel(bmp, x, y), &r, &g, &b); lum = (0.299*r + 0.587*g + 0.114*b)/2; // dividing by two makes it darker, default should be not dividing al_put_pixel(x, y, al_map_rgb(lum, lum, lum)); // RGB to grayscale } } al_unlock_bitmap(bmp); al_set_target_bitmap(dispbuf); }