Overlay::Overlay(renderer* parent) : parent(parent) { { CoreSuspender suspend; //parent->zoom(df::zoom_commands::zoom_reset); good_viewscreen = false; ReadTileLocations(); copy_from_inner(); } front_mutex = al_create_mutex(); int32_t flags = al_get_new_bitmap_flags(); if(al_get_current_display() != NULL){ al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP | ALLEGRO_ALPHA_TEST); } front = al_create_bitmap(0,0); if(al_get_current_display() != NULL){ al_set_new_bitmap_flags(al_get_bitmap_flags(al_get_backbuffer(al_get_current_display()))); } back = al_create_bitmap(0,0); al_set_new_bitmap_flags(flags); Flip(); };
przycisk_img::przycisk_img(int wsp_x, int wsp_y, std::string kadres_obrazka):przycisk(wsp_x,wsp_y),adres_obrazka(kadres_obrazka){ al_init_image_addon(); obrazek = al_load_bitmap(adres_obrazka.data()); if (!obrazek) { al_show_native_message_box(NULL, "Blad", "Cos nie tak", "Nie moge wczytac bitmapy kwadrat!", NULL, ALLEGRO_MESSAGEBOX_ERROR); } szer_ekranu = al_get_display_width(al_get_current_display()); wys_ekranu = al_get_display_height(al_get_current_display()); rozmiar_y=al_get_bitmap_height(obrazek); rozmiar_x=al_get_bitmap_width(obrazek); al_shutdown_image_addon(); }
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); }
void Image::print() { ALLEGRO_DISPLAY *display = al_get_current_display(); switch (mode) { case IMAGE_MODE_DEFAULT: al_draw_bitmap(image, x, y, flag); break; case IMAGE_MODE_FULLSCREEN: al_draw_scaled_bitmap( image, 0, 0, al_get_bitmap_width(image), al_get_bitmap_height(image), 0, 0, al_get_display_width(display), al_get_display_height(display), flag); break; case IMAGE_MODE_REGION: //al_convert_mask_to_alpha(image, al_map_rgb(255,0,255)); al_draw_bitmap_region( image, region_x, region_y, region_w, region_h, x, y, flag); break; } }
void error(const char *err) { ALLEGRO_DISPLAY *dialogErr; dialogErr=al_is_system_installed()?al_get_current_display():NULL; al_show_native_message_box(dialogErr,"ERREUR", "Erreur", err,NULL,0); exit(EXIT_FAILURE); }
void Map::drawTile(const Tile &t, std::shared_ptr<ALLEGRO_BITMAP> ptr) { std::shared_ptr<ALLEGRO_BITMAP> bm; Tileset* ts = nullptr; switch(t.getBiome()) { case GRASS: ts = &grass_; break; case SWAMP: ts = &swamp_; break; case ROCK: ts = &rock_; break; default: break; }; al_set_target_bitmap(bm_); bm = *ts << t.topleft(); al_draw_bitmap(bm.get(), t.getx() * 32, t.gety() * 32, 0); bm = *ts << t.topright(); al_draw_bitmap(bm.get(), t.getx() * 32 + 16, t.gety() * 32, 0); bm = *ts << t.botleft(); al_draw_bitmap(bm.get(), t.getx() * 32, t.gety() * 32 + 16, 0); bm = *ts << t.botright(); al_draw_bitmap(bm.get(), t.getx() * 32 + 16, t.gety() * 32 + 16, 0); if(ptr != nullptr) { al_draw_bitmap(ptr.get(), t.getx() * 32, t.gety() * 32, 0); } #ifdef _DEBUG t.asObject().drawHull(glm::vec2(0., 0.)); #endif //_DEBUG al_set_target_backbuffer(al_get_current_display()); }
Tileset::Tileset(ALLEGRO_COLOR cl) { spritesheet_ = al_create_bitmap(64, 64); al_set_target_bitmap(spritesheet_); al_clear_to_color(cl); al_set_target_backbuffer(al_get_current_display()); }
inline bool initRender() throw() { ALLEGRO_DISPLAY *d; glm::vec3 pos; d = al_get_current_display(); if (!d) return false; this->size_ = glm::vec3(al_get_display_width(d), al_get_display_height(d), 0.0f); this->center_ = glm::vec3(this->size_.x / 2.0f, this->size_.y / 2.0f, 0.0f); this->max_ = this->min_; this->max_ += this->size_; glMatrixMode(GL_PROJECTION); glLoadIdentity(); glViewport(0, 0, this->size_.x * this->zoom_, this->size_.y * this->zoom_); glOrtho(0 * this->zoom_, this->size_.x, 0 *this->zoom_, this->size_.y, -10000, 10000); glMatrixMode(GL_MODELVIEW); return true; }
VisualBullet(float x_in, float y_in, float dir[2], float acc[2]) : Bullet(x_in, y_in, dir, acc) { ALLEGRO_DISPLAY *old = al_get_current_display(); bmp_p = al_create_bitmap(10, 10); al_set_target_bitmap(bmp_p); al_clear_to_color(al_map_rgb(255, 0, 255)); //viola al_set_target_backbuffer(old); }
void Object::getDisplayData() { ALLEGRO_DISPLAY *display = al_get_current_display(); displayW = al_get_display_width(display); displayH = al_get_display_height(display); }
void Object::generate_error_bitmap() { if(testBit(ISMEM_BITMAP)) { bitmap = create_memory_bitmap(); } else { bitmap = al_create_bitmap(w, h); } ALLEGRO_COLOR background = al_color_html("#3f51b5"); ALLEGRO_COLOR shadow = al_color_html("#1a237e"); ALLEGRO_COLOR sign = al_color_html("#ffeb3b"); al_set_target_bitmap(bitmap); al_clear_to_color(background); // Shadow (3 triangles) al_draw_filled_triangle(w / 2.0f, h / 4.0f, w, (h * 3.0f) / 4.0f, w / 2.0f, h, shadow); al_draw_filled_triangle(w, (h * 3.0f) / 4.0f, w, h, w / 2.0f, h, shadow); al_draw_filled_triangle(w / 2.0f, h / 4.0f, w / 2.0f, h, w / 4.0f, (h * 3.0f) / 4.0f, shadow); // Alert sign triangle al_draw_filled_triangle(w / 2.0f, h / 4.0f, ((w * 3.0f) / 4), ((h * 3.0f) / 4.0f), w / 4.0f, ((h * 3.0f) / 4.0f), sign); // Exclamation point al_draw_filled_rectangle((w * 15.0f) / 32.0f, ((h * 14.0f) / 32.0f), ((w * 17.0f) / 32.0f), ((h * 19.0f) / 32.0f), background); al_draw_filled_rectangle((w * 15.0f) / 32.0f, (h * 5.0f) / 8.0f, (w * 17.0f) / 32.0f, (h * 11.0f) / 16.0f, background); al_set_target_backbuffer(al_get_current_display()); }
/* Creates a memory bitmap. */ static ALLEGRO_BITMAP *_al_create_memory_bitmap(int w, int h) { ALLEGRO_BITMAP *bitmap; int pitch; int format = al_get_new_bitmap_format(); format = _al_get_real_pixel_format(al_get_current_display(), format); bitmap = al_calloc(1, sizeof *bitmap); bitmap->size = sizeof(*bitmap); pitch = w * al_get_pixel_size(format); bitmap->vt = NULL; bitmap->format = format; bitmap->flags = (al_get_new_bitmap_flags() | ALLEGRO_MEMORY_BITMAP) & ~ALLEGRO_VIDEO_BITMAP; bitmap->w = w; bitmap->h = h; bitmap->pitch = pitch; bitmap->display = NULL; bitmap->locked = false; bitmap->cl = bitmap->ct = 0; bitmap->cr_excl = w; bitmap->cb_excl = h; al_identity_transform(&bitmap->transform); bitmap->parent = NULL; bitmap->xofs = bitmap->yofs = 0; bitmap->memory = al_malloc(pitch * h); bitmap->preserve_texture = !(al_get_new_bitmap_flags() & ALLEGRO_NO_PRESERVE_TEXTURE); return bitmap; }
bool InputField::Bitmap() { // al_set_target_bitmap(bmp); al_set_target_bitmap(as_bitmap); al_clear_to_color(bckground_color); //float tx = (text_width <= width ? 0 : width - text_width); float tx = (text_width <= width ? (center == true ? (width - text_width)/2 : 0) : width - text_width); al_draw_text(font, text_color, tx, (height - text_height) / 2.0f, 0, text.c_str()); if(detectingbutton->is_button_clicked() == true) { if(bling > 30) { al_draw_line(tx + text_width -2, (height - text_height) / 2.0f, tx + text_width -2, (height + text_height) / 2.0f, text_color, 2); if(bling > 60) { bling = 0; } } bling++; } /*al_set_target_bitmap(as_bitmap); al_clear_to_color(al_map_rgba(0,0,0,0)); al_draw_bitmap(bmp, 0, 0, 0);*/ al_draw_rounded_rectangle(0, 0, width, height, 5, 5, outline_color, 2); al_set_target_backbuffer(al_get_current_display()); return true; }
/* Function: al_destroy_display */ void al_destroy_display(ALLEGRO_DISPLAY *display) { if (display) { /* This causes warnings and potential errors on Android because * it clears the context and Android needs this thread to have * the context bound in its destroy function and to destroy the * shader. Just skip this part on Android. */ #ifndef ALLEGRO_ANDROID ALLEGRO_BITMAP *bmp; bmp = al_get_target_bitmap(); if (bmp && _al_get_bitmap_display(bmp) == display) al_set_target_bitmap(NULL); /* This can happen if we have a current display, but the target bitmap * was a memory bitmap. */ if (display == al_get_current_display()) _al_set_current_display_only(NULL); #endif al_destroy_shader(display->default_shader); display->default_shader = NULL; ASSERT(display->vt); display->vt->destroy_display(display); } }
static void wgl_destroy_display(ALLEGRO_DISPLAY *disp) { ALLEGRO_SYSTEM_WIN *system = (ALLEGRO_SYSTEM_WIN *)al_get_system_driver(); ALLEGRO_DISPLAY_WGL *wgl_disp = (ALLEGRO_DISPLAY_WGL *)disp; ALLEGRO_DISPLAY *old_disp = al_get_current_display(); if (old_disp != disp) _al_set_current_display_only(disp); if (system->mouse_grab_display == disp) system->mouse_grab_display = NULL; destroy_display_internals(wgl_disp); _al_event_source_free(&disp->es); _al_vector_find_and_delete(&system->system.displays, &disp); _al_vector_free(&disp->bitmaps); al_free(disp->ogl_extras); if (old_disp != disp) _al_set_current_display_only(old_disp); al_free(disp->vertex_cache); al_free(wgl_disp); }
static bool ogl_lock_region_nonbb_readwrite( ALLEGRO_BITMAP *bitmap, ALLEGRO_BITMAP_EXTRA_OPENGL *ogl_bitmap, int x, int gl_y, int w, int h, int format, bool* restore_fbo) { bool ok; ASSERT(bitmap->parent == NULL); ASSERT(bitmap->locked == false); ASSERT(_al_get_bitmap_display(bitmap) == al_get_current_display()); /* Try to create an FBO if there isn't one. */ *restore_fbo = _al_ogl_setup_fbo_non_backbuffer(_al_get_bitmap_display(bitmap), bitmap); if (ogl_bitmap->fbo_info) { ALLEGRO_DEBUG("Locking non-backbuffer READWRITE with fbo\n"); ok = ogl_lock_region_nonbb_readwrite_fbo(bitmap, ogl_bitmap, x, gl_y, w, h, format); } else { ALLEGRO_DEBUG("Locking non-backbuffer READWRITE no fbo\n"); ok = ogl_lock_region_nonbb_readwrite_nonfbo(bitmap, ogl_bitmap, x, gl_y, w, h, format); } return ok; }
/* Function: al_hold_bitmap_drawing */ void al_hold_bitmap_drawing(bool hold) { ALLEGRO_DISPLAY *current_display = al_get_current_display(); if (current_display) { if (hold && !current_display->cache_enabled) { /* * Set the hardware transformation to identity, but keep the bitmap * transform the same as it was. Relies on the fact that when bitmap * holding is turned on, al_use_transform does not update the hardware * transformation. */ ALLEGRO_TRANSFORM old, ident; al_copy_transform(&old, al_get_current_transform()); al_identity_transform(&ident); al_use_transform(&ident); current_display->cache_enabled = hold; al_use_transform(&old); } else { current_display->cache_enabled = hold; } if (!hold) { current_display->vt->flush_vertex_cache(current_display); /* * Reset the hardware transform to match the stored transform. */ al_use_transform(al_get_current_transform()); } } }
/* Function: al_hold_bitmap_drawing */ void al_hold_bitmap_drawing(bool hold) { ALLEGRO_DISPLAY *current_display = al_get_current_display(); current_display->cache_enabled = hold; if(!hold) current_display->vt->flush_vertex_cache(current_display); }
/* joydx_get_joystick: [primary thread] * * Returns the address of a ALLEGRO_JOYSTICK structure for the device * number NUM. */ static ALLEGRO_JOYSTICK *joydx_get_joystick(int num) { ALLEGRO_JOYSTICK *ret = NULL; unsigned i; ASSERT(num >= 0); EnterCriticalSection(&joydx_thread_cs); for (i = 0; i < MAX_JOYSTICKS; i++) { ALLEGRO_JOYSTICK_DIRECTX *joy = &joydx_joystick[i]; if (ACTIVE_STATE(joy->config_state)) { if (num == 0) { ret = (ALLEGRO_JOYSTICK *)joy; break; } num--; } } LeaveCriticalSection(&joydx_thread_cs); #if 0 /* is this needed? */ if (ret) { ALLEGRO_DISPLAY *display = al_get_current_display(); if (display) _al_win_joystick_dinput_grab(display); } #endif return ret; }
/* Function: al_get_display_flags */ int al_get_display_flags(void) { ALLEGRO_DISPLAY *display = al_get_current_display(); ASSERT(display); return display->flags; }
/* Function: al_set_window_title */ void al_set_window_title(const char *title) { ALLEGRO_DISPLAY *current_display = al_get_current_display(); if (current_display && current_display->vt && current_display->vt->set_window_title) current_display->vt->set_window_title(current_display, title); }
/* Function: al_get_display_format */ int al_get_display_format(void) { ALLEGRO_DISPLAY *display = al_get_current_display(); ASSERT(display); return display->backbuffer_format; }
/* Function: al_get_display_refresh_rate */ int al_get_display_refresh_rate(void) { ALLEGRO_DISPLAY *display = al_get_current_display(); ASSERT(display); return display->refresh_rate; }
/* Function: al_get_display_width */ int al_get_display_width(void) { ALLEGRO_DISPLAY *display = al_get_current_display(); ASSERT(display); return display->w; }
/* Function: al_get_display_height */ int al_get_display_height(void) { ALLEGRO_DISPLAY *display = al_get_current_display(); ASSERT(display); return display->h; }
/* Function: al_update_display_region */ void al_update_display_region(int x, int y, int width, int height) { ALLEGRO_DISPLAY *display = al_get_current_display(); ASSERT(display); display->vt->update_display_region(display, x, y, width, height); }
/* Function: al_flip_display */ void al_flip_display(void) { ALLEGRO_DISPLAY *display = al_get_current_display(); ASSERT(display); display->vt->flip_display(display); }
/* Function: al_get_frontbuffer */ ALLEGRO_BITMAP *al_get_frontbuffer(void) { ALLEGRO_DISPLAY *display = al_get_current_display(); ASSERT(display); return display->vt->get_frontbuffer(display); }
/* Function: al_set_render_state */ void al_set_render_state(ALLEGRO_RENDER_STATE state, int value) { ALLEGRO_DISPLAY *display = al_get_current_display(); if (!display) return; switch (state) { case ALLEGRO_ALPHA_TEST: display->render_state.alpha_test = value; break; case ALLEGRO_WRITE_MASK: display->render_state.write_mask = value; break; case ALLEGRO_DEPTH_TEST: display->render_state.depth_test = value; break; case ALLEGRO_DEPTH_FUNCTION: display->render_state.depth_function = value; break; case ALLEGRO_ALPHA_FUNCTION: display->render_state.alpha_function = value; break; case ALLEGRO_ALPHA_TEST_VALUE: display->render_state.alpha_test_value = value; break; default: ALLEGRO_WARN("unknown state to change: %d\n", state); break; } if (display->vt && display->vt->update_render_state) { display->vt->update_render_state(display); } }
void Overlay::Flip() { //do the starting timer stuff clock_t starttime = clock(); al_lock_mutex(front_mutex); { al_unlock_bitmap(front); if(al_get_bitmap_width(front) != ssState.ScreenW || al_get_bitmap_height(front) != ssState.ScreenH){ al_destroy_bitmap(front); int32_t flags = al_get_new_bitmap_flags(); if(al_get_current_display() != NULL){ al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP | ALLEGRO_ALPHA_TEST); } front = al_create_bitmap(ssState.ScreenW, ssState.ScreenH); al_set_new_bitmap_flags(flags); } al_set_target_bitmap(front); al_draw_bitmap(back, 0, 0, 0); front_data = al_lock_bitmap(front, al_get_bitmap_format(front), ALLEGRO_LOCK_READONLY); } front_updated = true; al_unlock_mutex(front_mutex); if(al_get_bitmap_width(back) != ssState.ScreenW || al_get_bitmap_height(back) != ssState.ScreenH){ al_destroy_bitmap(back); int32_t flags = al_get_new_bitmap_flags(); if(al_get_current_display() != NULL){ al_set_new_bitmap_flags(al_get_bitmap_flags(al_get_backbuffer(al_get_current_display()))); } back = al_create_bitmap(ssState.ScreenW, ssState.ScreenH); al_set_new_bitmap_flags(flags); } al_set_target_bitmap(back); //do the ending timer stuff clock_t donetime = clock(); ssTimers.overlay_time = (donetime - starttime)*0.1 + ssTimers.overlay_time*0.9; }