hdk-sdl/include/hdk/sdl/render/Renderer.hpp

#pragma once
/// @file Renderer.hpp
/// Header-only wrapper for SDL_Renderer struct & related functions.
/// For complete documentation, see src/render/Renderer.cpp
///
#include <SDL3/SDL.h>
#include <hdk/grid/SharedPtrWrapper.hpp>
#include <hdk/sdl/Properties.hpp>
#include <hdk/sdl/video/Surface.hpp>

namespace hdk::sdl {
  class Window;
  class Texture;
  class Renderer : public hdk::grid::SharedPtrWrapper<SDL_Renderer> {
    public:
      friend class Window;
      friend class Texture;
      friend std::pair<Window, Renderer> CreateWindowAndRenderer(
        const char* title, int width, int height, SDL_WindowFlags window_flags);
      using hdk::grid::SharedPtrWrapper<SDL_Renderer>::SharedPtrWrapper;
      /// @todo SDL_AddVulkanRenderSemaphores
      /// @todo SDL_ConvertEventToRenderCoordinates
      /// @todo SDL_CreateGPURenderer
      /// @todo SDL_CreateGPURenderState
      static Renderer Create(SDL_Window* window, const char* driverName) {
        return Renderer(get_or_cache(SDL_CreateRenderer(window, driverName), SDL_DestroyRenderer));
      }
      // SDL_CreateRendererWithProperties
      // https://wiki.libsdl.org/SDL3/SDL_CreateSoftwareRenderer
      static Renderer CreateSoftware(SDL_Surface* surface) {
        return Renderer(get_or_cache(SDL_CreateSoftwareRenderer(surface), SDL_DestroyRenderer));
      }
      /// @todo SDL_CreateWindowAndRenderer
      /// @todo SDL_DestroyGPURenderState
      /// @todo SDL_DestroyRenderer
      /// Implemented in `../render.hpp` to avoid circular dependency with Texture
      Texture CreateTexture(SDL_PixelFormat format, SDL_TextureAccess access, int w, int h) const;
      /// Implemented in `../render.hpp` to avoid circular dependency with Texture
      Texture CreateTextureFromSurface(SDL_Surface* surface) const;
      /// Implemented in `../render.hpp` to avoid circular dependency with Texture
      Texture CreateTextureWithProperties(SDL_PropertiesID properties) const;
      bool Flush() const { return SDL_FlushRenderer(*this); }
      /// @todo SDL_GDKResumeRenderer
      /// @todo SDL_GDKSuspendRenderer
      bool GetOutputSize(int* w, int* h) const { return SDL_GetRenderOutputSize(*this, w, h); }
      bool GetDefaultTextureScaleMode(SDL_ScaleMode* scaleMode) const {
        return SDL_GetDefaultTextureScaleMode(*this, scaleMode);
      }
      /// @todo SDL_GetGPURendererDevice
      static int GetNumRenderDrivers() { return SDL_GetNumRenderDrivers(); }

