C_matrix.hpp

/*
 * Copyright 2024 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_C_MATRIX_HPP_INCLUDED
#define _FGE_C_MATRIX_HPP_INCLUDED
 
#include "FastEngine/C_vector.hpp"
#include "FastEngine/fge_except.hpp"
#include "json.hpp"
#include <initializer_list>
 
#define FGE_MATRIX_GET(dataType_, data_, sizeY_, px_, py_)                                                             \
    (reinterpret_cast<dataType_*>(data_) + (py_) + ((px_) * (sizeY_)))
 
namespace fge
{
 
template<class T>
class Matrix
{
public:
    using iterator = T*;
    using const_iterator = T const*;
 
    Matrix();
 
    Matrix(std::initializer_list<std::initializer_list<T>> data);
 
    template<class Tvec>
    explicit Matrix(fge::Vector2<Tvec> const& msize);
    Matrix(std::size_t sizex, std::size_t sizey);
 
    template<class Tvec>
    Matrix(fge::Vector2<Tvec> const& msize, T const& defaultValue);
    Matrix(std::size_t sizex, std::size_t sizey, T const& defaultValue);
 
    Matrix(fge::Matrix<T> const& m);
    Matrix(fge::Matrix<T>&& m) noexcept;
 
    ~Matrix() = default;
 
    void clear();
 
    fge::Matrix<T>& operator=(fge::Matrix<T> const& m);
    fge::Matrix<T>& operator=(fge::Matrix<T>&& m) noexcept;
 
    inline T* operator[](std::size_t x);
    inline T const* operator[](std::size_t x) const;
 
    inline T const& get(std::size_t x, std::size_t y) const;
    template<class Tvec>
    inline T const& get(fge::Vector2<Tvec> const& coord) const;
    inline T& get(std::size_t x, std::size_t y);
    template<class Tvec>
    inline T& get(fge::Vector2<Tvec> const& coord);
 
    bool get(std::size_t x, std::size_t y, T& buff) const;
    template<class Tvec>
    bool get(fge::Vector2<Tvec> const& coord, T& buff) const;
 
    T* getPtr(std::size_t x, std::size_t y);
    template<class Tvec>
    T* getPtr(fge::Vector2<Tvec> const& coord);
    T const* getPtr(std::size_t x, std::size_t y) const;
    template<class Tvec>
    T const* getPtr(fge::Vector2<Tvec> const& coord) const;
 
    void set(std::size_t x, std::size_t y, T&& value);
    template<class Tvec>
    void set(fge::Vector2<Tvec> const& coord, T&& value);
    void set(std::size_t x, std::size_t y, T const& value);
    template<class Tvec>
    void set(fge::Vector2<Tvec> const& coord, T const& value);
 
    void set(std::initializer_list<std::initializer_list<T>> data);
 
    [[nodiscard]] inline std::size_t getTotalSize() const;
    [[nodiscard]] inline fge::Vector2<std::size_t> const& getSize() const;
    [[nodiscard]] inline std::size_t getSizeX() const;
    [[nodiscard]] inline std::size_t getSizeY() const;
 
    [[nodiscard]] inline T const* get() const;
    [[nodiscard]] inline T* get();
 
    [[nodiscard]] fge::Matrix<T>::iterator begin();
    [[nodiscard]] fge::Matrix<T>::iterator end();
    [[nodiscard]] fge::Matrix<T>::const_iterator begin() const;
    [[nodiscard]] fge::Matrix<T>::const_iterator end() const;
 
    template<class Tvec>
    void setSize(fge::Vector2<Tvec> const& msize);
    void setSize(std::size_t sizex, std::size_t sizey);
 
    void fill(T const& value);
 
    void rotateClockwise();
    void rotateCounterClockwise();
    void rotateClockwise(unsigned int n);
    void rotateCounterClockwise(unsigned int n);
    void flipHorizontally();
    void flipVertically();
 
    void toVector(std::vector<T>& buff) const;
 
private:
    std::unique_ptr<T[]> g_mdata;
    fge::Vector2<std::size_t> g_msize;
};
 
template<class T>
void to_json(nlohmann::json& j, fge::Matrix<T> const& r);
template<class T>
void from_json(nlohmann::json const& j, fge::Matrix<T>& r);
 
} // namespace fge
 
#include <FastEngine/C_matrix.inl>
 
#endif // _FGE_C_MATRIX_HPP_INCLUDED