Fix all warnings

- Add `static_cast`s where necessary
- Simplify the interface of the Text class (only deal with utf-8 encoded
  `std::strings` and let the user manage the conversions)
- Use c++20

Author: tretre91

examples/magnifying_glass/magnifying_glass.cpp

@@ -56,14 +56,14 @@ int main() {
         window.setCamera(camera);
         const glm::vec2 win_size = window.getSize();
         window.setClipPlanes(0, win_size.x, win_size.y, 0);
-        window.setViewport(0, 0, win_size.x, win_size.y);
+        window.setViewport(0, 0, static_cast<int>(win_size.x), static_cast<int>(win_size.y));
 
         window.draw(rect);
         window.draw(frame);
 
         window.setCamera(frameCam);
-        window.setClipPlanes(zoomValue, frameSize - zoomValue, frameSize - zoomValue, zoomValue);
-        window.setViewport(framePos.x, win_size.y - framePos.y - frameSize, frameSize, frameSize);
+        window.setClipPlanes(static_cast<float>(zoomValue), static_cast<float>(frameSize - zoomValue), static_cast<float>(frameSize - zoomValue), static_cast<float>(zoomValue));
+        window.setViewport(framePos.x, static_cast<int>(win_size.y) - framePos.y - frameSize, frameSize, frameSize);
 
         window.draw(rect);
 

examples/text/text.cpp

@@ -25,11 +25,11 @@ int main() {
     for (wchar_t c = L'\u03B1'; c < L'\u03CA'; c++) {
         greek_lowercase += c;
     }
-    my::Text greek_alphabet(greek_lowercase, open_sans, 30);
+    my::Text greek_alphabet(my::util::toUtf8(greek_lowercase), open_sans, 30);
     greek_alphabet.setColor(my::Color::red);
     greek_alphabet.setPosition(50, 500);
 
-    my::Text math_formula(U"\u2200\U0001D465 \u2208 \u211D\u2217, 1/\U0001D465 is defined", math_font, 30);
+    my::Text math_formula(my::util::toUtf8(U"\u2200\U0001D465 \u2208 \u211D\u2217, 1/\U0001D465 is defined"), math_font, 30);
     math_formula.setColor(my::Color::green);
     math_formula.rotate(-20);
     math_formula.setPosition(600, 450, true);
@@ -41,7 +41,7 @@ int main() {
         }
         hiraganas += c;
     }
-    my::Text some_hiraganas(hiraganas, jp_font, 30);
+    my::Text some_hiraganas(my::util::toUtf8(hiraganas), jp_font, 30);
     some_hiraganas.setColor(my::Color::white);
     some_hiraganas.setPosition(window.getSize().x / 2, 75, true);
     some_hiraganas.setOutlineThickness(2);

include/MyGL/Color.hpp

@@ -6,6 +6,7 @@
 #include <glm/glm.hpp>
 
 #include <string>
+#include <cstdint>
 
 namespace my
 {
@@ -112,4 +113,4 @@ namespace my
 MYGL_EXPORT bool operator==(const my::Color& color1, const my::Color& color2) noexcept;
 MYGL_EXPORT bool operator!=(const my::Color& color1, const my::Color& color2) noexcept;
 
-#endif // MYGL_COLOR
+#endif // MYGL_COLOR

include/MyGL/Drawable/AbstractShape.hpp

@@ -10,6 +10,7 @@
 
 #include <string>
 #include <vector>
+#include <numbers>
 
 namespace my
 {
@@ -22,7 +23,7 @@ namespace my
         static void initShaders();
 
     protected:
-        static const float pi;
+        static constexpr float pi = std::numbers::pi_v<float>;
         static my::ShaderProgram shader;
         static my::ShaderProgram texShader;
 
@@ -174,7 +175,7 @@ namespace my
          * @param b The blue component
          * @param alpha The alpha (transparency) value, by default 255
          */
-        MYGL_EXPORT virtual void setColor(int r, int g, int b, int alpha = 255) noexcept;
+        MYGL_EXPORT virtual void setColor(uint8_t r, uint8_t g, uint8_t b, uint8_t alpha = 255) noexcept;
 
         /**
          * @brief Sets the shape's color from an existing color
@@ -207,7 +208,7 @@ namespace my
          * @param b The blue component
          * @param alpha The alpha (transparency) value, by default 255
          */
-        MYGL_EXPORT void setOutlineColor(int r, int g, int b, int alpha = 255) noexcept;
+        MYGL_EXPORT void setOutlineColor(uint8_t r, uint8_t g, uint8_t b, uint8_t alpha = 255) noexcept;
 
         /**
          * @brief Tells wether 2 shapes are overlapping using the separating

include/MyGL/Drawable/Font.hpp

@@ -29,11 +29,11 @@ namespace my
          * @param glyph A glyph slot containing the bitmap we want to copy (it
          *        should be loaded with the FT_LOAD_RENDER flag)
          * @param texture The vector we want to twrite to
-         * @param x The x coord of thetop left hand corner of the zone we wil copy the bitmap to
-         * @param y The y coord of thetop left hand corner of the zone we wil copy the bitmap to
+         * @param x The x coord of the top left hand corner of the zone we wil copy the bitmap to
+         * @param y The y coord of the top left hand corner of the zone we wil copy the bitmap to
          * @param width The final texture's width
          */
-        static void addGlyph(FT_GlyphSlot& glyph, std::vector<uint8_t>& texture, size_t x, size_t y, size_t width);
+        static void addGlyph(FT_GlyphSlot& glyph, std::vector<uint8_t>& texture, FT_Pos x, FT_Pos y, FT_Pos width);
 
         /**
          * @brief Creates a texture containing a string

include/MyGL/Drawable/Text.hpp

@@ -5,9 +5,38 @@
 
 #include "Font.hpp"
 #include "Rectangle.hpp"
+#include <iterator>
+#include <string_view>
+#include <utf8.h>
 
 namespace my
 {
+    namespace util
+    {
+        template<typename StringType>
+        inline std::string toUtf8(const StringType& text) {
+            std::basic_string_view view{std::begin(text), std::end(text)};
+
+            using CharType = typename decltype(view)::value_type;
+
+            if constexpr (sizeof(CharType) == 1) {
+                return view;
+            } else if constexpr (sizeof(CharType) == 2) {
+                std::string result;
+                result.reserve(2 * view.size());
+                utf8::utf16to8(view.begin(), view.end(), std::back_inserter(result));
+                return result;
+            } else if constexpr (sizeof(CharType) == 4) {
+                std::string result;
+                result.reserve(4 * view.size());
+                utf8::utf32to8(view.begin(), view.end(), std::back_inserter(result));
+                return result;
+            } else {
+                static_assert(false, "Unknown character encoding");
+            }
+        }
+    } // namespace util
+
     /**
      * @brief Class for drawing strings of text
      */
@@ -42,47 +71,28 @@ namespace my
          */
         MYGL_EXPORT Text();
 
-        /** @name Constructors
-            @{ */
         /**
          * @brief Creates a text object
-         * @param text A std::string (or wstring, u16string, u32string) with the text to
-         *        be displayed
+         * @param text A utf-8 encoded std::string with the text to be displayed
          * @param font A my::Font object defining the text's font
          * @param size The character size in pixels
          */
         MYGL_EXPORT Text(const std::string& text, my::Font& font, unsigned int size = 30u);
-        MYGL_EXPORT Text(const std::wstring& text, my::Font& font, unsigned int size = 30u);
-        MYGL_EXPORT Text(const std::u16string& text, my::Font& font, unsigned int size = 30u);
-        MYGL_EXPORT Text(const std::u32string& text, my::Font& font, unsigned int size = 30u);
-        /** @} */
 
         /** @brief Default destructor */
         MYGL_EXPORT ~Text() override;
 
-        /** @name Setters
-            @{ */
         /**
          * @brief Sets the displayed text's content
-         * @param text The new text to display
+         * @param text A utf-8 encoded std::string
          */
         MYGL_EXPORT void setContent(const std::string& text);
-        MYGL_EXPORT void setContent(const std::wstring& text);
-        MYGL_EXPORT void setContent(const std::u16string& text);
-        MYGL_EXPORT void setContent(const std::u32string& text);
-        /** @} */
 
-        /** @name Getters
-            @{ */
         /**
          * @brief Returns the text that is currently displayed
-         * @return The content of the string that is currently displayed
+         * @return The text that is currently displayed as a utf-8 encoded std::string
          */
-        MYGL_EXPORT std::string getString() const;
-        MYGL_EXPORT std::wstring getWString() const;
-        MYGL_EXPORT std::u16string getU16String() const;
-        MYGL_EXPORT std::u32string getU32String() const noexcept;
-        /** @} */
+        MYGL_EXPORT const std::string& getContent() const;
 
         /**
          * @brief Changes the font

include/MyGL/Image.hpp

@@ -4,6 +4,7 @@
 #include "mygl_export.h"
 #include <memory>
 #include <string>
+#include <cstdint>
 
 namespace my
 {
@@ -72,10 +73,9 @@ namespace my
         MYGL_EXPORT bool isUsable() const noexcept;
 
         /**
-         * @brief Returns a read only pointer to the pixel array
-         * @return
+         * @brief Returns a pointer to the pixel array
          */
-        MYGL_EXPORT const uint8_t* data() const noexcept;
+        MYGL_EXPORT uint8_t* data() const noexcept;
 
         /**
          * @brief Indicates the image's width
@@ -97,4 +97,4 @@ namespace my
     };
 } // namespace my
 
-#endif // MYGL_IMAGE
+#endif // MYGL_IMAGE

include/MyGL/Texture.hpp

@@ -113,7 +113,7 @@ namespace my
          * @param b The blue component
          * @param alpha The alpha component
          */
-        MYGL_EXPORT void setBorderColor(int r, int g, int b, int alpha = 255);
+        MYGL_EXPORT void setBorderColor(uint8_t r, uint8_t g, uint8_t b, uint8_t alpha = 255);
 
         /**
          * @brief Sets the border color used with GL_CLAMP_TO_BORDER wrapping method

include/MyGL/Window.hpp

@@ -158,7 +158,7 @@ namespace my
          * @param bottom The frustum's bottom coordinate
          * @param top The frustum's top coordinate
          */
-        MYGL_EXPORT void setClipPlanes(int left, int right, int bottom, int top);
+        MYGL_EXPORT void setClipPlanes(float left, float right, float bottom, float top);
 
         /**
          * @brief Sets the viewport's position and size

include/MyGL/common.hpp

@@ -23,9 +23,9 @@ namespace my
      * @brief Helper function for static variables relying on glfw functions
      *
      * This function should be used to call glfw functions when it is unsure
-     * whether glfw was already initialized (for example in static variables'
+     * whether glfw was already initialized (for example in static variables
      * definitions), it ensures that glfw is initialized before calling the
-     * function
+     * function.
      *
      * @tparam GLFWfunction
      * @tparam ...Args
@@ -38,13 +38,6 @@ namespace my
         initGLFW();
         return function(args...);
     }
-
-    /**
-     * @brief Sleeps for a certain amount of time
-     * @param nanoseconds The sleep time in nanoseconds
-     */
-    MYGL_EXPORT void sleep(unsigned long long nanoseconds); // TODO
-
 } // namespace my
 
-#endif // MYGL_COMMON
+#endif // MYGL_COMMON

meson.build

@@ -1,7 +1,7 @@
 project('MyGL', 'c', 'cpp',
         license: 'zlib',
         version: '0.1.0',
-        default_options: ['cpp_std=c++17'])
+        default_options: ['cpp_std=c++20'])
 
 subdir('include')
 

src/Cursor.cpp

@@ -31,9 +31,9 @@ namespace my
     bool Cursor::load(const Image& image, int xhot, int yhot) {
         if (image.isUsable()) {
             GLFWimage cursor;
-            cursor.width = image.getWidth();
-            cursor.height = image.getHeight();
-            cursor.pixels = const_cast<uint8_t*>(image.data());
+            cursor.width = static_cast<int>(image.getWidth());
+            cursor.height = static_cast<int>(image.getHeight());
+            cursor.pixels = image.data();
             p_cursor.reset(glfwCreateCursor(&cursor, xhot, cursor.height - 1 - yhot), CursorDeleter());
         } else {
             p_cursor.reset();
@@ -49,4 +49,4 @@ namespace my
         return p_cursor != nullptr;
     }
 
-} // namespace my
+} // namespace my

