Форум программистов, компьютерный форум CyberForum.ru

Объединение view и projection матриц - C++

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ Немного философии ООП http://www.cyberforum.ru/cpp/thread1808784.html
На днях на работе возник холивар с коллегами, к правильному решению пришли только на следующий день, почитав Мейерса и Саттера (один из участников холивара уже знал о правильном решении, но сторонников неправильного было большинство). Рекомендаций от упомянутых гуру пока не говорю, предлагаю поразмышлять) Итак - есть проект, в проекте используется ООП, скатываться до С считается мовитоном и...
C++ OpenCV захват видео с веб-камеры Начал изучать OpenCV. В просторах интернета нашел данный код: #include <cv.h> #include <highgui.h> #include <stdlib.h> #include <stdio.h> int main(int argc, char* argv) { // получаем любую подключённую камеру CvCapture* capture = cvCreateCameraCapture(CV_CAP_ANY); //cvCaptureFromCAM( 0 ); http://www.cyberforum.ru/cpp/thread1808506.html
Как компилятор обрабатывает член класса static constexpr const char* C++
Привет! Наткнулся на непонятный момент class Foo { public: static constexpr const char* PTR = "value"; }; без constexpr не компилируется. Вопрос - как компилятора без линкера разруливает это дело, ведь constexpr value ему нужен на этапе компиляции? Если он это пережевывает, почему тогда constexpr необходим?
C++ Распознование животных на изображении
Стала интересна тема распознавания образов на изображениях. Программа должна получать картинку с животным и определить какое это животное(как я понимаю, задача не простая, но все же) . Подскажите в какую сторону копать, какие есть статьи/книги/сайты посвященные этой теме. Слышал про OpenCV, но я уверен, что есть еще что-то похожее.
C++ Как подружить компьютер c МК через USB http://www.cyberforum.ru/cpp/thread1807335.html
Здравствуйте, уважаемые форумчане! Никогда не работал с USB нужна помощь. Есть компьютер под управлением Windows 7, плата разработки DE0-Nano-SoC. Необходимо написать программу для ОС, которая могла бы определять плату как USB устройство. В DE0-Nano-SoC есть два USb-интерфейса UART to USB (COM-порт) и USB OTG (FT232R). Думаю подключать через USB OTG. Пишу как в Microsoft Visual Stidio...
C++ Различия между Java и Си++ Я раньше программировал на си++,сейчас начал на java,нужно понять основные различия 1. Каковы отличия в структуре программы вычисления простого арифметического выражения на языке Си и Си++ от структуры программы на языке Java. 2. Если пакет содержит только один класс, нужно ли указывать класс, в котором находится функция main? 3. Могут ли в одном пакете определено несколько функций main и,... подробнее

Показать сообщение отдельно
Pro100Tom
69 / 28 / 7
Регистрация: 29.10.2012
Сообщений: 326
19.09.2016, 20:38  [ТС]     Объединение view и projection матриц
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
Points Renderer::ConvertToNDC(Vertex(&vertices)[3])
{
    Points points;
    
    for (int i = 0; i < 3; i++)
    {
        Vertex vertex = vertices[i] / vertices[i].w;
 
        Point point;
 
        point.x = (int)(vertex.x * horizontalScale + halfWidth);
        point.y = (int)(-vertex.y * verticalScale + halfHeight);
 
        points.push_back(point);
    }
 
    return points;
}
 
void Renderer::Render()
{
    Matrix4x4 viewMatrix = currentCamera.GetViewMatrix();
    Matrix4x4 projectonMatrix = currentCamera.GetProjectionMatrix();
 
    for (unsigned int j = 0; j < models.size(); j++)
    {
        Vertices tempVertices = viewMatrix * models[j].GetTransformedVertices();
        Vertices finalVertices = projectonMatrix * tempVertices;
 
        for (unsigned int i = 0; i < models[j].vertexFaces.size(); i++)
        {
            Face face = models[j].vertexFaces[i];
            Vertex polygonVertices[] =
            {
                finalVertices[face.a - 1],
                finalVertices[face.b - 1],
                finalVertices[face.c - 1]
            };
 
            Points points = ConvertToNDC(polygonVertices);
            DrawTriangle(points[0], points[1], points[2]);
        }
    }
}