      bool GetClipRect(SDL_Rect* rect) const { return SDL_GetRenderClipRect(*this, rect); }
      bool GetColorScale(float* scale) const { return SDL_GetRenderColorScale(*this, scale); }
      bool GetDrawBlendMode(SDL_BlendMode* blendMode) const { return SDL_GetRenderDrawBlendMode(*this, blendMode); }
      /* @see https://wiki.libsdl.org/SDL3/SDL_GetRenderDrawColor
       * @brief Get the color used for drawing operations (Fill and Line).
       * @param r A pointer to a Uint8 to be filled in with the red component of the drawing color. If the renderer is
       * invalid, this will be set to 0.
       * @param g A pointer to a Uint8 to be filled in with the green component of the drawing color. If the renderer is
       * invalid, this will be set to 0.
       * @param b A pointer to a Uint8 to be filled in with the blue component of the drawing color. If the renderer is
       * invalid, this will be set to 0.
       * @param a A pointer to a Uint8 to be filled in with the alpha component of the drawing color. If the renderer is
       * invalid, this will be set to 0.
       * @return bool True if the drawing color was successfully retrieved, false otherwise.
       */
      bool GetDrawColor(Uint8* r, Uint8* g, Uint8* b, Uint8* a) const {
        return SDL_GetRenderDrawColor(*this, r, g, b, a);
      }
      /** @see https://wiki.libsdl.org/SDL3/SDL_GetRenderDrawColorFloat
       * @brief Get the color used for drawing operations (Fill and Line) as floats.
       * @param r A pointer to a float to be filled in with the red component of the drawing color. If the renderer is
       * invalid, this will be set to 0.0f.
       * @param g A pointer to a float to be filled in with the green component of the drawing color. If the renderer is
       * invalid, this will be set to 0.0f.
       * @param b A pointer to a float to be filled in with the blue component of the drawing color. If the renderer is
       * invalid, this will be set to 0.0f.
       * @param a A pointer to a float to be filled in with the alpha component of the drawing color. If the renderer is
       * invalid, this will be set to 0.0f.
       * @return bool True if the drawing color was successfully retrieved, false otherwise.
       */
      bool GetDrawColorFloat(float* r, float* g, float* b, float* a) const {
        return SDL_GetRenderDrawColorFloat(*this, r, g, b, a);
      }
      /** @see https://wiki.libsdl.org/SDL3/SDL_GetRenderDriver
       * @brief Get the name of a renderer driver specified by an index.
       * @param index The index of display driver to query, starting at 0.
       * @return const char* driver name string
       */
      static const char* GetDriver(int index) { return SDL_GetRenderDriver(index); }
      /** @see https://wiki.libsdl.org/SDL3/SDL_GetRenderer
       * @brief Get the renderer associated with a window.
       * @param window The window to query
       * @return Renderer The renderer associated with the window
       */
      static Renderer GetFromWindow(SDL_Window* window) {
        /** we may not have created the renderer we get back, if not we will not own it. */
        return Renderer(get_or_view(SDL_GetRenderer(window)));
      }
      /** @see https://wiki.libsdl.org/SDL3/SDL_GetRendererFromTexture
       * @brief Get the renderer associated with a texture.
       * @param texture The texture to query
       * @return Renderer The renderer associated with the texture
       */
      static Renderer GetFromTexture(SDL_Texture* texture) {
        /** we may not have created the renderer we get back, if not we will not own it. */
        return Renderer(get_or_view(SDL_GetRendererFromTexture(texture)));
      }
      /** @see https://wiki.libsdl.org/SDL3/SDL_GetRendererName
       * @brief Get the name of a renderer.
       * @return const char* The name of the renderer
       */
      const char* GetName() const { return SDL_GetRendererName(*this); }
      /** @see https://wiki.libsdl.org/SDL3/SDL_GetRendererProperties
       * @brief Get the properties of a renderer.
       * @returns Properties associated with the renderer.
       */
      Properties GetProperties() const { return Properties(SDL_GetRendererProperties(*this)); }
      /** @see https://wiki.libsdl.org/SDL_GetRenderLogicalPresentation
       * @brief device independent resolution and presentation mode
       * @param w pointer to store width
       * @param h pointer to store height
       * @param mode sdl enum value to store presentation mode
       * @return bool true on success
       */
      bool GetLogicalPresentation(int* w, int* h, SDL_RendererLogicalPresentation* mode) const {
        return SDL_GetRenderLogicalPresentation(*this, w, h, mode);
      }
      /** @see https://wiki.libsdl.org/SDL3/SDL_GetRenderLogicalPresentationRect
       * @brief Get the logical presentation rectangle of a renderer.
       * @param rect pointer to store the logical presentation rectangle
       * @return bool true on success
       */
      bool GetLogicalPresentationRect(SDL_FRect* rect) const {
        return SDL_GetRenderLogicalPresentationRect(*this, rect);
      }
      /**
       * @todo https://wiki.libsdl.org/SDL3/SDL_GetRenderMetalCommandEncoder
       * @todo https://wiki.libsdl.org/SDL3/SDL_GetRenderMetalLayer
       */
      bool GetSafeArea(SDL_Rect* rect) const { return SDL_GetRenderSafeArea(*this, rect); }
      /** @see https://wiki.libsdl.org/SDL3/SDL_GetRenderScale
       * @brief Get the scale of the current render target.
       * @param scaleX A pointer to a float to be filled in with the horizontal scale factor.
       * @param scaleY A pointer to a float to be filled in with the vertical scale factor.
       * @return bool True on success
       */
      bool GetScale(float* scaleX, float* scaleY) const { return SDL_GetRenderScale(*this, scaleX, scaleY); }
      /// Implemented in `../render.hpp` to avoid circular dependency with Texture
      Texture GetRenderTarget() const;
      bool GetTextureAddressMode(SDL_TextureAddressMode* u_mode, SDL_TextureAddressMode* v_mode) const {
        return SDL_GetRenderTextureAddressMode(*this, u_mode, v_mode);
      }
      bool GetViewport(SDL_Rect* rect) const { return SDL_GetRenderViewport(*this, rect); }
      bool GetVSync(int* vsync) const { return SDL_GetRenderVSync(*this, vsync); }
      /**
      @todo https://wiki.libsdl.org/SDL3/SDL_GetRenderWindow
      **/
      bool Clear() const { return SDL_RenderClear(*this); }
      bool ClipEnabled() const { return SDL_RenderClipEnabled(*this); }
      bool CoordinatesFromWindow(float windowX, float windowY, float* rendererX, float* rendererY) const {
        return SDL_RenderCoordinatesFromWindow(*this, windowX, windowY, rendererX, rendererY);
      }
      bool CoordinatesToWindow(float rendererX, float rendererY, float* windowX, float* windowY) const {
        return SDL_RenderCoordinatesToWindow(*this, rendererX, rendererY, windowX, windowY);
      }
      bool DebugText(float x, float y, const char* text) const { return SDL_RenderDebugText(*this, x, y, text); }
      template <typename... Args> bool DebugTextFormat(float x, float y, const char* fmt, Args... args) const {
        return SDL_RenderDebugTextFormat(*this, x, y, fmt, args...);
      }
      bool FillRect(const SDL_FRect* rect) const { return SDL_RenderFillRect(*this, rect); }
      bool FillRects(const SDL_FRect* rects, int count) const { return SDL_RenderFillRects(*this, rects, count); }
      bool RenderGeometry(
        SDL_Texture* texture, const SDL_Vertex* vertices, int numVertices, const int* indices, int numIndices) const {
        return SDL_RenderGeometry(*this, texture, vertices, numVertices, indices, numIndices);
      }
      bool RenderGeometryRaw(SDL_Texture* texture, const float* xy, int xy_stride, const SDL_FColor* color,
        int color_stride, const float* uv, int uv_stride, int numVertices, const void* indices, int numIndices,
        int sizeIndices) const {
        return SDL_RenderGeometryRaw(*this, texture, xy, xy_stride, color, color_stride, uv, uv_stride, numVertices,
          indices, numIndices, sizeIndices);
      }
      bool RenderLine(float x1, float y1, float x2, float y2) const { return SDL_RenderLine(*this, x1, y1, x2, y2); }
      bool RenderLines(const SDL_FPoint* points, int count) const { return SDL_RenderLines(*this, points, count); }
      bool RenderPoint(float x, float y) const { return SDL_RenderPoint(*this, x, y); }
      bool RenderPoints(const SDL_FPoint* points, int count) const { return SDL_RenderPoints(*this, points, count); }
      bool Present() const { return SDL_RenderPresent(*this); }
      Surface ReadPixels(const SDL_Rect* rect) const {
        return Surface(Surface::get_or_cache(SDL_RenderReadPixels(*this, rect), SDL_DestroySurface));
      }

