dl_type_create.h

浏览该文件的文档.

#pragma once
 
#include <cmath>
#include <string>
#include <optional>
 
#include "dl_type_def.h"
#include "dl_type_convert.h"
#include "dl_type_op.h"
#include "base/dl_concept.h"
 
namespace dl
{
 
//------------------------Quad----------------------
struct QuadParam
{
    Size _size;            // 原始大小
    Position _anchor;    // 锚点位置
    float _scaleX = 1.0f;// X缩放比例
    float _scaleY = 1.0f;// Y缩放比例
    float _rotate = 0.0f;// 旋转角度
    bool _filpX = false;// 是否在X轴翻转
    bool _filpY = false;// 是否在Y轴翻转
    // 以下覆盖上面的值
    std::string _exAnchor;// 不为空则计算锚点
    std::optional<float> _exScale;
};

inline constexpr Quad createQuad(const Position& p0, const Position& p1, const Position& p2, const Position& p3)
{
    return { p0, p1, p2, p3 };
}

inline constexpr Quad createQuad(const Position& lt, const Position& rb)
{
    return { lt, {rb[0], lt[1]}, rb, {lt[0], rb[1]} };
}
 
inline constexpr Quad createQuad(const Rect& rect)
{
    return createQuad(toPosition(rect[0], rect[1]), toPosition(rect[2], rect[3]));
}
 
inline constexpr Quad createQuad(const RectF& rect)
{
    return createQuad({ rect[0], rect[1] }, { rect[2], rect[3] });
}

inline Quad createQuad(const Position& p0, const Position& p1, Float d)
{
    Float at = atan2f(p1[1] - p0[1], p1[0] - p0[0]);
 
    Float dy = d * cosf(at) / 2_f;
    Float dx = d * sinf(at) / 2_f;
    return{
        p0 + Position{dx, -dy},
        p1 + Position{dx, -dy},
        p1 + Position{-dx, dy},
        p0 + Position{-dx, dy} };
}

template<IsBase T>
constexpr Quad createQuad(T size, bool center = true)
{
    if (center)
    {
        Float size_half = (Float)size / 2_f;
        return { Position{-size_half, -size_half}, Position{ size_half, -size_half },
            Position{size_half, size_half}, Position{-size_half, size_half} };
    }
    else
    {
        return { Position{}, Position{(Float)size, 0},
            Position{(Float)size, (Float)size}, Position{0, (Float)size} };
    }
}
 

inline constexpr Quad createQuad(Position size, bool center = true)
{
    if (center)
    {
        Float w_half = size[0] / 2.0f;
        Float h_half = size[1] / 2.0f;
        return { Position{-w_half, -h_half}, Position{ w_half, -h_half }, Position{w_half, h_half}, Position{-w_half, h_half} };
    }
    else
    {
        return { Position{}, Position{size[0], 0}, Position{size[0], size[1]}, Position{0, size[1]} };
    }
}

constexpr Quad createQuad(Size size, bool center = true)
{
    return createQuad(toPosition(size), center);
}

Quad createQuad(const QuadParam& param);
 
//------------------------Rect----------------------
constexpr Rect createRect(const Size& size)
{
    return { 0, 0, (int)size[0], (int)size[1] };
}
constexpr Rect createRect(const Position& size)
{
    return { 0, 0, (int)size[0], (int)size[1] };
}

constexpr Rect createRect(const Point& lt, const Size& size)
{
    return { lt[0], lt[1], lt[0] + (int)size[0], lt[1] + (int)size[1] };
}

constexpr Rect createRect(const Point& lt, const Point& rb)
{
    return { lt[0], lt[1], rb[0], rb[1] };
}
 
//------------------------RectU----------------------
constexpr RectU createRectU(const Size& size)
{
    return { 0, 0, size[0], size[1] };
}

constexpr RectU createRectU(unsigned size)
{
    return { 0, 0, size, size };
}

constexpr RectU createRectU(const PointU& lt, const Size& size)
{
    return { lt[0], lt[1], lt[0] + size[0], lt[1] + size[1] };
}
 
//------------------------RectF----------------------
constexpr RectF createRectF(const Position& size)
{
    return { 0, 0, size[0], size[1] };
}

constexpr RectF createRectF(const Position& lt, const Position& size)
{
    return { lt[0], lt[1], lt[0] + size[0], lt[1] + size[1] };
}

constexpr RectF createRectLTRB(const Position& lt, const Position& rb)
{
    return { lt[0], lt[1], rb[0], rb[1] };
}
 
}