Как правильно сделать математику с матрицами для преобразований opengl?

Question

Я действительно запутался, как работают матрицы и как их использовать возможно.В качестве теста я пытаюсь заставить прямоугольник вращаться против часовой стрелки, когда он движется к углу, также прямоугольник вдвое меньше.В принципе, все не работает, ожидайте ротации.

Если вам интересно, я не использую GLM и не хочу использовать GLM.Я чувствую, что мне нужно попробовать себя, но теперь я серьезно застрял.Я пытался изменить порядок выполнения преобразований, но получаю случайные результаты.

Вот код в main.cpp, это пользовательский игровой движок, поэтому здесь есть только соответствующая часть

Matrix4 transform = Matrix4(); // the matrix
float d = 5, g = 1;
void OnUserUpdate() override { // Called once every frame
    transform.Translate(Vector3(d * DeltaTime, d * DeltaTime, 0.0f));
    transform.Rotate(Vector3(0.0f, 0.0f, 1.0f), ToRadians(g));
    transform.Scale(Vector3(0.5f, 0.5f, 0.5f));

    g+=0.01;

    Shaders.SetMat4(shader, "transform", transform);
}

Вот полный класс матрицы.Vector3 просто с плавающей точкой x, y, z.Есть только конструктор.

template <typename Number> float ToRadians(Number deg) {
return deg * PI / 180;
}

struct Matrix4 {
private:
Matrix4& identity() {
    m[0] = m[5] = m[10] = m[15] = 1.0f;
    m[1] = m[2] = m[3] = m[4] = m[6] = m[7] = m[8] = m[9] = m[11] = m[12] = m[13] = m[14] = 0.0f;
    return* this;
}
public:
float m[16];
Matrix4() {
    identity();
}

Matrix4(const float src[16]) {
    Set(src);
}

void Set(const float src[16]) {
    for (int i = 0; i < 16; i++) {
        m[i] = src[i];
    }
}

void Projection(float fov, float aspectratio, float nearpane, float farpane) {

}

void Translate(Vector3 v) {
    float x = v.x; float y = v.y; float z = v.y;
    m[0] += m[3] * x;   m[4] += m[7] * x;   m[8] += m[11] * x;   m[12] += m[15] * x;
    m[1] += m[3] * y;   m[5] += m[7] * y;   m[9] += m[11] * y;   m[13] += m[15] * y;
    m[2] += m[3] * z;   m[6] += m[7] * z;   m[10] += m[11] * z;   m[14] += m[15] * z;
}

void Rotate(Vector3 axis, float deg) {
    m[0] = cosf(deg)+axis.x*axis.x*(1-cosf(deg));
    m[1] = axis.y*axis.x*(1 - cosf(deg)) + axis.z*sinf(deg);
    m[2] = axis.z*axis.x*(1 - cosf(deg)) - axis.y*sinf(deg);
    m[4] = axis.x*axis.y*(1 - cosf(deg)) - axis.z*sinf(deg);
    m[5] = cosf(deg)+axis.y*axis.y*(1-cosf(deg));
    m[6] = axis.z*axis.y*(1 - cosf(deg)) + axis.x*sinf(deg);
    m[8] = axis.x*axis.z*(1 - cosf(deg)) + axis.y*sinf(deg);
    m[9] = axis.y*axis.z*(1 - cosf(deg)) - axis.x*sinf(deg);
    m[10] = cosf(deg) + axis.z*axis.z*(1 - cosf(deg));;
    m[15] = 1;
}

void Scale(Vector3 v) {
    float x = v.x; float y = v.y; float z = v.y;
    m[0] *= x;   m[4] *= x;   m[8] *= x;   m[12] *= x;
    m[1] *= y;   m[5] *= y;   m[9] *= y;   m[13] *= y;
    m[2] *= z;   m[6] *= z;   m[10] *= z;   m[14] *= z;
}
};