src/Drawable/AbstractShape.cpp

@@ -44,7 +44,6 @@ constexpr const char* texFragmentSource =
 
 namespace my
 {
-    const float AbstractShape::pi = 3.1415926535f;
     ShaderProgram AbstractShape::shader;
     ShaderProgram AbstractShape::texShader;
     const ShaderProgram& AbstractShape::defaultShader = AbstractShape::shader;
@@ -70,8 +69,9 @@ namespace my
     }
 
     AbstractShape::AbstractShape(int width, int height) :
-      m_position(0.0f, 0.0f), m_originalScale(width / 2.0f, height / 2.0f), m_scaleFactor(1.0f, 1.0f), m_rotationAngle(0.0f), m_updateMatrix(true),
-      m_model(1.0f), m_color(100, 100, 100), m_outlineThickness(0.0f), m_outlineColor(255, 255, 255), m_outlineModel(1.0f), m_isTextured(false) {
+      m_position(0.0f, 0.0f), m_originalScale(static_cast<float>(width) / 2.0f, static_cast<float>(height) / 2.0f), m_scaleFactor(1.0f, 1.0f),
+      m_rotationAngle(0.0f), m_updateMatrix(true), m_model(1.0f), m_color(100, 100, 100), m_outlineThickness(0.0f), m_outlineColor(255, 255, 255),
+      m_outlineModel(1.0f), m_isTextured(false) {
         initShaders();
         m_shader = shader;
         m_outlineShader = shader;
@@ -154,8 +154,8 @@ namespace my
         return m_rotationAngle;
     }
 
-    void AbstractShape::setColor(int r, int g, int b, int alpha) noexcept {
-        m_color = my::Color(glm::clamp(r, 0, 255), glm::clamp(g, 0, 255), glm::clamp(b, 0, 255), glm::clamp(alpha, 0, 255));
+    void AbstractShape::setColor(uint8_t r, uint8_t g, uint8_t b, uint8_t alpha) noexcept {
+        m_color = my::Color(r, g, b, alpha);
     }
 
     void AbstractShape::setColor(const my::Color& color) noexcept {
@@ -180,8 +180,8 @@ namespace my
         m_outlineColor = color;
     }
 
-    void AbstractShape::setOutlineColor(int r, int g, int b, int alpha) noexcept {
-        m_outlineColor = my::Color(glm::clamp(r, 0, 255), glm::clamp(g, 0, 255), glm::clamp(b, 0, 255), glm::clamp(alpha, 0, 255));
+    void AbstractShape::setOutlineColor(uint8_t r, uint8_t g, uint8_t b, uint8_t alpha) noexcept {
+        m_outlineColor = my::Color(r, g, b, alpha);
     }
 
     bool AbstractShape::SATCollides(const AbstractShape& shape) const {