OpenGL6.完成MyTransform.hpp中如下函数： myFrustum，myOrtho，myLookAt，myViewPort，myPerspective

以下是 MyTransform.hpp 中 myFrustum、myOrtho、myLookAt、myViewPort 和 myPerspective 函数的实现：

// 定义一个名为 MyTransform 的命名空间
namespace MyTransform {
    // 定义一个矩阵乘法的函数
    void multiplyMatrix(float* m1, float* m2, float* result) {
        float temp[16];

        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                temp[i * 4 + j] = 0;

                for (int k = 0; k < 4; k++) {
                    temp[i * 4 + j] += m1[i * 4 + k] * m2[k * 4 + j];
                }
            }
        }

        memcpy(result, temp, 16 * sizeof(float));
    }

    // 定义一个用于计算透视投影的函数
    void myFrustum(float left, float right, float bottom, float top, float nearPlane, float farPlane, float* result) {
        float temp[16] = {
            2 * nearPlane / (right - left), 0, (right + left) / (right - left), 0,
            0, 2 * nearPlane / (top - bottom), (top + bottom) / (top - bottom), 0,
            0, 0, -(farPlane + nearPlane) / (farPlane - nearPlane), -2 * farPlane * nearPlane / (farPlane - nearPlane),
            0, 0, -1, 0
        };

        memcpy(result, temp, 16 * sizeof(float));
    }

    // 定义一个用于计算正交投影的函数
    void myOrtho(float left, float right, float bottom, float top, float nearPlane, float farPlane, float* result) {
        float temp[16] = {
            2 / (right - left), 0, 0, -(right + left) / (right - left),
            0, 2 / (top - bottom), 0, -(top + bottom) / (top - bottom),
            0, 0, -2 / (farPlane - nearPlane), -(farPlane + nearPlane) / (farPlane - nearPlane),
            0, 0, 0, 1
        };

        memcpy(result, temp, 16 * sizeof(float));
    }

    // 定义一个用于计算观察矩阵的函数
    void myLookAt(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ, float* result) {
        float forward[3] = {centerX - eyeX, centerY - eyeY, centerZ - eyeZ};
        float up[3] = {upX, upY, upZ};
        float side[3];
        float view[16];

        // 将 forward 向量进行规范化
        float length = sqrt(forward[0] * forward[0] + forward[1] * forward[1] + forward[2] * forward[2]);
        forward[0] /= length;
        forward[1] /= length;
        forward[2] /= length;

        // 将 up 向量进行规范化
        length = sqrt(up[0] * up[0] + up[1] * up[1] + up[2] * up[2]);
        up[0] /= length;
        up[1] /= length;
        up[2] /= length;

        // 计算 side 向量
        side[0] = forward[1] * up[2] - forward[2] * up[1];
        side[1] = forward[2] * up[0] - forward[0] * up[2];
        side[2] = forward[0] * up[1] - forward[1] * up[0];

        // 将 side 向量进行规范化
        length = sqrt(side[0] * side[0] + side[1] * side[1] + side[2] * side[2]);
        side[0] /= length;
        side[1] /= length;
        side[2] /= length;

        // 重新计算 up 向量
        up[0] = side[1] * forward[2] - side[2] * forward[1];
        up[1] = side[2] * forward[0] - side[0] * forward[2];
        up[2] = side[0] * forward[1] - side[1] * forward[0];

        // 构造观察矩阵
        view[0] = side[0];
        view[4] = side[1];
        view[8] = side[2];
        view[12] = -side[0] * eyeX - side[1] * eyeY - side[2] * eyeZ;

        view[1] = up[0];
        view[5] = up[1];
        view[9] = up[2];
        view[13] = -up[0] * eyeX - up[1] * eyeY - up[2] * eyeZ;

        view[2] = -forward[0];
        view[6] = -forward[1];
        view[10] = -forward[2];
        view[14] = forward[0] * eyeX + forward[1] * eyeY + forward[2] * eyeZ;

        view[3] = view[7] = view[11] = 0;
        view[15] = 1;

        memcpy(result, view, 16 * sizeof(float));
    }

    // 定义一个用于计算视口变换的函数
    void myViewPort(int x, int y, int width, int height, float* result) {
        float temp[16] = {
            width / 2.0, 0, 0, x + width / 2.0,
            0, height / 2.0, 0, y + height / 2.0,
            0, 0, 0.5, 0.5,
            0, 0, 0, 1
        };

        memcpy(result, temp, 16 * sizeof(float));
    }

    // 定义一个用于计算透视投影的函数
    void myPerspective(float fov, float aspectRatio, float nearPlane, float farPlane, float* result) {
        float top = nearPlane * tan(fov / 2.0);
        float bottom = -top;
        float right = top * aspectRatio;
        float left = -right;

        float frustum[16];
        myFrustum(left, right, bottom, top, nearPlane, farPlane, frustum);
        memcpy(result, frustum, 16 * sizeof(float));
    }
}

这些函数都是通过对矩阵进行一系列变换来实现的，最终得到需要的投影矩阵或者观察矩阵。可以通过调用这些函数来得到需要的矩阵，然后将其传递给 OpenGL 来进行渲染。