C++
1
2
3
4
Vertex operator / (const Vertex& vertex, const float scalar)
{
    return Vertex(vertex.x / scalar, vertex.y / scalar, vertex.z / scalar);
}
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
Matrix4x4 operator * (const Matrix4x4& firstMatrix, const Matrix4x4& secondMatrix)
{
    Matrix4x4 newMatrix = Matrix4x4();
 
    newMatrix.elements[0][0] = 
        firstMatrix.elements[0][0] * secondMatrix.elements[0][0] +
        firstMatrix.elements[0][1] * secondMatrix.elements[1][0] +
        firstMatrix.elements[0][2] * secondMatrix.elements[2][0] +
        firstMatrix.elements[0][3] * secondMatrix.elements[3][0];
 
    newMatrix.elements[0][1] =
        firstMatrix.elements[0][0] * secondMatrix.elements[0][1] +
        firstMatrix.elements[0][1] * secondMatrix.elements[1][1] +
        firstMatrix.elements[0][2] * secondMatrix.elements[2][1] +
        firstMatrix.elements[0][3] * secondMatrix.elements[3][1];
 
    newMatrix.elements[0][2] =
        firstMatrix.elements[0][0] * secondMatrix.elements[0][2] +
        firstMatrix.elements[0][1] * secondMatrix.elements[1][2] +
        firstMatrix.elements[0][2] * secondMatrix.elements[2][2] +
        firstMatrix.elements[0][3] * secondMatrix.elements[3][2];
 
    newMatrix.elements[0][3] =
        firstMatrix.elements[0][0] * secondMatrix.elements[0][3] +
        firstMatrix.elements[0][1] * secondMatrix.elements[1][3] +
        firstMatrix.elements[0][2] * secondMatrix.elements[2][3] +
        firstMatrix.elements[0][3] * secondMatrix.elements[3][3];
 
 
 
 
    newMatrix.elements[1][0] =
        firstMatrix.elements[1][0] * secondMatrix.elements[0][0] +
        firstMatrix.elements[1][1] * secondMatrix.elements[1][0] +
        firstMatrix.elements[1][2] * secondMatrix.elements[2][0] +
        firstMatrix.elements[1][3] * secondMatrix.elements[3][0];
 
    newMatrix.elements[1][1] =
        firstMatrix.elements[1][0] * secondMatrix.elements[0][1] +
        firstMatrix.elements[1][1] * secondMatrix.elements[1][1] +
        firstMatrix.elements[1][2] * secondMatrix.elements[2][1] +
        firstMatrix.elements[1][3] * secondMatrix.elements[3][1];
 
    newMatrix.elements[1][2] =
        firstMatrix.elements[1][0] * secondMatrix.elements[0][2] +
        firstMatrix.elements[1][1] * secondMatrix.elements[1][2] +
        firstMatrix.elements[1][2] * secondMatrix.elements[2][2] +
        firstMatrix.elements[1][3] * secondMatrix.elements[3][2];
 
    newMatrix.elements[1][3] =
        firstMatrix.elements[1][0] * secondMatrix.elements[0][3] +
        firstMatrix.elements[1][1] * secondMatrix.elements[1][3] +
        firstMatrix.elements[1][2] * secondMatrix.elements[2][3] +
        firstMatrix.elements[1][3] * secondMatrix.elements[3][3];
 
 
 
 
 
 
 
 
    newMatrix.elements[2][0] =
        firstMatrix.elements[2][0] * secondMatrix.elements[0][0] +
        firstMatrix.elements[2][1] * secondMatrix.elements[1][0] +
        firstMatrix.elements[2][2] * secondMatrix.elements[2][0] +
        firstMatrix.elements[2][3] * secondMatrix.elements[3][0];
 
    newMatrix.elements[2][1] =
        firstMatrix.elements[2][0] * secondMatrix.elements[0][1] +
        firstMatrix.elements[2][1] * secondMatrix.elements[1][1] +
        firstMatrix.elements[2][2] * secondMatrix.elements[2][1] +
        firstMatrix.elements[2][3] * secondMatrix.elements[3][1];
 
    newMatrix.elements[2][2] =
        firstMatrix.elements[2][0] * secondMatrix.elements[0][2] +
        firstMatrix.elements[2][1] * secondMatrix.elements[1][2] +
        firstMatrix.elements[2][2] * secondMatrix.elements[2][2] +
        firstMatrix.elements[2][3] * secondMatrix.elements[3][2];
 
    newMatrix.elements[2][3] =
        firstMatrix.elements[2][0] * secondMatrix.elements[0][3] +
        firstMatrix.elements[2][1] * secondMatrix.elements[1][3] +
        firstMatrix.elements[2][2] * secondMatrix.elements[2][3] +
        firstMatrix.elements[2][3] * secondMatrix.elements[3][3];
 
 
 
 
 
 
    newMatrix.elements[3][0] =
        firstMatrix.elements[3][0] * secondMatrix.elements[0][0] +
        firstMatrix.elements[3][1] * secondMatrix.elements[1][0] +
        firstMatrix.elements[3][2] * secondMatrix.elements[2][0] +
        firstMatrix.elements[3][3] * secondMatrix.elements[3][0];
 
    newMatrix.elements[3][1] =
        firstMatrix.elements[3][0] * secondMatrix.elements[0][1] +
        firstMatrix.elements[3][1] * secondMatrix.elements[1][1] +
        firstMatrix.elements[3][2] * secondMatrix.elements[2][1] +
        firstMatrix.elements[3][3] * secondMatrix.elements[3][1];
 
    newMatrix.elements[3][2] =
        firstMatrix.elements[3][0] * secondMatrix.elements[0][2] +
        firstMatrix.elements[3][1] * secondMatrix.elements[1][2] +
        firstMatrix.elements[3][2] * secondMatrix.elements[2][2] +
        firstMatrix.elements[3][3] * secondMatrix.elements[3][2];
 
    newMatrix.elements[3][3] =
        firstMatrix.elements[3][0] * secondMatrix.elements[0][3] +
        firstMatrix.elements[3][1] * secondMatrix.elements[1][3] +
        firstMatrix.elements[3][2] * secondMatrix.elements[2][3] +
        firstMatrix.elements[3][3] * secondMatrix.elements[3][3];
 
 
    /*for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            newMatrix.elements[i][j] =
                firstMatrix.elements[i][0] * secondMatrix.elements[0][j] +
                firstMatrix.elements[i][1] * secondMatrix.elements[1][j] +
                firstMatrix.elements[i][2] * secondMatrix.elements[2][j] +
                firstMatrix.elements[i][3] * secondMatrix.elements[3][j];
        }
    }*/
 
    return newMatrix;
}
C++
1
2
3
4
5
6
7
8
9
10
11
12
Vertices operator * (const Matrix4x4& matrix, const Vertices vertices)
{
    std::vector<Vertex> newVertices;
 
    for (unsigned int i = 0; i < vertices.size(); i++)
    {
        Vertex vertex = matrix * vertices[i];
        newVertices.push_back(vertex);
    }
 
    return newVertices;
}
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
bool BaseModel::BuildTransformationMatrix()
{
    bool changesWereMade = false;
 
    if (isTranslateRotateOutdated)
    {
        // Set translation values into translation matrix
        translationMatrix.elements[0][3] = location.x;
        translationMatrix.elements[1][3] = location.y;
        translationMatrix.elements[2][3] = location.z;
 
 
        // Prepare values and set them into rotation matrix
        float angleDeg = rotationAngle.y * Math::pi / 180.0f;
        rotationMatrix.elements[0][0] = rotationMatrix.elements[2][2] = cos(angleDeg);
 
        float result = sin(angleDeg);
        rotationMatrix.elements[0][2] = result;
        rotationMatrix.elements[2][0] = -result;
 
 
        translationRotationMatrix = translationMatrix * rotationMatrix;
        isTranslateRotateOutdated = false;
 
        changesWereMade = true;
    }
 
    if (isScaleOutdated)
    {
        // Set scale values into scaling matrix
        scalingMatrix.elements[0][0] = scale.x;
        scalingMatrix.elements[1][1] = scale.y;
        scalingMatrix.elements[2][2] = scale.z;
 
        transformationMatrix = translationRotationMatrix * scalingMatrix;
        isScaleOutdated = false;
 
        changesWereMade = true;
    }
 
    return changesWereMade;
}
C++
1
2
3
4
5
6
7
8
9
10
11
Camera::Camera()
{
    Math::Identity(viewMatrix);
    Math::Identity(projectionMatrix);
    projectionMatrix.elements[2][3] = -1.0f;
    projectionMatrix.elements[3][3] = 0.0f;
 
    SetNearFar(-1.0f, 1.0f);
    SetFov(10.0f);
    SetEye(Vertex(0.0f, 0.0f, 15.0f));
}

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
void Camera::BuildProjectionMatrix()
{
    if (isProjectionOutdated)
    {
        float scale = 1 / (tanf(fov / 2 * Math::pi / 180.0f));
        projectionMatrix.elements[0][0] = projectionMatrix.elements[1][1] = scale;
 
        float difference = farPlane - nearPlane;
        projectionMatrix.elements[2][2] = -(farPlane / difference);
        projectionMatrix.elements[3][2] = -(farPlane * nearPlane / difference);
        isProjectionOutdated = false;
    }
}
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
float Math::CalculateDeterminant(const Matrix3x3& matrix)
{
    return matrix.elements[0][0] * (matrix.elements[1][1] * matrix.elements[2][2] - matrix.elements[1][2] * matrix.elements[2][1]) -
        matrix.elements[0][1] * (matrix.elements[1][0] * matrix.elements[2][2] - matrix.elements[1][2] * matrix.elements[2][0]) +
        matrix.elements[0][2] * (matrix.elements[1][0] * matrix.elements[2][1] - matrix.elements[1][1] * matrix.elements[2][0]);
}
 
 
float Math::CalculateDeterminant(const Matrix4x4& matrix)
{
    std::vector<int> horizontalIndexes = { 1, 2, 3 };
    float det = 0.0f;
 
    for (int j = 0; j < 4; j++)
    {
        if (matrix.elements[0][j] == 0) { continue; }
 
        std::vector<int> verticalIndexes = { 0, 1, 2, 3 };
        std::vector<int>::iterator vPosition = std::find(verticalIndexes.begin(), verticalIndexes.end(), j);
        verticalIndexes.erase(vPosition);
 
        Matrix3x3 tempMatrix;
        for (int k = 0; k < 3; k++)
        {
            for (int l = 0; l < 3; l++)
            {
                tempMatrix.elements[k][l] = matrix.elements[horizontalIndexes[k]][verticalIndexes[l]];
            }
        }
 
        int sign = j % 2 ? -1 : 1;
 
        det += matrix.elements[0][j] * CalculateDeterminant(tempMatrix) * sign;
    }
 
    return det;
}
 
 
void Math::TransposeMatrix(const Matrix4x4& inputMatrix, Matrix4x4& outputMatrix)
{
    Matrix4x4 tempMatrix;
 
    for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            //if (i == j) { continue; }
 
            tempMatrix.elements[i][j] = inputMatrix.elements[j][i];
        }
    }
 
    for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            //if (i == j) { continue; }
 
            outputMatrix.elements[i][j] = tempMatrix.elements[i][j];
        }
    }
}
 
 
void Math::CalculateCofactorMatrix(const Matrix4x4& inputMatrix, Matrix4x4& outputMatrix)
{
    for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            std::vector<int> horizontalIndexes = { 0, 1, 2, 3 };
            std::vector<int> verticalIndexes = { 0, 1, 2, 3 };
 
            std::vector<int>::iterator hPosition = std::find(horizontalIndexes.begin(), horizontalIndexes.end(), i);
            horizontalIndexes.erase(hPosition);
 
            std::vector<int>::iterator vPosition = std::find(verticalIndexes.begin(), verticalIndexes.end(), j);
            verticalIndexes.erase(vPosition);
 
            // Transpose matrix
            Matrix3x3 tempMatrix;
            for (int k = 0; k < 3; k++)
            {
                for (int l = 0; l < 3; l++)
                {
                    tempMatrix.elements[k][l] = inputMatrix.elements[horizontalIndexes[k]][verticalIndexes[l]];
                }
            }
 
            int sign = (i + j) % 2 ? -1 : 1;
 
            outputMatrix.elements[i][j] = CalculateDeterminant(tempMatrix) * sign;
        }
    }
}
 
 
void Math::DivideMatrixByScalar(const Matrix4x4& inputMatrix, Matrix4x4& outputMatrix, const float value)
{
    for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 4; j++)
        {
            outputMatrix.elements[i][j] = inputMatrix.elements[i][j] * value;
        }
    }
}
 
 
void Math::CalculateMatrixInverse(const Matrix4x4& inputMatrix, Matrix4x4& outputMatrix)
{
    // step 1: find the determinant
    float det = CalculateDeterminant(inputMatrix);
    Matrix4x4 tempMatrix;
 
    if (det == 0)
    {
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 4; j++)
            {
                tempMatrix.elements[i][j] = inputMatrix.elements[i][j];
            }
        }
 
        TransposeMatrix(tempMatrix, outputMatrix);
        return;
    }
 
    // step 2: calculate the matrix of cofactors
    CalculateCofactorMatrix(inputMatrix, tempMatrix);
 
    // step 3: transpose the matrix
    Matrix4x4 anotherTempMatrix;
    TransposeMatrix(tempMatrix, anotherTempMatrix);
 
    // step 4: divide matrix by determinant
    DivideMatrixByScalar(anotherTempMatrix, outputMatrix, 1 / det);
}
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru