void
WindArrowLook::Initialise(const Font &_font, bool inverse)
{
arrow_pen.Create(Layout::Scale(1),
inverse
? (HasColors() ? LightColor(COLOR_GRAY) : COLOR_WHITE)
: (HasColors() ? DarkColor(COLOR_GRAY) : COLOR_BLACK));
tail_pen.Create(Pen::DASH2, 1, inverse ? COLOR_WHITE : COLOR_BLACK);
arrow_brush.Create(IsDithered() ? COLOR_DARK_GRAY : COLOR_GRAY);
font = &_font;
}
//删除所选的部分
void DcGp::DcGpPointCloud::DeleteChoosed()
{
std::vector<DCVector3D> points;
std::vector<PointColor> rgbColors;
std::vector<PointColor> selectColors;
std::vector<int> pointsVisibility; //显示表
for (unsigned i = 0; i < Size(); ++i)
{
if (m_pDcGpPointCloudImpl->m_pointsChoosedState[i] == false)
{
points.push_back(m_pDcGpPointCloudImpl->m_points[i]);
selectColors.push_back(m_pDcGpPointCloudImpl->m_choosedColors[i]);
if (HasColors())
{
rgbColors.push_back(m_pDcGpPointCloudImpl->m_rgbColors[i]);
}
//取出当前显示状态保存起来
pointsVisibility.push_back(GetPointVisibility(i));
//更新标量场值
}
}
m_pDcGpPointCloudImpl->m_points = points;
m_pDcGpPointCloudImpl->m_choosedColors = selectColors;
m_pDcGpPointCloudImpl->m_rgbColors = rgbColors;
m_pDcGpPointCloudImpl->m_pointsVisibility = pointsVisibility;
m_pDcGpPointCloudImpl->m_pointsChoosedState.resize(Size());
std::fill_n(m_pDcGpPointCloudImpl->m_pointsChoosedState.begin(), Size(), false);
//m_pDcGpPointCloudImpl->m_visibilityTable = false;
m_pDcGpPointCloudImpl->SetBorderInValid();
}
//设置指定点的选中状态
void DcGp::DcGpPointCloud::SetPointChoosed(unsigned index, bool status)
{
if (GetPointVisibility(index) == DCCore::POINT_VISIBLE)
{
m_pDcGpPointCloudImpl->m_pointsChoosedState[index] = status;
//设置选取点的颜色
if (status)
{
m_pDcGpPointCloudImpl->m_choosedColors[index][0] = 255;
m_pDcGpPointCloudImpl->m_choosedColors[index][1] = 0;
m_pDcGpPointCloudImpl->m_choosedColors[index][2] = 0;
}
else
{
if (HasColors() && GetColorMode() == eTrueLinearColor)
{
m_pDcGpPointCloudImpl->m_choosedColors[index] = m_pDcGpPointCloudImpl->m_rgbColors[index];
}
else if (GetColorMode() == eFalseRangeColor ||
GetColorMode() == eFalseHeightColor ||
GetColorMode() == eFalseScalarColor)
{
m_pDcGpPointCloudImpl->m_choosedColors[index] = m_pDcGpPointCloudImpl->m_scalarColors[index];
}
else
{
m_pDcGpPointCloudImpl->m_choosedColors[index][0] = GetTempColor()[0];
m_pDcGpPointCloudImpl->m_choosedColors[index][1] = GetTempColor()[1];
m_pDcGpPointCloudImpl->m_choosedColors[index][2] = GetTempColor()[2];
}
}
}
}
void
InfoBoxLook::Initialise(bool _inverse, bool use_colors,
unsigned width)
{
inverse = _inverse;
value.fg_color = title.fg_color = comment.fg_color =
inverse ? COLOR_WHITE : COLOR_BLACK;
background_color = inverse ? COLOR_BLACK : COLOR_WHITE;
caption_background_color = inverse
? Color(0x40, 0x40, 0x40)
: Color(0xe0, 0xe0, 0xe0);
focused_background_color = COLOR_XCSOAR_LIGHT;
pressed_background_color = COLOR_YELLOW;
Color border_color = Color(128, 128, 128);
border_pen.Create(BORDER_WIDTH, border_color);
ReinitialiseLayout(width);
unit_fraction_pen.Create(1, value.fg_color);
colors[0] = border_color;
if (HasColors() && use_colors) {
colors[1] = inverse ? COLOR_INVERSE_RED : COLOR_RED;
colors[2] = inverse ? COLOR_INVERSE_BLUE : COLOR_BLUE;
colors[3] = inverse ? COLOR_INVERSE_GREEN : Color(0, 192, 0);
colors[4] = inverse ? COLOR_INVERSE_YELLOW : COLOR_YELLOW;
colors[5] = inverse ? COLOR_INVERSE_MAGENTA : COLOR_MAGENTA;
} else
std::fill(colors + 1, colors + 6, inverse ? COLOR_WHITE : COLOR_BLACK);
}
void
TrafficLook::Initialise(const Font &_font)
{
if (HasColors()) {
safe_color = Color(0x1d,0x9b,0xc5);
warning_color = Color(0xfe,0x84,0x38);
alarm_color = Color(0xfb,0x35,0x2f);
} else {
safe_color = COLOR_WHITE;
warning_color = COLOR_GRAY;
alarm_color = COLOR_BLACK;
}
safe_brush.Create(safe_color);
warning_brush.Create(warning_color);
alarm_brush.Create(alarm_color);
plane_outline_pen.Create(2, COLOR_BLACK);
unsigned width = 4;
team_pen_green.Create(width, team_color_green);
team_pen_blue.Create(width, team_color_blue);
team_pen_yellow.Create(width, team_color_yellow);
team_pen_magenta.Create(width, team_color_magenta);
teammate_icon.LoadResource(IDB_TEAMMATE_POS, IDB_TEAMMATE_POS_HD);
font = &_font;
}
//取消选取
void DcGp::DcGpPointCloud::CancelChoosed()
{
if (!IsChoosed())
{
return;
}
//取消每个点的选取状态
std::fill_n(m_pDcGpPointCloudImpl->m_pointsChoosedState.begin(), Size(), false);
//清空每个点的选取颜色
if (HasColors() && GetColorMode() == eTrueLinearColor)
{
m_pDcGpPointCloudImpl->m_choosedColors = m_pDcGpPointCloudImpl->m_rgbColors;
}
else if (GetColorMode() == eFalseRangeColor ||
GetColorMode() == eFalseHeightColor ||
GetColorMode() == eFalseScalarColor)
{
m_pDcGpPointCloudImpl->m_choosedColors = m_pDcGpPointCloudImpl->m_scalarColors;
}
else
{
PointColor color = {GetTempColor()[0], GetTempColor()[1], GetTempColor()[2]};
std::fill_n(m_pDcGpPointCloudImpl->m_choosedColors.begin(), Size(), color);
}
}
//添加颜色
void DcGp::DcGpPointCloud::AddColor(PointColor color)
{
if (!HasColors())
{
ShowColors(true);
}
m_pDcGpPointCloudImpl->m_rgbColors.push_back(color);
}
void
DialogLook::Initialise(const Font &caption_font,
const Font &_text_font,
const Font &_small_font,
const Font &button_font,
const Font &list_font,
const Font &list_font_bold)
{
caption.text_color = COLOR_BLACK;
caption.font = &caption_font;
#ifdef EYE_CANDY
caption.background_bitmap.Load(IDB_DIALOGTITLE);
#else
caption.background_color = HasColors()? COLOR_XCSOAR_DARK : COLOR_BLACK;
caption.inactive_background_color = COLOR_GRAY;
#endif
if (!HasColors())
SetBackgroundColor(COLOR_WHITE);
else
SetBackgroundColor(Color(0xe2, 0xdc, 0xbe));
text_color = COLOR_BLACK;
text_font = &_text_font;
small_font = &_small_font;
button.Initialise(button_font);
focused.background_color = COLOR_XCSOAR_DARK;
focused.text_color = COLOR_WHITE;
focused.border_pen.Set(Layout::FastScale(1) + 2, COLOR_BLACK);
list.background_color = COLOR_WHITE;
list.text_color = COLOR_BLACK;
list.selected.background_color = COLOR_XCSOAR_LIGHT;
list.selected.text_color = COLOR_BLACK;
list.focused.background_color = COLOR_XCSOAR;
list.focused.text_color = COLOR_WHITE;
list.pressed.background_color = COLOR_YELLOW;
list.pressed.text_color = COLOR_BLACK;
list.font = &list_font;
list.font_bold = &list_font_bold;
}
void
LayoutConfigPanel::Prepare(ContainerWindow &parent, const PixelRect &rc)
{
const UISettings &ui_settings = CommonInterface::GetUISettings();
RowFormWidget::Prepare(parent, rc);
if (Display::RotateSupported())
AddEnum(_("Display orientation"), _("Rotate the display on devices that support it."),
display_orientation_list, (unsigned)ui_settings.display.orientation);
else
AddDummy();
AddEnum(_("InfoBox geometry"),
_("A list of possible InfoBox layouts. Do some trials to find the best for your screen size."),
info_box_geometry_list, (unsigned)ui_settings.info_boxes.geometry);
AddEnum(_("FLARM display"), _("Choose a location for the FLARM display."),
flarm_display_location_list,
(unsigned)ui_settings.traffic.gauge_location);
SetExpertRow(AppFlarmLocation);
AddEnum(_("Tab dialog style"), nullptr,
tabdialog_style_list, (unsigned)ui_settings.dialog.tab_style);
AddEnum(_("Message display"), nullptr,
popup_msg_position_list,
(unsigned)ui_settings.popup_message_position);
SetExpertRow(AppStatusMessageAlignment);
AddBoolean(_("Inverse InfoBoxes"), _("If true, the InfoBoxes are white on black, otherwise black on white."),
ui_settings.info_boxes.inverse);
SetExpertRow(AppInverseInfoBox);
if (HasColors()) {
AddBoolean(_("Colored InfoBoxes"),
_("If true, certain InfoBoxes will have coloured text. For example, the active waypoint "
"InfoBox will be blue when the glider is above final glide."),
ui_settings.info_boxes.use_colors);
SetExpertRow(AppInfoBoxColors);
} else
AddDummy();
AddEnum(_("InfoBox border"), nullptr, infobox_border_list,
unsigned(ui_settings.info_boxes.border_style));
SetExpertRow(AppInfoBoxBorder);
#ifdef KOBO
AddBoolean(_("Show Menubutton"), _("Show the Menubutton"),
ui_settings.show_menu_button);
SetExpertRow(ShowMenuButton);
#endif
}
void
TaskLook::Initialise()
{
// Magenta ICAO color is 0x65,0x23,0x1c
const Color task_color = Color(0x62, 0x4e, 0x90);
const Color bearing_color = Color(0x3e, 0x30, 0x5f);
const Color isoline_color = bearing_color;
oz_current_pen.Create(Pen::SOLID, Layout::ScalePenWidth(2), task_color);
oz_active_pen.Create(Pen::SOLID, Layout::ScalePenWidth(1), task_color);
oz_inactive_pen.Create(Pen::SOLID, Layout::ScalePenWidth(1),
DarkColor(task_color));
leg_active_pen.Create(Pen::DASH, Layout::ScalePenWidth(2), task_color);
leg_inactive_pen.Create(Pen::DASH, Layout::ScalePenWidth(1), task_color);
arrow_pen.Create(Layout::ScalePenWidth(1), task_color);
isoline_pen.Create(Pen::DASH, Layout::ScalePenWidth(1), isoline_color);
bearing_pen.Create(Layout::ScalePenWidth(2),
HasColors() ? bearing_color : COLOR_BLACK);
best_cruise_track_brush.Create(bearing_color);
best_cruise_track_pen.Create(Layout::ScalePenWidth(1),
HasColors()
? DarkColor(bearing_color)
: COLOR_BLACK);
highlight_pen.Create(Layout::ScalePenWidth(4), COLOR_BLACK);
target_icon.LoadResource(IDB_TARGET, IDB_TARGET_HD);
hbGray.Create(COLOR_GRAY);
hbGreen.Create(COLOR_GREEN);
hbOrange.Create(COLOR_ORANGE);
hbLightGray.Create(COLOR_LIGHT_GRAY);
hbNotReachableTerrain.Create(LightColor(COLOR_RED));
}
void
ButtonLook::Initialise(const Font &_font)
{
font = &_font;
standard.foreground_color = COLOR_BLACK;
standard.foreground_brush.Set(standard.foreground_color);
standard.background_color = IsDithered() ? COLOR_WHITE : COLOR_LIGHT_GRAY;
if (IsDithered()) {
standard.light_border_pen.Set(1, COLOR_BLACK);
standard.dark_border_pen.Set(1, COLOR_BLACK);
} else if (!HasColors()) {
standard.light_border_pen.Set(1, LightColor(COLOR_DARK_GRAY));
standard.dark_border_pen.Set(1, COLOR_BLACK);
} else {
standard.light_border_pen.Set(1, LightColor(standard.background_color));
standard.dark_border_pen.Set(1, DarkColor(standard.background_color));
}
focused.foreground_color = COLOR_WHITE;
focused.foreground_brush.Set(focused.foreground_color);
focused.background_color = IsDithered() ? COLOR_BLACK : COLOR_XCSOAR_DARK;
if (IsDithered()) {
focused.light_border_pen.Set(1, COLOR_WHITE);
focused.dark_border_pen.Set(1, COLOR_WHITE);
} else if (!HasColors()) {
focused.light_border_pen.Set(1, LightColor(COLOR_DARK_GRAY));
focused.dark_border_pen.Set(1, COLOR_BLACK);
} else {
focused.light_border_pen.Set(1, LightColor(focused.background_color));
focused.dark_border_pen.Set(1, DarkColor(focused.background_color));
}
disabled.color = COLOR_GRAY;
disabled.brush.Set(disabled.color);
}
void
AirspaceRendererSettings::SetDefaults()
{
enable = true;
black_outline = false;
altitude_mode = AirspaceDisplayMode::ALLON;
clip_altitude = 1000;
#if defined(HAVE_HATCHED_BRUSH) && defined(HAVE_ALPHA_BLEND)
transparency = false;
#endif
fill_mode = FillMode::DEFAULT;
label_selection = LabelSelection::NONE;
for (auto it = classes; it != classes + AIRSPACECLASSCOUNT; ++it)
it->SetDefaults();
classes[CLASSG].display = false;
#ifdef HAVE_HATCHED_BRUSH
classes[OTHER].brush = 2;
classes[CLASSA].brush = 3;
classes[CLASSB].brush = 3;
classes[CLASSC].brush = 3;
classes[CLASSD].brush = 3;
classes[CTR].brush = 3;
classes[WAVE].brush = 2;
classes[AATASK].brush = 3;
classes[CLASSE].brush = 3;
classes[CLASSF].brush = 3;
classes[RMZ].brush = 3;
#endif
classes[OTHER].SetColors(RGB8_CYAN);
classes[DANGER].SetColors(RGB8_MAGENTA.Darken());
classes[MATZ].SetColors(RGB8_MAGENTA.Darken());
classes[CLASSC].SetColors(RGB8_MAGENTA.Darken());
classes[CLASSD].SetColors(RGB8_BLUE);
classes[CTR].SetColors(RGB8_MAGENTA.Darken());
classes[WAVE].SetColors(RGB8_YELLOW.Darken());
classes[AATASK].SetColors(HasColors() ? RGB8_YELLOW : RGB8_MAGENTA);
classes[CLASSE].SetColors(RGB8_GREEN.Darken());
classes[CLASSF].SetColors(RGB8_GREEN.Darken());
classes[RMZ].SetColors(RGB8_MAGENTA.Darken());
}
//获取显示参数
void DcGp::DcGpPointCloud::GetDrawingParameters(glDrawParameters& params) const
{
//颜色重写
if (IsColorOverriden())
{
params.showColors = true;
params.showNormals = HasNormals() && NormalsShown();
params.showScalarField = false;
}
else
{
params.showScalarField = HasScalarFields() && ScalarFieldShown();
params.showNormals = HasNormals() && NormalsShown();
params.showColors = !params.showScalarField && HasColors() && ColorsShown();
}
}
void
MapLook::Initialise(const MapSettings &settings,
const Font &font, const Font &bold_font)
{
waypoint.Initialise(settings.waypoint, font, bold_font);
airspace.Initialise(settings.airspace, font);
aircraft.Initialise();
task.Initialise();
marker.Initialise();
trail.Initialise(settings.trail);
wave.Initialise();
wind.Initialise(bold_font);
#ifdef HAVE_NOAA
noaa.Initialise();
#endif
#ifdef HAVE_HATCHED_BRUSH
above_terrain_bitmap.Load(IDB_ABOVETERRAIN);
above_terrain_brush.Set(above_terrain_bitmap);
#endif
terrain_warning_icon.LoadResource(IDB_TERRAINWARNING, IDB_TERRAINWARNING_HD);
compass_brush.Set(IsDithered() ? COLOR_WHITE : Color(207, 207, 207));
compass_pen.Set(Layout::ScalePenWidth(1), HasColors()? COLOR_GRAY : COLOR_BLACK);
compass_triangle_brush.Set(IsDithered() ? COLOR_BLACK : Color(50, 50, 50));
compass_triangle_pen.Set(Layout::ScalePenWidth(1), HasColors()? COLOR_GRAY : COLOR_BLACK);
traffic_safe_icon.LoadResource(IDB_TRAFFIC_SAFE, IDB_TRAFFIC_SAFE_HD, false);
traffic_warning_icon.LoadResource(IDB_TRAFFIC_WARNING, IDB_TRAFFIC_WARNING_HD, false);
traffic_alarm_icon.LoadResource(IDB_TRAFFIC_ALARM, IDB_TRAFFIC_ALARM_HD, false);
static constexpr Color clrSepia(0x78,0x31,0x18);
reach_pen.Set(Pen::DASH, Layout::ScalePenWidth(1), clrSepia);
reach_pen_thick.Set(Pen::DASH, Layout::ScalePenWidth(2), clrSepia);
track_line_pen.Set(3, COLOR_GRAY);
contest_pens[0].Set(Layout::ScalePenWidth(1) + 2, COLOR_RED);
contest_pens[1].Set(Layout::ScalePenWidth(1) + 1, COLOR_ORANGE);
contest_pens[2].Set(Layout::ScalePenWidth(1), COLOR_BLUE);
thermal_source_icon.LoadResource(IDB_THERMALSOURCE, IDB_THERMALSOURCE_HD);
traffic_safe_icon.LoadResource(IDB_TRAFFIC_SAFE, IDB_TRAFFIC_SAFE_HD, false);
traffic_warning_icon.LoadResource(IDB_TRAFFIC_WARNING, IDB_TRAFFIC_WARNING_HD, false);
traffic_alarm_icon.LoadResource(IDB_TRAFFIC_ALARM, IDB_TRAFFIC_ALARM_HD, false);
map_scale_left_icon.LoadResource(IDB_MAPSCALE_LEFT, IDB_MAPSCALE_LEFT_HD, false);
map_scale_right_icon.LoadResource(IDB_MAPSCALE_RIGHT, IDB_MAPSCALE_RIGHT_HD, false);
logger_on_icon.LoadResource(IDB_LOGGER, IDB_LOGGER_HD);
logger_off_icon.LoadResource(IDB_LOGGEROFF, IDB_LOGGEROFF_HD);
cruise_mode_icon.LoadResource(IDB_CRUISE, IDB_CRUISE_HD, false);
climb_mode_icon.LoadResource(IDB_CLIMB, IDB_CLIMB_HD, false);
final_glide_mode_icon.LoadResource(IDB_FINALGLIDE, IDB_FINALGLIDE_HD, false);
abort_mode_icon.LoadResource(IDB_ABORT, IDB_ABORT_HD, false);
waiting_for_fix_icon.LoadResource(IDB_GPSSTATUS1, IDB_GPSSTATUS1_HD, false);
no_gps_icon.LoadResource(IDB_GPSSTATUS2, IDB_GPSSTATUS2_HD, false);
overlay_font = &bold_font;
}
bool
LayoutConfigPanel::Save(bool &_changed)
{
bool changed = false;
UISettings &ui_settings = CommonInterface::SetUISettings();
bool orientation_changed = false;
if (Display::RotateSupported()) {
orientation_changed =
SaveValueEnum(MapOrientation, ProfileKeys::MapOrientation,
ui_settings.display.orientation);
changed |= orientation_changed;
}
bool info_box_geometry_changed = false;
info_box_geometry_changed |=
SaveValueEnum(AppInfoBoxGeom, ProfileKeys::InfoBoxGeometry,
ui_settings.info_boxes.geometry);
info_box_geometry_changed |=
SaveValueEnum(AppFlarmLocation, ProfileKeys::FlarmLocation,
ui_settings.traffic.gauge_location);
changed |= info_box_geometry_changed;
changed |= SaveValueEnum(AppStatusMessageAlignment, ProfileKeys::AppStatusMessageAlignment,
ui_settings.popup_message_position);
changed |= SaveValueEnum(AppInfoBoxBorder, ProfileKeys::AppInfoBoxBorder,
ui_settings.info_boxes.border_style);
if (SaveValue(AppInverseInfoBox, ProfileKeys::AppInverseInfoBox,
ui_settings.info_boxes.inverse))
require_restart = changed = true;
if (HasColors() &&
SaveValue(AppInfoBoxColors, ProfileKeys::AppInfoBoxColors,
ui_settings.info_boxes.use_colors))
require_restart = changed = true;
#ifdef KOBO
if (SaveValue(ShowMenuButton, ProfileKeys::ShowMenuButton,ui_settings.show_menu_button))
require_restart = changed = true;
#endif
DialogSettings &dialog_settings = CommonInterface::SetUISettings().dialog;
changed |= SaveValueEnum(TabDialogStyle, ProfileKeys::AppDialogTabStyle, dialog_settings.tab_style);
if (orientation_changed) {
assert(Display::RotateSupported());
if (ui_settings.display.orientation == DisplayOrientation::DEFAULT)
Display::RotateRestore();
else {
if (!Display::Rotate(ui_settings.display.orientation))
LogFormat("Display rotation failed");
}
#ifdef KOBO
event_queue->SetMouseRotation(ui_settings.display.orientation);
#endif
CommonInterface::main_window->CheckResize();
} else if (info_box_geometry_changed)
CommonInterface::main_window->ReinitialiseLayout();
_changed |= changed;
return true;
}
void
MapLook::Initialise(const MapSettings &settings,
const Font &font, const Font &bold_font)
{
const uint8_t alpha = ALPHA_OVERLAY;
waypoint.Initialise(settings.waypoint, font, bold_font);
aircraft.Initialise();
task.Initialise();
trail.Initialise(settings.trail);
wave.Initialise();
wind.Initialise(bold_font);
#ifdef HAVE_NOAA
noaa.Initialise();
#endif
#ifdef HAVE_HATCHED_BRUSH
above_terrain_bitmap.Load(IDB_ABOVETERRAIN);
above_terrain_brush.Create(above_terrain_bitmap);
#endif
terrain_warning_icon.LoadResource(IDB_TERRAINWARNING, IDB_TERRAINWARNING_HD);
compass_brush.Create(IsDithered() ? COLOR_WHITE : ColorWithAlpha(Color(207, 207, 207), alpha));
compass_pen.Create(Layout::ScalePenWidth(1),
HasColors()? COLOR_GRAY : COLOR_BLACK);
compass_triangle_brush.Create(IsDithered()
? COLOR_BLACK
: ColorWithAlpha(Color(50, 50, 50), alpha));
compass_triangle_pen.Create(Layout::ScalePenWidth(1),
HasColors() ? COLOR_GRAY : COLOR_BLACK);
traffic_safe_icon.LoadResource(IDB_TRAFFIC_SAFE, IDB_TRAFFIC_SAFE_HD, false);
traffic_warning_icon.LoadResource(IDB_TRAFFIC_WARNING, IDB_TRAFFIC_WARNING_HD, false);
traffic_alarm_icon.LoadResource(IDB_TRAFFIC_ALARM, IDB_TRAFFIC_ALARM_HD, false);
static constexpr Color clrSepia(0x78,0x31,0x18);
reach_terrain_pen.Create(Pen::DASH3, Layout::ScalePenWidth(1), clrSepia);
reach_terrain_pen_thick.Create(Pen::DASH3, Layout::ScalePenWidth(2), clrSepia);
static constexpr Color clrBlupia(0x38,0x55,0xa7);
reach_working_pen.Create(Pen::DASH1, Layout::ScalePenWidth(1), clrBlupia);
reach_working_pen_thick.Create(Pen::DASH1, Layout::ScalePenWidth(2), clrBlupia);
track_line_pen.Create(3, COLOR_GRAY);
contest_pens[0].Create(Layout::ScalePenWidth(1) + 2, COLOR_RED);
contest_pens[1].Create(Layout::ScalePenWidth(1) + 1, COLOR_ORANGE);
contest_pens[2].Create(Layout::ScalePenWidth(1), COLOR_BLUE);
thermal_source_icon.LoadResource(IDB_THERMALSOURCE, IDB_THERMALSOURCE_HD);
traffic_safe_icon.LoadResource(IDB_TRAFFIC_SAFE, IDB_TRAFFIC_SAFE_HD, false);
traffic_warning_icon.LoadResource(IDB_TRAFFIC_WARNING, IDB_TRAFFIC_WARNING_HD, false);
traffic_alarm_icon.LoadResource(IDB_TRAFFIC_ALARM, IDB_TRAFFIC_ALARM_HD, false);
cruise_mode_icon.LoadResource(IDB_CRUISE, IDB_CRUISE_HD, false);
climb_mode_icon.LoadResource(IDB_CLIMB, IDB_CLIMB_HD, false);
final_glide_mode_icon.LoadResource(IDB_FINALGLIDE, IDB_FINALGLIDE_HD, false);
abort_mode_icon.LoadResource(IDB_ABORT, IDB_ABORT_HD, false);
waiting_for_fix_icon.LoadResource(IDB_GPSSTATUS1, IDB_GPSSTATUS1_HD, false);
no_gps_icon.LoadResource(IDB_GPSSTATUS2, IDB_GPSSTATUS2_HD, false);
topography.Initialise();
airspace.Initialise(settings.airspace, topography.important_label_font);
overlay.Initialise(font, bold_font);
}
bool Mesh::Load(const GLfloat* positions,
const GLfloat* colors,
const GLfloat* normals,
const GLfloat* texCoords,
const GLuint* indices,
int numVertices,
int numIndices,
GLenum drawMode,
StorageType storageType
)
{
if (!positions || numVertices <= 0)
{
return false;
}
mDrawMode = drawMode;
mStorageType = storageType;
mNumVertices = numVertices;
mNumIndices = (numIndices <= 0 || indices == nullptr) ? numVertices : numIndices;
mHasColors = (colors != nullptr);
mHasNormals = (normals != nullptr);
mHasTexCoord = (texCoords != nullptr);
mVertexSize = 3 + 3*mHasColors + 3*mHasNormals + 2*mHasTexCoord;
mVertices = new GLfloat [mVertexSize * mNumVertices];
mIndices = new GLuint [mNumIndices];
if (mStorageType == kTightlyPacked)
{
// Initialize vertices buffer array.
for (int i = 0; i < mNumVertices; i++)
{
float* position = PositionAt(i);
float* texCoord = TexCoordAt(i);
float* normal = NormalAt(i);
float* color = ColorAt(i);
memcpy(position, positions + 3*i, sizeof(GLfloat)*3);
if (HasColors())
{
memcpy(color, colors + 3*i, sizeof(GLfloat)*3);
}
if (HasNormals())
{
memcpy(normal, normals + 3*i, sizeof(GLfloat)*3);
}
if (HasTexCoord())
{
memcpy(texCoord, texCoords + 2*i, sizeof(GLfloat)*2);
}
}
}
else
{
GLfloat* dest = mVertices;
memcpy(dest, positions, 3*sizeof(GLfloat)*mNumVertices);
dest += 3*mNumVertices;
if (HasColors())
{
memcpy(dest, colors, 3*sizeof(GLfloat)*mNumVertices);
dest += 3*mNumVertices;
}
if (HasNormals())
{
memcpy(dest, normals, 3*sizeof(GLfloat)*mNumVertices);
dest += 3*mNumVertices;
}
if (HasTexCoord())
{
memcpy(dest, texCoords, 2*sizeof(GLfloat)*mNumVertices);
dest += 2*mNumVertices;
}
}
// Initialize element array (indices array).
if (indices) // Element array provided.
{
memcpy(mIndices, indices, sizeof(GLuint)*mNumIndices);
}
else // Element array wasn't provided -- build it up.
{
for (int i = 0; i < mNumIndices; i++)
{
mIndices[i] = i;
}
}
mInitialized = true;
Mesh::Upload();
return true;
}
void Mesh::Upload()
{
if (mProgramHandle == 0)
{
std::cerr << "ERROR Program Handle must be set before creating buffer objects.\n";
return;
}
if (!mInitialized)
{
std::cerr << "ERROR The mesh must be initialized before creating buffer objects.\n";
return;
}
// Specify how the arguments will be passed to shaders.
GLuint locTexCoordAttrib = glGetAttribLocation(mProgramHandle, "in_tex_coord");
GLuint locPositionAttrib = glGetAttribLocation(mProgramHandle, "in_position");
GLuint locNormalAttrib = glGetAttribLocation(mProgramHandle, "in_normal");
GLuint locColorAttrib = glGetAttribLocation(mProgramHandle, "in_color");
// Generate Buffers.
glGenVertexArrays(1, &mVao);
glGenBuffers(1, &mVbo);
glGenBuffers(1, &mEab);
// Specify VAO.
glBindVertexArray(mVao);
// Upload indices to GPU.
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mEab);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, mNumIndices * sizeof(GLuint), mIndices, GL_STATIC_DRAW);
// Enable/Disable each vertex attribute.
glEnableVertexAttribArray(locPositionAttrib);
if (HasColors())
{
glEnableVertexAttribArray(locColorAttrib);
}
else
{
glDisableVertexAttribArray(locColorAttrib);
}
if (HasNormals())
{
glEnableVertexAttribArray(locNormalAttrib);
}
else
{
glDisableVertexAttribArray(locNormalAttrib);
}
if (HasTexCoord())
{
glEnableVertexAttribArray(locTexCoordAttrib);
}
else
{
glDisableVertexAttribArray(locTexCoordAttrib);
}
// Upload vertices to GPU.
glBindBuffer(GL_ARRAY_BUFFER, mVbo);
glBufferData(GL_ARRAY_BUFFER, mVertexSize * mNumVertices * sizeof(GLfloat), mVertices, GL_STATIC_DRAW);
if (mStorageType == kTightlyPacked)
{
GLfloat stride = sizeof(GLfloat) * mVertexSize;
glVertexAttribPointer(locPositionAttrib, 3, GL_FLOAT, GL_FALSE, stride, 0);
glVertexAttribPointer(locColorAttrib, 3, GL_FLOAT, GL_FALSE, stride,
(void*)(sizeof(GLfloat) * 3));
glVertexAttribPointer(locNormalAttrib, 3, GL_FLOAT, GL_FALSE, stride,
(void*)(sizeof(GLfloat) * (3 + 3*mHasColors)));
glVertexAttribPointer(locTexCoordAttrib, 2, GL_FLOAT, GL_FALSE, stride,
(void*)(sizeof(GLfloat) * (3 + 3*mHasColors + 3*mHasNormals)) );
}
else // Sub buffered storage type.
{
glVertexAttribPointer(locPositionAttrib, 3, GL_FLOAT, GL_FALSE, 0, 0);
glVertexAttribPointer(locColorAttrib, 3, GL_FLOAT, GL_FALSE, 0,
(void*)(sizeof(GLfloat) * 3*mNumVertices));
glVertexAttribPointer(locNormalAttrib, 3, GL_FLOAT, GL_FALSE, 0,
(void*)(sizeof(GLfloat) * (3 + 3*mHasColors)*mNumVertices));
glVertexAttribPointer(locTexCoordAttrib, 2, GL_FLOAT, GL_FALSE, 0,
(void*)(sizeof(GLfloat) * (3 + 3*mHasColors + 3*mHasNormals)*mNumVertices));
}
}
// Reloads the geometry. To keep some data constant, just specify nullptr.
void Mesh::Reload(const GLfloat* positions,
const GLfloat* colors,
const GLfloat* normals,
const GLfloat* texCoords
)
{
if (!mInitialized)
{
std::cerr << "ERROR The mesh must be initialized before creating buffer objects.\n";
return;
}
if (mStorageType == kTightlyPacked)
{
for (int i = 0; i < mNumVertices; i++)
{
float* position = PositionAt(i);
float* texCoord = TexCoordAt(i);
float* normal = NormalAt(i);
float* color = ColorAt(i);
if (positions)
{
memcpy(position, positions + 3*i, sizeof(GLfloat)*3);
}
if (colors && HasColors())
{
memcpy(color, colors + 3*i, sizeof(GLfloat)*3);
}
if (normals && HasNormals())
{
memcpy(normal, normals + 3*i, sizeof(GLfloat)*3);
}
if (texCoords && HasTexCoord())
{
memcpy(texCoord, texCoords + 2*i, sizeof(GLfloat)*2);
}
}
}
else // Sub-buffered.
{
GLfloat* dest = mVertices;
if (positions)
{
memcpy(dest, positions, 3*sizeof(GLfloat)*mNumVertices);
dest += 3*mNumVertices;
}
if (colors && HasColors())
{
memcpy(dest, colors, 3*sizeof(GLfloat)*mNumVertices);
dest += 3*mNumVertices;
}
if (normals && HasNormals())
{
memcpy(dest, normals, 3*sizeof(GLfloat)*mNumVertices);
dest += 3*mNumVertices;
}
if (texCoords && HasTexCoord())
{
memcpy(dest, texCoords, 2*sizeof(GLfloat)*mNumVertices);
dest += 2*mNumVertices;
}
}
Mesh::Upload();
}
//刷新选取颜色
void DcGp::DcGpPointCloud::RefreshChoosedColor()
{
if (m_pDcGpPointCloudImpl->m_choosedColors.size() == 0)
{
return;
}
switch (GetColorMode())
{
case eAmplitudeLinearColor:
break;
case eFalseRangeColor:
m_pDcGpPointCloudImpl->m_choosedColors = m_pDcGpPointCloudImpl->m_scalarColors;
break;
case eFalseHeightColor:
m_pDcGpPointCloudImpl->m_choosedColors = m_pDcGpPointCloudImpl->m_scalarColors;
break;
case eFalseScalarColor:
m_pDcGpPointCloudImpl->m_choosedColors = m_pDcGpPointCloudImpl->m_scalarColors;
break;
case eTrueLinearColor:
if (HasColors())
{
//如果数据有真实颜色
for (unsigned i = 0; i < Size(); ++i)
{
if (false == m_pDcGpPointCloudImpl->m_pointsChoosedState[i])
{
m_pDcGpPointCloudImpl->m_choosedColors[i] = m_pDcGpPointCloudImpl->m_rgbColors[i];
}
}
}
else
{
//数据没有真实颜色
for (unsigned i = 0; i < Size(); ++i)
{
if (false == m_pDcGpPointCloudImpl->m_pointsChoosedState[i])
{
m_pDcGpPointCloudImpl->m_choosedColors[i] = GetTempColor();
}
}
}
break;
case eTrueLogarithmicColor:
break;
case eSingleColor:
for (unsigned i = 0; i < Size(); ++i)
{
if (false == m_pDcGpPointCloudImpl->m_pointsChoosedState[i])
{
m_pDcGpPointCloudImpl->m_choosedColors[i] = GetTempColor();
}
}
break;
case eDeviationColor:
break;
default:
break;
}
}