Как я уже сказал, я пытаюсь заставить прямоугольник вращаться против часовой стрелки, когда он движется к углу, и прямоугольник в два раза меньше.Я использовал несколько источников, но, честно говоря, я не до конца все понял

http://www.songho.ca/opengl/gl_matrix.html

https://learnopengl.com/Getting-started/Transformations

Answer 1

Упростите вещи.

Создайте 3 метода, которые инициализируют масштаб, сдвиг и матрицу вращения:

struct Matrix4 {

    // ...

    void SetScale( Vector3 v ) {
        identity();
        m[0] = v.x; m[5] = v.y; m[10] = v.z;
    }

    void SetTranslate( Vector3 v ) {
        identity();
        m[12] = v.x; m[13] = v.y; m[14] = v.z;
    }

    void SetRotate( Vector3 v, float rad ) {
        identity();

        float c = cosf(rad);
        float s = sinf(rad);
        float x = v.x, y = v.x, z = v.z;

        m[0] = x*x*(1.0f-c)+c;   m[1] = x*y*(1.0f-c)-z*s; m[2]  = x*z*(1.0f-c)+y*s;
        m[4] = y*x*(1.0f-c)+z*s; m[5] = y*y*(1.0f-c)+c;   m[6]  = y*z*(1.0f-c)-x*s;
        m[8] = z*x*(1.0f-c)-y*s; m[9] = z*y*(1.0f-c)+x*s; m[10] = z*z*(1.0f-c)+c;
    }

    // ...

}

Далее создайте метод, который умножает матрицу на текущую матрицу:

struct Matrix4 {

    // ... 

    void Multiply( const Matrix4 &b ) {
        Matrix4 a;
        a.Set( m );
        for ( int k = 0; k < 4; ++ k ) {
            for ( int j = 0; j < 4; ++ j ) {
                m[k*4+j] =
                    a.m[0*4+j] * b.m[k*4+0] +
                    a.m[1*4+j] * b.m[k*4+1] +
                    a.m[2*4+j] * b.m[k*4+2] +
                    a.m[3*4+j] * b.m[k*4+3];
            }
        }
    }

    // ...

}

Основываясь на этих методах, методы, которые масштабируют, переводят и поворачивают существующую матрицу, могут быть легко реализованы:

struct Matrix4 {

    // ... 

    void Scale(Vector3 v) {

        Matrix4 s;
        s.SetScale( v );
        Multiply( s );
    }

    void Translate(Vector3 v) {

        Matrix4 t;
        t.SetTranslate( v );
        Multiply( t );
    }

    void Rotate(Vector3 axis, float rad) {

        Matrix4 r;
        r.SetRotate( axis, rad );
        Multiply( r );
    }

    // ...

}

Выполните этот запуск.После этого вы можете попробовать оптимизировать методы, но у вас будет рабочая база для сравнения результатов.

---

Обратите внимание, что в transform.Rotate(Vector3(0.0f, 0.0f, 1.0f), ToRadians(g)); угол преобразуется из градусов в лучистую.g+=0.01 - очень маленький шаг вперед (в градусах).Вероятно, вы должны изменить это значение на g+=1.0, чтобы получить заметное изменение в каждом кадре.

---

Наконец, вы должны инициализировать матрицу модема (transform), используя единичную матрицу, перед тем каквы делаете преобразования.В противном случае новые преобразования будут выполнены поверх преобразований предыдущих кадров.Это приведет к быстрому уменьшению сетки и переводу некуда:

float g = 0, t = 0;

void OnUserUpdate() override {

    transform = Matrix4();
    transform.Translate(Vector3(t, t, 0.0f));
    transform.Rotate(Vector3(0.0f, 0.0f, 1.0f), ToRadians(g));
    transform.Scale(Vector3(0.5f, 0.5f, 0.5f));

    t += 0.1 * DeltaTime;
    g += 5;

    Shaders.SetMat4(shader, "transform", transform);
}