graphic/C_surface.hpp

/*
 * Copyright 2025 Guillaume Guillet
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef _FGE_GRAPHIC_C_SURFACE_HPP_INCLUDED
#define _FGE_GRAPHIC_C_SURFACE_HPP_INCLUDED
 
#include "FastEngine/fge_extern.hpp"
#include "FastEngine/C_rect.hpp"
#include "FastEngine/C_vector.hpp"
#include "FastEngine/graphic/C_color.hpp"
#include "SDL_render.h"
#include <cstdint>
#include <filesystem>
#include <optional>
 
namespace fge
{
 
#ifdef FGE_DEF_SERVER
namespace vulkan
{
 
class Context;
 
} // namespace vulkan
#endif

class FGE_API Surface
{
public:
    Surface();
#ifdef FGE_DEF_SERVER
    //TODO: this is here in order to be interchangeable easily with TextureImage
    //when building for the server or client target.
    //For future, I want to remove that and have a TextureImage server version
    //instead of switching between Surface <-> TextureImage with the fge::TextureType alias
    explicit Surface([[maybe_unused]] fge::vulkan::Context const& r) :
            Surface()
    {}
#endif
    Surface(int width, int height, fge::Color const& color = {0, 0, 0, 255});
    Surface(Surface const& r);
    Surface(Surface&& r) noexcept;
    explicit Surface(SDL_Surface* newSurface);
    ~Surface();
 
    Surface& operator=(Surface const& r);
    Surface& operator=(Surface&& r) noexcept;

    void clear();
 
    bool create(int width, int height, fge::Color const& color = {0, 0, 0, 255});
    bool loadFromFile(std::filesystem::path const& filePath);
    bool loadFromMemory(void const* data, std::size_t size);

    bool saveToFile(std::filesystem::path const& filePath) const;
 
    [[nodiscard]] fge::Vector2i getSize() const;

    void createMaskFromColor(fge::Color const& color, uint8_t alpha = 0);
 
    bool setPixel(int x, int y, fge::Color const& color);
    [[nodiscard]] std::optional<fge::Color> getPixel(int x, int y) const;
 
    void setCircle(int x, int y, unsigned int radius, fge::Color const& color);
 
    void flipHorizontally();
    void flipVertically();
 
    void stretch(int width, int height);
    enum class ShearBaseSides
    {
        Top,
        Bottom
    };
    void shear(float angle, ShearBaseSides side);

    bool blitSurface(Surface const& src, std::optional<SDL_Rect> const& srcRect, std::optional<SDL_Rect>& dstRect);

    bool fillRect(std::optional<SDL_Rect> const& rect, fge::Color const& color);

    bool addBorder(int borderSize, fge::Color const& color);
 
    enum class AngleDirections
    {
        Clockwise,
        CounterClockwise
    };
 
    void addCircle(int x, int y, unsigned int radius, fge::Color const& color);
    void addUnfilledCircle(int x,
                           int y,
                           float startAngle,
                           float endAngle,
                           unsigned int radius,
                           AngleDirections direction,
                           fge::Color const& color);
    void addHollowCircle(int x, int y, unsigned int startRadius, unsigned int endRadius, fge::Color const& color);
    void addUnfilledHollowCircle(int x,
                                 int y,
                                 float startAngle,
                                 float endAngle,
                                 unsigned int startRadius,
                                 unsigned int endRadius,
                                 AngleDirections direction,
                                 fge::Color const& color);

    void set(SDL_Surface* surface);
    [[nodiscard]] SDL_Surface* get() const;

    [[nodiscard]] fge::Vector2f normalizeTextureCoords(fge::Vector2i const& coords) const;
    [[nodiscard]] fge::RectFloat normalizeTextureRect(fge::RectInt const& rect) const;
 
private:
    SDL_Surface* g_surface;
};
 
} // namespace fge
 
#endif //_FGE_GRAPHIC_C_SURFACE_HPP_INCLUDED