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

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

Восстановить пароль Регистрация
Другие темы раздела
C++ Почему не работает cin>> в Sublime Text 3? http://www.cyberforum.ru/cpp/thread1809252.html
Доброго времени суток, подскажите пожалуйста, можно ли в редакторе кода Sublime Text 3 вводить данные во встроенную снизу панель при запуске программы? Выводить данные она выводит, а вот вводить не позволяет.
C++ Скопировать объект, на который ссылается указатель на абстрактный класс Доброго времени суток. У меня такое задание: написать программу символьного дифференцирования, т.е. пользователь пишет функцию f(x), а программа выводит ее производную как f'(x). Так вот есть базовый абстрактный класс, который дан в условии задачи class Expression { public: virtual Expression *diff()=0; //функция дифференцирования virtual void print()=0; //функция вывода... http://www.cyberforum.ru/cpp/thread1809084.html
C++ Немного философии ООП
На днях на работе возник холивар с коллегами, к правильному решению пришли только на следующий день, почитав Мейерса и Саттера (один из участников холивара уже знал о правильном решении, но сторонников неправильного было большинство). Рекомендаций от упомянутых гуру пока не говорю, предлагаю поразмышлять) Итак - есть проект, в проекте используется ООП, скатываться до С считается мовитоном и...
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 );
C++ Как компилятор обрабатывает член класса static constexpr const char* http://www.cyberforum.ru/cpp/thread1808427.html
Привет! Наткнулся на непонятный момент class Foo { public: static constexpr const char* PTR = "value"; }; без constexpr не компилируется. Вопрос - как компилятора без линкера разруливает это дело, ведь constexpr value ему нужен на этапе компиляции? Если он это пережевывает, почему тогда constexpr необходим?
C++ Получить график дат санитарных дней в указанном году задача: Городской рынок имеет санитарный день каждый понедельник месяца . Дано номер года и указано день недели , на который приходится 1 января. Получить график дат санитарных дней в указанном году. Помогите пожалуйста решить задачу подробнее

Показать сообщение отдельно
Pro100Tom
 Аватар для 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);
}
 
Текущее время: 14:13. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru