source/gui/CGUISprite.h

   1 /* Copyright (C) 2022 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 /*
  19         A GUI Sprite, which is actually a collage of several
  20         sprites.
  21 */
  22
  23 #ifndef INCLUDED_CGUISPRITE
  24 #define INCLUDED_CGUISPRITE
  25
  26 #include "gui/GUIRenderer.h"
  27 #include "gui/SettingTypes/CGUISize.h"
  28 #include "gui/SettingTypes/CGUIColor.h"
  29 #include "lib/file/vfs/vfs_path.h"
  30 #include "ps/CStr.h"
  31 #include "renderer/backend/Sampler.h"
  32
  33 #include <map>
  34 #include <memory>
  35 #include <vector>
  36
  37 class CCanvas2D;
  38
  39 struct SGUIImageEffects
  40 {
  41         SGUIImageEffects() : m_Greyscale(false) {}
  42         CGUIColor m_AddColor;
  43         CGUIColor m_SolidColor;
  44         bool m_Greyscale;
  45 };
  46
  47 /**
  48  * A CGUISprite is actually a collage of several <b>real</b>
  49  * sprites, this struct represents is such real sprite.
  50  */
  51 struct SGUIImage
  52 {
  53         NONCOPYABLE(SGUIImage);
  54 public:
  55         SGUIImage() :
  56                 m_FixedHAspectRatio(0.f),
  57                 m_RoundCoordinates(true),
  58                 m_AddressMode(Renderer::Backend::Sampler::AddressMode::REPEAT),
  59                 m_Effects(),
  60                 m_Size(CGUISize::Full()),
  61                 m_TextureSize(CGUISize::Full())
  62         {
  63         }
  64
  65         // Filename of the texture
  66         VfsPath m_TextureName;
  67
  68         // Image placement (relative to object)
  69         CGUISize m_Size;
  70
  71         // Texture placement (relative to image placement)
  72         CGUISize m_TextureSize;
  73
  74         // Because OpenGL wants textures in squares with a power of 2 (64x64, 256x256)
  75         //  it's sometimes tedious to adjust this. So this value simulates which area
  76         //  is the real texture
  77         CRect m_TexturePlacementInFile;
  78
  79         /**
  80          * If non-zero, then the image's width will be adjusted when rendering so that
  81          * the width:height ratio equals this value.
  82          */
  83         float m_FixedHAspectRatio;
  84
  85         /**
  86          * If true, the image's coordinates will be rounded to integer pixels when
  87          * rendering, to avoid blurry filtering.
  88          */
  89         bool m_RoundCoordinates;
  90
  91         /**
  92          * Texture address mode (REPEAT, CLAMP_TO_EDGE, etc).
  93          */
  94         Renderer::Backend::Sampler::AddressMode m_AddressMode;
  95
  96         // Visual effects (e.g. color modulation)
  97         std::shared_ptr<SGUIImageEffects> m_Effects;
  98
  99         // Color
 100         CGUIColor m_BackColor;
 101 };
 102
 103 /**
 104  * The GUI sprite, is actually several real sprites (images)
 105  * like a collage. View the section \<sprites\> in the GUI
 106  * TDD for more information.
 107  *
 108  * Drawing routine is located in CGUI
 109  *
 110  * @see CGUI#DrawSprite
 111  */
 112 class CGUISprite
 113 {
 114         NONCOPYABLE(CGUISprite);
 115 public:
 116         CGUISprite() {}
 117         virtual ~CGUISprite();
 118
 119         /**
 120          * Adds an image to the sprite collage.
 121          *
 122          * @param image Adds this image to the sprite collage.
 123          */
 124         void AddImage(std::unique_ptr<SGUIImage> image);
 125
 126         /// List of images
 127         std::vector<std::unique_ptr<SGUIImage>> m_Images;
 128 };
 129
 130 // An instance of a sprite, usually stored in IGUIObjects - basically a string
 131 // giving the sprite's name, but with some extra data to cache rendering
 132 // calculations between draw calls.
 133 class CGUISpriteInstance
 134 {
 135 public:
 136         NONCOPYABLE(CGUISpriteInstance);
 137         MOVABLE(CGUISpriteInstance);
 138
 139         CGUISpriteInstance();
 140         CGUISpriteInstance(const CStr& SpriteName);
 141
 142         void Draw(CGUI& pGUI, CCanvas2D& canvas, const CRect& Size, std::map<CStr, std::unique_ptr<const CGUISprite>>& Sprites) const;
 143
 144         /**
 145          * Whether this Sprite has no texture name set.
 146          */
 147         operator bool() const { return !m_SpriteName.empty(); };
 148
 149         /**
 150          * Returns the sprite texture name.
 151          */
 152         const CStr& GetName() const { return m_SpriteName; }
 153
 154         /**
 155          * Changes the texture name.
 156          * Use as rarely as possible, because it clears the draw cache.
 157          */
 158         void SetName(const CStr& SpriteName);
 159
 160 private:
 161         CStr m_SpriteName;
 162
 163         // Stored drawing calls, for more efficient rendering
 164         mutable GUIRenderer::DrawCalls m_DrawCallCache;
 165         // Relevant details of previously rendered sprite; the cache is invalidated
 166         // whenever any of these values changes.
 167         mutable CRect m_CachedSize;
 168 };
 169
 170 #endif // INCLUDED_CGUISPRITE