backend/ogl_sys/NTransform.cpp - devOpt - ArtemNech/simpleOpenGL

backend/ogl_sys/NTransform.cpp
128 строк3 KB
Artem Nechitaylenko
initial
16 май 2026, 12:48
16 май 2026, 12:480d3ac6c
//
// Created by artem on 20.10.25.
//

#include "NTransform.h"
#include <cmath>
#include <algorithm>

namespace ngraph
{


    NTransform::NTransform()
    = default;

    NTransform NTransform::scale(double sx, double sy)
    {
        NTransform t;
        t.m11 = sx; t.m22 = sy;
        return t;
    }

    NTransform NTransform::translate(double dx, double dy)
    {
        NTransform t;
        t.m13 = dx; t.m23 = dy;
        return t;
    }

    NTransform NTransform::translate(const NPointF &offset)
    {
        return translate(offset.x(), offset.y());
    }

    NPointF NTransform::map(const NPointF &point) const
    {
        return {point.x() * m11 + point.y() * m12 + m13,
                point.x() * m21 + point.y() * m22 + m23};
    }

    NRectF NTransform::map(const NRectF &rect) const
    {
        /*NPointF tl = map(rect.left_top());
        NPointF br = map(rect.bottom_right());
        return NRectF(tl, br);*/
        NPointF tl = map(rect.left_top());
        NPointF tr = map(NPointF(rect.right(), rect.top()));
        NPointF bl = map(NPointF(rect.left(), rect.bottom()));
        NPointF br = map(rect.bottom_right());

        // Находим bounding box трансформированного прямоугольника
        double left = std::min({tl.x(), tr.x(), bl.x(), br.x()});
        double right = std::max({tl.x(), tr.x(), bl.x(), br.x()});
        double top = std::min({tl.y(), tr.y(), bl.y(), br.y()});
        double bottom = std::max({tl.y(), tr.y(), bl.y(), br.y()});

        return {NPointF(left, top), NPointF(right, bottom)};
    }

    NLineF NTransform::map(const NLineF &line) const
    {
        return {map(line.p1()), map(line.p2())};
    }

    NTransform NTransform::combined(const NTransform &other) const
    {
        NTransform result;

        // Умножение матриц 3x3 (аффинные преобразования)
        result.m11 = m11 * other.m11 + m12 * other.m21;
        result.m12 = m11 * other.m12 + m12 * other.m22;
        result.m13 = m11 * other.m13 + m12 * other.m23 + m13;

        result.m21 = m21 * other.m11 + m22 * other.m21;
        result.m22 = m21 * other.m12 + m22 * other.m22;
        result.m23 = m21 * other.m13 + m22 * other.m23 + m23;

        return result;
    }

    double NTransform::scaleX() const
    {
        return m11;
    }

    double NTransform::scaleY() const
    {
        return m22;
    }

    double NTransform::uniformScale() const
    {
        return sqrt(m11*m11 + m22*m22) / sqrt(2);
    }

    NTransform NTransform::inverted() const
    {
        NTransform inv;

        // Для аффинных преобразований с последней строкой [0 0 1]
        double det = m11 * m22 - m12 * m21;
        if (std::abs(det) < 1e-10) return {}; // Защита от вырождения

        double invDet = 1.0 / det;

        inv.m11 = m22 * invDet;
        inv.m12 = -m12 * invDet;
        inv.m13 = (m12 * m23 - m22 * m13) * invDet;

        inv.m21 = -m21 * invDet;
        inv.m22 = m11 * invDet;
        inv.m23 = (m21 * m13 - m11 * m23) * invDet;

        // m31, m32, m33 остаются [0, 0, 1]

        return inv;
    }

    glm::mat4 NTransform::toGlmMatrix() const
    {
        glm::mat4 mat(1.0f);
        mat[0][0] = (float)m11;  // scale X
        mat[1][1] = (float)m22;  // scale Y
        mat[3][0] = (float)m13;  // translate X
        mat[3][1] = (float)m23;  // translate Y
        return mat;
    }
}