void FleetButton::Init(const std::vector<int>& fleet_IDs, SizeType size_type) {
if (!scanline_shader && GetOptionsDB().Get<bool>("UI.system-fog-of-war")) {
boost::filesystem::path shader_path = GetRootDataDir() / "default" / "shaders" / "scanlines.frag";
std::string shader_text;
ReadFile(shader_path, shader_text);
scanline_shader = boost::shared_ptr<ShaderProgram>(
ShaderProgram::shaderProgramFactory("", shader_text));
}
// get fleets
std::vector<TemporaryPtr<const Fleet> > fleets;
for (std::vector<int>::const_iterator it = fleet_IDs.begin(); it != fleet_IDs.end(); ++it) {
TemporaryPtr<const Fleet> fleet = GetFleet(*it);
if (!fleet) {
Logger().errorStream() << "FleetButton::FleetButton couldn't get fleet with id " << *it;
continue;
}
m_fleets.push_back(*it);
fleets.push_back(fleet);
}
// determine owner(s) of fleet(s). Only care whether or not there is more than one owner, as owner
// is used to determine colouration
int owner_id = ALL_EMPIRES;
int multiple_owners = false;
if (fleets.empty()) {
// leave as ALL_EMPIRES
} else if (fleets.size() == 1) {
owner_id = (*fleets.begin())->Owner();
} else {
owner_id = (*fleets.begin())->Owner();
// use ALL_EMPIRES if there are multiple owners (including no owner and an owner)
for (std::vector<TemporaryPtr<const Fleet> >::const_iterator it = fleets.begin(); it != fleets.end(); ++it) {
TemporaryPtr<const Fleet> fleet = *it;
if (fleet->Owner() != owner_id) {
owner_id = ALL_EMPIRES;
multiple_owners = true;
break;
}
}
}
// get fleet colour
if (multiple_owners) {
SetColor(GG::CLR_WHITE);
} else if (owner_id == ALL_EMPIRES) {
// all ships owned by now empire
bool monsters = true;
// find if any ship in fleets in button is not a monster
for (std::vector<TemporaryPtr<const Fleet> >::const_iterator it = fleets.begin(); it != fleets.end(); ++it) {
TemporaryPtr<const Fleet> fleet = *it;
for (std::set<int>::const_iterator ship_it = fleet->ShipIDs().begin();
ship_it != fleet->ShipIDs().end(); ++ship_it)
{
if (TemporaryPtr<const Ship> ship = GetShip(*ship_it)) {
if (!ship->IsMonster()) {
monsters = false;
break;
}
}
}
}
if (monsters)
SetColor(GG::CLR_RED);
else
SetColor(GG::CLR_WHITE);
} else {
// single empire owner
if (const Empire* empire = Empires().Lookup(owner_id))
SetColor(empire->Color());
else
SetColor(GG::CLR_GRAY); // should never be necessary... but just in case
}
// select icon(s) for fleet(s)
int num_ships = 0;
for (std::vector<TemporaryPtr<const Fleet> >::const_iterator it = fleets.begin(); it != fleets.end(); ++it) {
TemporaryPtr<const Fleet> fleet = *it;
if (fleet)
num_ships += fleet->NumShips();
}
m_size_icon = FleetSizeIcon(num_ships, size_type);
m_head_icons = FleetHeadIcons(fleets, size_type);
// resize to fit icon by first determining necessary size, and then resizing
GG::X texture_width(0);
GG::Y texture_height(0);
if (!m_head_icons.empty()) {
texture_width = m_head_icons.front()->DefaultWidth();
texture_height = m_head_icons.front()->DefaultHeight();
}
if (m_size_icon) {
texture_width = std::max(texture_width, m_size_icon->DefaultWidth());
texture_height = std::max(texture_height, m_size_icon->DefaultHeight());
}
// determine if fleet icon should be rotated. this should be done if the fleet is moving along
// a starlane, which is the case if the fleet is not in a system and has a valid next system
GG::Pt direction_vector(GG::X(0), GG::Y(1)); // default, unrotated button orientation
TemporaryPtr<const Fleet> first_fleet;
if (!m_fleets.empty())
first_fleet = *fleets.begin();
if (first_fleet && first_fleet->SystemID() == INVALID_OBJECT_ID) {
int next_sys_id = first_fleet->NextSystemID();
if (TemporaryPtr<const UniverseObject> obj = GetUniverseObject(next_sys_id)) {
// fleet is not in a system and has a valid next destination, so can orient it in that direction
// fleet icons might not appear on the screen in the exact place corresponding to their
// actual universe position, but if they're moving along a starlane, this code will assume
// their apparent position will only be different from their true position in a direction
// parallel with the starlane, so the direction from their true position to their destination
// position can be used to get a direction vector to orient the icon
double dest_x = obj->X(), dest_y = obj->Y();
double cur_x = first_fleet->X(), cur_y = first_fleet->Y();
const MapWnd* map_wnd = ClientUI::GetClientUI()->GetMapWnd();
GG::Pt dest = map_wnd->ScreenCoordsFromUniversePosition(dest_x, dest_y);
GG::Pt cur = map_wnd->ScreenCoordsFromUniversePosition(cur_x, cur_y);
direction_vector = dest - cur;
}
}
// check for unrotated texture
if (Value(direction_vector.x) == 0) {
// not rotated. can do simple texture blits
m_vertex_components.clear();
} else {
// texture is rotated, so need some extra math
// get rotated corner vetex x and y components (x1, y1, x2, y2, x3, y3, x4, y4) for texture of appropriate size
m_vertex_components = VectorAlignedQuadVertices(direction_vector, Value(texture_height), Value(texture_width));
}
// size icon according to texture size (average two dimensions)
int diameter = static_cast<int>((Value(texture_width) + Value(texture_height)) / 2.0);
Resize(GG::Pt(GG::X(diameter), GG::Y(diameter)));
// get selection indicator texture
m_selection_texture = ClientUI::GetTexture(ClientUI::ArtDir() / "icons" / "fleet" / "fleet_selection.png", true);
}
/////////////////////
// Free Functions
/////////////////////
std::vector<boost::shared_ptr<GG::Texture> > FleetHeadIcons(TemporaryPtr<const Fleet> fleet, FleetButton::SizeType size_type) {
std::vector< TemporaryPtr<const Fleet> > fleets(1U, fleet);
return FleetHeadIcons(fleets, size_type);
}
void FleetButton::Init(const std::vector<int>& fleet_IDs, SizeType size_type) {
//std::cout << "FleetButton::Init" << std::endl;
// get fleets
std::vector<TemporaryPtr<const Fleet> > fleets;
for (std::vector<int>::const_iterator it = fleet_IDs.begin(); it != fleet_IDs.end(); ++it) {
TemporaryPtr<const Fleet> fleet = GetFleet(*it);
if (!fleet) {
ErrorLogger() << "FleetButton::FleetButton couldn't get fleet with id " << *it;
continue;
}
m_fleets.push_back(*it);
fleets.push_back(fleet);
}
// determine owner(s) of fleet(s). Only care whether or not there is more than one owner, as owner
// is used to determine colouration
int owner_id = ALL_EMPIRES;
int multiple_owners = false;
if (fleets.empty()) {
// leave as ALL_EMPIRES
} else if (fleets.size() == 1) {
owner_id = (*fleets.begin())->Owner();
} else {
owner_id = (*fleets.begin())->Owner();
// use ALL_EMPIRES if there are multiple owners (including no owner and an owner)
for (std::vector<TemporaryPtr<const Fleet> >::const_iterator it = fleets.begin(); it != fleets.end(); ++it) {
TemporaryPtr<const Fleet> fleet = *it;
if (fleet->Owner() != owner_id) {
owner_id = ALL_EMPIRES;
multiple_owners = true;
break;
}
}
}
// get fleet colour
if (multiple_owners) {
SetColor(GG::CLR_WHITE);
} else if (owner_id == ALL_EMPIRES) {
// all ships owned by now empire
bool monsters = true;
// find if any ship in fleets in button is not a monster
for (std::vector<TemporaryPtr<const Fleet> >::const_iterator it = fleets.begin(); it != fleets.end(); ++it) {
TemporaryPtr<const Fleet> fleet = *it;
for (std::set<int>::const_iterator ship_it = fleet->ShipIDs().begin();
ship_it != fleet->ShipIDs().end(); ++ship_it)
{
if (TemporaryPtr<const Ship> ship = GetShip(*ship_it)) {
if (!ship->IsMonster()) {
monsters = false;
break;
}
}
}
}
if (monsters)
SetColor(GG::CLR_RED);
else
SetColor(GG::CLR_WHITE);
} else {
// single empire owner
if (const Empire* empire = GetEmpire(owner_id))
SetColor(empire->Color());
else
SetColor(GG::CLR_GRAY); // should never be necessary... but just in case
}
// determine direction button should be rotated to orient along a starlane
GLfloat pointing_angle = 0.0f;
TemporaryPtr<const Fleet> first_fleet;
if (!m_fleets.empty())
first_fleet = *fleets.begin();
if (first_fleet && first_fleet->SystemID() == INVALID_OBJECT_ID && first_fleet->NextSystemID() != INVALID_OBJECT_ID) {
int next_sys_id = first_fleet->NextSystemID();
if (TemporaryPtr<const UniverseObject> obj = GetUniverseObject(next_sys_id)) {
// fleet is not in a system and has a valid next destination, so can orient it in that direction
// fleet icons might not appear on the screen in the exact place corresponding to their
// actual universe position, but if they're moving along a starlane, this code will assume
// their apparent position will only be different from their true position in a direction
// parallel with the starlane, so the direction from their true position to their destination
// position can be used to get a direction vector to orient the icon
float dest_x = obj->X(), dest_y = obj->Y();
float cur_x = first_fleet->X(), cur_y = first_fleet->Y();
const MapWnd* map_wnd = ClientUI::GetClientUI()->GetMapWnd();
GG::Pt dest = map_wnd->ScreenCoordsFromUniversePosition(dest_x, dest_y);
GG::Pt cur = map_wnd->ScreenCoordsFromUniversePosition(cur_x, cur_y);
GG::Pt direction_vector = dest - cur;
if (direction_vector.x != GG::X0 || direction_vector.y != GG::Y0)
pointing_angle = 360.0f / TWO_PI * std::atan2(static_cast<float>(Value(direction_vector.y)), static_cast<float>(Value(direction_vector.x))) + 90;
}
}
// select icon(s) for fleet(s)
int num_ships = 0;
for (std::vector<TemporaryPtr<const Fleet> >::const_iterator it = fleets.begin(); it != fleets.end(); ++it) {
TemporaryPtr<const Fleet> fleet = *it;
if (fleet)
num_ships += fleet->NumShips();
}
boost::shared_ptr<GG::Texture> size_texture = FleetSizeIcon(num_ships, size_type);
std::vector<boost::shared_ptr<GG::Texture> > head_textures = FleetHeadIcons(fleets, size_type);
// add RotatingGraphics for all icons needed
if (size_texture) {
RotatingGraphic* icon = new RotatingGraphic(size_texture, GG::GRAPHIC_FITGRAPHIC | GG::GRAPHIC_PROPSCALE);
icon->SetPhaseOffset(pointing_angle);
icon->SetRPM(0.0f);
icon->SetColor(this->Color());
m_icons.push_back(icon);
Resize(GG::Pt(size_texture->DefaultWidth(), size_texture->DefaultHeight()));
AttachChild(icon);
}
for (std::vector<boost::shared_ptr<GG::Texture> >::const_iterator it = head_textures.begin();
it != head_textures.end(); ++it)
{
RotatingGraphic* icon = new RotatingGraphic(*it, GG::GRAPHIC_FITGRAPHIC | GG::GRAPHIC_PROPSCALE);
icon->SetPhaseOffset(pointing_angle);
icon->SetRPM(0.0f);
icon->SetColor(this->Color());
m_icons.push_back(icon);
if (Width() < (*it)->DefaultWidth())
Resize(GG::Pt((*it)->DefaultWidth(), (*it)->DefaultHeight()));
AttachChild(icon);
}
// set up selection indicator
m_selection_indicator = new RotatingGraphic(FleetSelectionIndicatorIcon(), GG::GRAPHIC_FITGRAPHIC | GG::GRAPHIC_PROPSCALE);
m_selection_indicator->SetRPM(ClientUI::SystemSelectionIndicatorRPM());
LayoutIcons();
// Scanlines for not currently-visible objects?
int empire_id = HumanClientApp::GetApp()->EmpireID();
if (empire_id == ALL_EMPIRES || !GetOptionsDB().Get<bool>("UI.system-fog-of-war"))
return;
bool at_least_one_fleet_visible = false;
for (std::vector<int>::const_iterator it = m_fleets.begin(); it != m_fleets.end(); ++it) {
if (GetUniverse().GetObjectVisibilityByEmpire(*it, empire_id) >= VIS_BASIC_VISIBILITY) {
at_least_one_fleet_visible = true;
break;
}
}
// Create scanline renderer control
m_scanline_control = new ScanlineControl(GG::X0, GG::Y0, Width(), Height());
if (!at_least_one_fleet_visible)
AttachChild(m_scanline_control);
}