source/graphics/Overlay.h

   1 /* Copyright (C) 2021 Wildfire Games.
   2  * This file is part of 0 A.D.
   3  *
   4  * 0 A.D. is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * 0 A.D. is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #ifndef INCLUDED_GRAPHICS_OVERLAY
  19 #define INCLUDED_GRAPHICS_OVERLAY
  20
  21 #include "graphics/Color.h"
  22 #include "graphics/Texture.h"
  23 #include "maths/Vector2D.h"
  24 #include "maths/Vector3D.h"
  25 #include "ps/CStrIntern.h"
  26
  27 #include <vector>
  28
  29 class CFrustum;
  30 class CSimContext;
  31 class CTexturedLineRData;
  32 struct SOverlayDescriptor;
  33
  34 /**
  35  * Line-based overlay, with world-space coordinates, rendered in the world
  36  * potentially behind other objects. Designed for debug info.
  37  */
  38 struct SOverlayLine
  39 {
  40         SOverlayLine() : m_Thickness(0.1f) { }
  41
  42         CColor m_Color;
  43         // Shape is not automatically closed.
  44         std::vector<CVector3D> m_Coords;
  45         // Half-width of the line, in world-space units.
  46         float m_Thickness;
  47
  48         void PushCoords(const CVector3D& v) { m_Coords.emplace_back(v); }
  49
  50         void PushCoords(const float x, const float y, const float z)
  51         {
  52                 m_Coords.emplace_back(x, y, z);
  53         }
  54 };
  55
  56 /**
  57  * Textured line overlay, with world-space coordinates, rendered in the world onto the terrain.
  58  * Designed for relatively static textured lines, i.e. territory borders, originally.
  59  *
  60  * Once submitted for rendering, instances must not be copied afterwards. The reason is that they
  61  * are assigned rendering data that is unique to the submitted instance, and non-transferable to
  62  * any copies that would otherwise be made. Amongst others, this restraint includes that they must
  63  * not be submitted by their address inside a std::vector storing them by value.
  64  */
  65 struct SOverlayTexturedLine
  66 {
  67         enum LineCapType
  68         {
  69                 LINECAP_FLAT, ///< no line ending; abrupt stop of the line (aka. butt ending)
  70
  71                 /**
  72                  * Semi-circular line ending. The texture is mapped by curving the left vertical edge
  73                  * around the semi-circle's rim. That is, the center point has UV coordinates (0.5;0.5),
  74                  * and the rim vertices all have U coordinate 0 and a V coordinate that ranges from 0 to
  75                  * 1 as the rim is traversed.
  76                  */
  77                 LINECAP_ROUND,
  78                 LINECAP_SHARP, ///< sharp point ending
  79                 LINECAP_SQUARE, ///< square end that extends half the line width beyond the line end
  80         };
  81
  82         SOverlayTexturedLine()
  83                 : m_Thickness(1.0f), m_Closed(false), m_AlwaysVisible(false),
  84                   m_StartCapType(LINECAP_FLAT), m_EndCapType(LINECAP_FLAT), m_SimContext(NULL)
  85         { }
  86
  87         CTexturePtr m_TextureBase;
  88         CTexturePtr m_TextureMask;
  89
  90         /// Color to apply to the line texture, where indicated by the mask.
  91         CColor m_Color;
  92         /// (x, z) vertex coordinate pairs; y is computed automatically.
  93         std::vector<CVector2D> m_Coords;
  94         /// Half-width of the line, in world-space units.
  95         float m_Thickness;
  96         /// Should this line be treated as a closed loop? If set, any end cap settings are ignored.
  97         bool m_Closed;
  98         /// Should this line be rendered fully visible at all times, even under the SoD?
  99         bool m_AlwaysVisible;
 100
 101         LineCapType m_StartCapType;
 102         LineCapType m_EndCapType;
 103
 104         /**
 105          * Simulation context applicable for this overlay line; used to obtain terrain information
 106          * during automatic computation of Y coordinates.
 107          */
 108         const CSimContext* m_SimContext;
 109
 110         /**
 111          * Cached renderer data, because expensive to compute. Allocated by the renderer when necessary
 112          * for rendering purposes.
 113          *
 114          * Note: the rendering data may be shared between copies of this object to prevent having to
 115          * recompute it, while at the same time maintaining copyability of this object (see also docs on
 116          * CTexturedLineRData).
 117          */
 118         std::shared_ptr<CTexturedLineRData> m_RenderData;
 119
 120         /**
 121          * Converts a string line cap type into its corresponding LineCap enum value, and returns
 122          * the resulting value. If the input string is unrecognized, a warning is issued and a
 123          * default value is returned.
 124          */
 125         static LineCapType StrToLineCapType(const std::wstring& str);
 126
 127         /**
 128          * Creates the texture specified by the given overlay descriptor and assigns it to this overlay.
 129          */
 130         void CreateOverlayTexture(const SOverlayDescriptor* overlayDescriptor);
 131
 132         void PushCoords(const float x, const float z) { m_Coords.emplace_back(x, z); }
 133         void PushCoords(const CVector2D& v) { m_Coords.push_back(v); }
 134         void PushCoords(const std::vector<CVector2D>& points)
 135         {
 136                 for (const CVector2D& point : points)
 137                         PushCoords(point);
 138         }
 139
 140         bool IsVisibleInFrustum(const CFrustum& frustum) const;
 141 };
 142
 143 /**
 144  * Billboard sprite overlay, with world-space coordinates, rendered on top
 145  * of all other objects. Designed for health bars and rank icons.
 146  */
 147 struct SOverlaySprite
 148 {
 149         CTexturePtr m_Texture;
 150         CColor m_Color;
 151         CVector3D m_Position; // base position
 152         float m_X0, m_Y0, m_X1, m_Y1; // billboard corner coordinates, relative to base position
 153 };
 154
 155 /**
 156  * Rectangular single-quad terrain overlay, in world space coordinates. The vertices of the quad
 157  * are not required to be coplanar; the quad is arbitrarily triangulated with no effort being made
 158  * to find a best fit to the underlying terrain.
 159  */
 160 struct SOverlayQuad
 161 {
 162         CTexturePtr m_Texture;
 163         CTexturePtr m_TextureMask;
 164         CVector3D m_Corners[4];
 165         CColor m_Color;
 166 };
 167
 168 struct SOverlaySphere
 169 {
 170         SOverlaySphere() : m_Radius(0) { }
 171
 172         CVector3D m_Center;
 173         float m_Radius;
 174         CColor m_Color;
 175 };
 176
 177 enum EOverlayType
 178 {
 179         /// A single textured quad overlay, intended for entities that move around much, like units (e.g. foot soldiers, etc).
 180         DYNAMIC_QUAD,
 181         /// A more complex textured line overlay, composed of several textured line segments.
 182         STATIC_OUTLINE,
 183 };
 184
 185 struct SOverlayDescriptor
 186 {
 187         EOverlayType m_Type;
 188         CStrIntern m_QuadTexture;
 189         CStrIntern m_QuadTextureMask;
 190         CStrIntern m_LineTexture;
 191         CStrIntern m_LineTextureMask;
 192         float m_LineThickness;
 193         int m_Radius;
 194
 195         SOverlayDescriptor() : m_LineThickness(0) { }
 196 };
 197
 198 // TODO: OverlayText
 199
 200 #endif // INCLUDED_GRAPHICS_OVERLAY