summaryrefslogtreecommitdiffhomepage
path: root/StarsEx/HUDView.h
blob: 4274ac990a64e47f5070ab79201401b05d6090ed (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
/*  Starshatter: The Open Source Project
    Copyright (c) 2021-2022, Starshatter: The Open Source Project Contributors
    Copyright (c) 2011-2012, Starshatter OpenSource Distribution Contributors
    Copyright (c) 1997-2006, Destroyer Studios LLC.

    AUTHOR:       John DiCamillo


    OVERVIEW
    ========
    View class for Heads Up Display
*/

#ifndef HUDView_h
#define HUDView_h

#include "Types.h"
#include "View.h"
#include "Bitmap.h"
#include "Font.h"
#include "System.h"
#include "SimObject.h"
#include "Text.h"

// +--------------------------------------------------------------------+

class Graphic;
class Sprite;
class Solid;
class Ship;
class Contact;
class Physical;
class OrbitalBody;
class OrbitalRegion;
class Instruction;
class CameraView;
class Projector;
class MFD;

// +--------------------------------------------------------------------+

class HUDView : public View,
public SimObserver
{
public:
    HUDView(Window* c);
    virtual ~HUDView();

    enum HUDModes { HUD_MODE_OFF, HUD_MODE_TAC, HUD_MODE_NAV, HUD_MODE_ILS };

    // Operations:
    virtual void      Refresh();
    virtual void      OnWindowMove();
    virtual void      ExecFrame();
    virtual void      UseCameraView(CameraView* v);

    virtual Ship*     GetShip()      const { return ship;   }
    virtual SimObject* GetTarget()   const { return target; }
    virtual void      SetShip(Ship* s);
    virtual void      SetTarget(SimObject* t);
    virtual MFD*      GetMFD(int n)  const;

    virtual void      HideAll();
    virtual void      DrawBars();
    virtual void      DrawNav();
    virtual void      DrawILS();
    virtual void      DrawObjective();
    virtual void      DrawNavInfo();
    virtual void      DrawNavPoint(Instruction& navpt, int index, int next);
    virtual void      DrawContactMarkers();
    virtual void      DrawContact(Contact* c, int index);
    virtual void      DrawTrack(Contact* c);
    virtual void      DrawTrackSegment(Point& t1, Point& t2, Color c);
    virtual void      DrawRect(SimObject* targ);
    virtual void      DrawTarget();
    virtual void      DrawSight();
    virtual void      DrawLCOS(SimObject* targ, double dist);
    virtual void      DrawDesignators();
    virtual void      DrawFPM();
    virtual void      DrawHPM();
    virtual void      DrawCompass();
    virtual void      HideCompass();
    virtual void      DrawPitchLadder();
    virtual void      DrawStarSystem();

    virtual void      DrawMFDs();
    virtual void      DrawWarningPanel();
    virtual void      DrawInstructions();
    virtual void      DrawMessages();

    virtual void      MouseFrame();

    virtual int       GetHUDMode()      const { return mode;     }
    virtual int       GetTacticalMode() const { return tactical; }
    virtual void      SetTacticalMode(int mode=1);
    virtual int       GetOverlayMode()  const { return overlay;  }
    virtual void      SetOverlayMode(int mode=1);

    virtual void      SetHUDMode(int mode);
    virtual void      CycleHUDMode();
    virtual Color     CycleHUDColor();
    virtual void      SetHUDColorSet(int c);
    virtual int       GetHUDColorSet()  const { return color;     }
    virtual Color     GetHUDColor()     const { return hud_color; }
    virtual Color     GetTextColor()    const { return txt_color; }
    virtual Color     Ambient()         const;
    virtual void      ShowHUDWarn();
    virtual void      ShowHUDInst();
    virtual void      HideHUDWarn();
    virtual void      HideHUDInst();
    virtual void      CycleHUDWarn();
    virtual void      CycleHUDInst();
    virtual void      CycleMFDMode(int mfd);
    virtual void      CycleInstructions(int direction);
    virtual void      RestoreHUD();

    virtual void      TargetOff() { target = 0; }
    static  Color     MarkerColor(Contact* targ);

    static bool       IsNameCrowded(int x, int y);
    static bool       IsMouseLatched();
    static HUDView*   GetInstance() { return hud_view; }
    static void       Message(const char* fmt, ...);
    static void       ClearMessages();
    static void       PrepareBitmap(const char* name, Bitmap& img, BYTE*& shades);
    static void       TransferBitmap(const Bitmap& src, Bitmap& img, BYTE*& shades);
    static void       ColorizeBitmap(Bitmap& img, BYTE* shades, Color color, bool force_alpha=false);

    static int        GetGunsight()              { return gunsight;      }
    static void       SetGunsight(int s)         { gunsight = s;         }
    static bool       IsArcade()                 { return arcade;        }
    static void       SetArcade(bool a)          { arcade = a;           }
    static int        DefaultColorSet()          { return def_color_set; }
    static void       SetDefaultColorSet(int c)  { def_color_set = c;    }
    static Color      GetStatusColor(System::STATUS status);
    static bool       ShowFPS()                  { return show_fps;      }
    static void       ShowFPS(bool f)            { show_fps = f;         }

    virtual bool         Update(SimObject* obj);
    virtual const char*  GetObserverName() const;

protected:
    const char*       FormatInstruction(Text instr);
    void              SetStatusColor(System::STATUS status);

    enum HUD_CASE { HUD_MIXED_CASE, HUD_UPPER_CASE };

    void              DrawDiamond(int x, int y, int r, Color c);
    void              DrawHUDText(int index, const char* txt, Rect& rect, int align, int upcase=HUD_UPPER_CASE, bool box=false);
    void              HideHUDText(int index);

    void              DrawOrbitalBody(OrbitalBody* body);

    Projector*  projector;
    CameraView* camview;

    int         width, height, aw, ah;
    double      xcenter, ycenter;

    Sim*        sim;
    Ship*       ship;
    SimObject*  target;

    SimRegion*  active_region;

    Bitmap*     cockpit_hud_texture;

    Color       hud_color;
    Color       txt_color;
    Color       status_color;

    bool        show_warn;
    bool        show_inst;
    int         inst_page;
    int         threat;

    int         mode;
    int         color;
    int         tactical;
    int         overlay;
    int         transition;
    int         docking;

    MFD*        mfd[3];

    Sprite*     pitch_ladder[31];
    Sprite*     hud_sprite[32];

    Solid*      az_ring;
    Solid*      az_pointer;
    Solid*      el_ring;
    Solid*      el_pointer;
    double      compass_scale;

    enum { MAX_MSG = 6 };
    Text        msg_text[MAX_MSG];
    double      msg_time[MAX_MSG];

    static HUDView*   hud_view;
    static bool       arcade;
    static bool       show_fps;
    static int        gunsight;
    static int        def_color_set;
};


// +--------------------------------------------------------------------+

struct HUDText {
    Font*    font;
    Color    color;
    Rect     rect;
    bool     hidden;
};

#endif  // HUDView_h