      bool RenderRect(const SDL_FRect* rect) const { return SDL_RenderRect(*this, rect); }
      bool RenderRect(const SDL_FRect&& rect) const { return SDL_RenderRect(*this, &rect); }
      
      bool RenderRects(const SDL_FRect* rects, int count) const { return SDL_RenderRects(*this, rects, count); }
      bool RenderTexture(SDL_Texture* texture, const SDL_FRect* src, const SDL_FRect* dst) const {
        return SDL_RenderTexture(*this, texture, src, dst);
      }
      bool RenderTexture9Grid(SDL_Texture* texture, const SDL_FRect* src, float left_width, float right_width,
        float top_height, float bottom_height, float scale, const SDL_FRect* dst) const {
        return SDL_RenderTexture9Grid(
          *this, texture, src, left_width, right_width, top_height, bottom_height, scale, dst);
      }
      bool RenderTexture9GridTiled(SDL_Texture* texture, const SDL_FRect* src, float left_width, float right_width,
        float top_height, float bottom_height, float scale, const SDL_FRect* dst, float tile_scale) const {
        return SDL_RenderTexture9GridTiled(
          *this, texture, src, left_width, right_width, top_height, bottom_height, scale, dst, tile_scale);
      }
      bool RenderTextureAffine(SDL_Texture* texture, const SDL_FRect* src, const SDL_FPoint* origin,
        const SDL_FPoint* right, const SDL_FPoint* down) const {
        return SDL_RenderTextureAffine(*this, texture, src, origin, right, down);
      }
      bool RenderTextureRotated(SDL_Texture* texture, const SDL_FRect* srcrect, const SDL_FRect* dstrect, double angle,
        const SDL_FPoint* center, SDL_FlipMode flip) const {
        return SDL_RenderTextureRotated(*this, texture, srcrect, dstrect, angle, center, flip);
      }
      bool RenderTextureTiled(
        SDL_Texture* texture, const SDL_FRect* srcrect, float scale, const SDL_FRect* dstrect, float tile_scale) const {
        return SDL_RenderTextureTiled(*this, texture, srcrect, scale, dstrect);
      }
      bool SetDefaultTextureScaleMode(SDL_ScaleMode scaleMode) const {
        return SDL_SetDefaultTextureScaleMode(*this, scaleMode);
      }
      /** @todo SDL_SetGPURenderState
      // https://wiki.libsdl.org/SDL3/SDL_SetGPURenderStateFragmentUniforms
      // https://wiki.libsdl.org/SDL3/SDL_SetGPURenderStateSamplerBindings
      // https://wiki.libsdl.org/SDL3/SDL_SetGPURenderStateStorageBuffers
      // https://wiki.libsdl.org/SDL3/SDL_SetGPURenderStateStorageTextures
      **/
      bool SetClipRect(const SDL_Rect* rect) const { return SDL_SetRenderClipRect(*this, rect); }
      bool SetRenderColorScale(float scale) const { return SDL_SetRenderColorScale(*this, scale); }
      bool SetDrawBlendMode(SDL_BlendMode blendMode) const { return SDL_SetRenderDrawBlendMode(*this, blendMode); }
      bool SetDrawColor(Uint8 r, Uint8 g, Uint8 b, Uint8 a) const { return SDL_SetRenderDrawColor(*this, r, g, b, a); }
      bool SetDrawColorFloat(float r, float g, float b, float a) const {
        return SDL_SetRenderDrawColorFloat(*this, r, g, b, a);
      }
      bool SetLogicalPresentation(int w, int h, SDL_RendererLogicalPresentation mode) const {
        return SDL_SetRenderLogicalPresentation(*this, w, h, mode);
      }
      bool SetScale(float scaleX, float scaleY) const { return SDL_SetRenderScale(*this, scaleX, scaleY); }
      bool SetRenderTarget(SDL_Texture* texture) const { return SDL_SetRenderTarget(*this, texture); }
      bool SetTextureAddressMode(SDL_TextureAddressMode u_mode, SDL_TextureAddressMode v_mode) const {
        return SDL_SetRenderTextureAddressMode(*this, u_mode, v_mode);
      }
      bool ViewportSet() const { return SDL_RenderViewportSet(*this); }
      bool SetViewport(const SDL_Rect* rect) const { return SDL_SetRenderViewport(*this, rect); }
      bool SetViewport(const SDL_Rect&& rect) const { return SDL_SetRenderViewport(*this, &rect); }
      bool SetVSync(int vsync) const { return SDL_SetRenderVSync(*this, vsync); }
      /// Implemented in ../video.hpp to avoid circular dependency
      Window GetWindow() const;
  };
}