I have matrices for perspective projection. but I don't know how to multiply the matrices

I have a bit of code that has a Object3D struct with vertices and triangles
and I have a class that replicates a perspective camera, but I don't know how to multiply the matrices like:

projectionMatrix * (vertices+cameraPos) * toScreenMatrix


Code (3D.h):

#include<list>
#include <cmath>
#include <iostream>

struct Object3D {
    float vertices;//{ {1.0, 1.0, -1.0, 1}, {1.0, -1.0, -1.0, 1}, {1.0, 1.0, 1.0, 1}, {1.0, -1.0, 1.0, 1}, {-1.0, 1.0, -1.0, 1}, {-1.0, -1.0, -1.0, 1}, {-1.0, 1.0, 1.0, 1}, {-1.0, -1.0, 1.0, 1} };
    float triangles;//{ {4, 2, 0}, {2, 7, 3}, {6, 5, 7}, {1, 7, 5}, {0, 3, 1}, {4, 1, 5}, {4, 6, 2}, {2, 6, 7}, {6, 4, 5}, {1, 3, 7}, {0, 2, 3}, {4, 0, 1} };
};

class PerspectiveProjectionCamera {
public:
    float projectionMatrix[4][4];
    float toScreenMatrix[4][4];
    float position[3];
    int hwidth;
    int hheight;
    void init(float nearplane, float farplane, int width, int height, float FOV) { //FOV: 14719667 (π/3)
        vFOV = FOV * (height / width);
        right = tan(FOV / 2);
        left = -right;
        top = tan(vFOV / 2);
        bottom = -top;
        hwidth = (int)width / 2;
        hheight = (int)height / 2;
        m00 = 2 / (right - left);
        m11 = 2 / (top - bottom);
        m22 = (farplane + nearplane) / (farplane - nearplane);
        m32 = -2 * nearplane * farplane / (farplane - nearplane);
        float projectionMatrix[4][4] = {
            {m00, 0, 0, 0 },
            {0, m11, 0, 0},
            {0, 0, m22, 1},
            {0, 0, m32, 0}
        };
        float toScreenMatrix[4][4] = {
            {(float)width / 2, 0, 0, 0},
            {0, -(float)height / 2, 0 ,0},
            {0, 0, 1, 0},
            {(float)width / 2, (float)height / 2, 0, 0}
        };
    }
private:
    double vFOV;
    double right;
    double left;
    double top;
    double bottom;
    double m00;
    double m11;
    double m22;
    double m32;
};

If you need the other code I can give it to you!

I have tried three times using different functions for matrix multiplication and one made my computer crash (don't ask) and they all give errors.

I'm expecting to be able to draw 100K Triangles at more that 10FPS

In the interest of learning how this is done internally and to avoid linking against 3rd party libraries, which can be a pain, you can basically just use simple C-style algebra routines as follows

#include <cstdint>
#include <iostream>

using Matrix = float[4][4];

void multiply( const Matrix&a, const Matrix&b, Matrix&c ) {
    for ( int i=0; i<4; ++i ) {
        for ( int j=0; j<4; ++j ) {
            float sum = 0;
            for ( int k=0; k<4; ++k ) {
                sum += a[i][k]*b[k][j];
            }
            c[i][j] = sum;
        }
    }
}

void sum( const Matrix&a, const Matrix&b, Matrix&c ) {
    for ( int i=0; i<4; ++i ) {
        for ( int j=0; j<4; ++j ) {
            c[i][j] = a[i][j]+b[i][j];
        }
    }
}

void print( const Matrix& a ) {
    for ( int i=0; i<4; ++i ) {
        for ( int j=0; j<4; ++j ) {
            std::cout << a[i][j] << " ";
        }
        std::cout << std::endl;
    }
}

As they are C-style functions, you do not get the C++ syntax sugar and have to call them directly, which is not a big deal to be frank.

Matrix I = {{1,0,0,0},{0,1,0,0},{0,0,1,0},{0,0,0,1}};
Matrix x = {{1,2,3,4},{5,6,7,8},{9,10,11,12},{13,14,15,16}};

int main() {
    Matrix res;
    multiply(I,x,res);
    print( res );
    sum(I,x,res);
    print( res );
}

Results in

Program stdout
1 2 3 4 
5 6 7 8 
9 10 11 12 
13 14 15 16 
2 2 3 4 
5 7 7 8 
9 10 12 12 
13 14 15 17 

Godbolt: https://godbolt.org/z/f4MWExjMM

For a more robust and cpp_like solution you can do as following :

#include <iostream>
#include <vector>
struct Object3D {
std::vector<std::vector<float>> vertices;
std::vector<std::vector<int>> triangles;
};
class PerspectiveProjectionCamera {
public:
std::vector<std::vector<float>> projectionMatrix;
std::vector<std::vector<float>> toScreenMatrix;
std::vector<float> position;
int hwidth;
int hheight;
void init(float nearplane, float farplane, int width, int height, float FOV) {
// Your initialization code here
// Example matrix initialization
projectionMatrix = {
{ m00, 0, 0, 0 },
{ 0, m11, 0, 0 },
{ 0, 0, m22, 1 },
{ 0, 0, m32, 0 }
};
toScreenMatrix = {
{ static_cast<float>(width) / 2, 0, 0, 0 },
{ 0, -static_cast<float>(height) / 2, 0, 0 },
{ 0, 0, 1, 0 },
{ static_cast<float>(width) / 2, static_cast<float>(height) / 2, 0, 0 }
};
}
std::vector<std::vector<float>> multiplyMatrix(const std::vector<std::vector<float>>& matrixA, const std::vector<std::vector<float>>& matrixB) {
int rowsA = matrixA.size();
int colsA = matrixA[0].size();
int colsB = matrixB[0].size();
std::vector<std::vector<float>> result(rowsA, std::vector<float>(colsB, 0));
for (int i = 0; i < rowsA; ++i) {
for (int j = 0; j < colsB; ++j) {
for (int k = 0; k < colsA; ++k) {
result[i][j] += matrixA[i][k] * matrixB[k][j];
}
}
}
return result;
}
std::vector<std::vector<float>> transformVertices(const Object3D& object) {
std::vector<std::vector<float>> transformedVertices;
for (const auto& vertex : object.vertices) {
std::vector<float> transformedVertex = multiplyMatrix(projectionMatrix, addVectors(vertex, position));
transformedVertices.push_back(transformedVertex);
}
return transformedVertices;
}
std::vector<float> addVectors(const std::vector<float>& vectorA, const std::vector<float>& vectorB) {
int size = vectorA.size();
std::vector<float> result(size);
for (int i = 0; i < size; ++i) {
result[i] = vectorA[i] + vectorB[i];
}
return result;
}
};
int main() {
PerspectiveProjectionCamera camera;
camera.init(/* nearplane, farplane, width, height, FOV */);
Object3D object;
// Initialize object.vertices and object.triangles
// Perform vertex transformations
std::vector<std::vector<float>> transformedVertices = camera.transformVertices(object);
// Example usage: printing transformed vertices
for (const auto& vertex : transformedVertices) {
std::cout << "Transformed Vertex: ";
for (const auto& coordinate : vertex) {
std::cout << coordinate << " ";
}
std::cout << std::endl;
}
return 0;
}

** Even this code doesn't guarantee best performance.**

To achieve more optimal performance, you should consider 3rd-party libraries like this:

#include <iostream>
#include <Eigen/Dense>
#include <vector>
struct Object3D {
std::vector<Eigen::Vector4f> vertices; // Store vertices as Eigen vectors
std::vector<Eigen::Vector3i> triangles; // Store triangles as Eigen vectors
};
class PerspectiveProjectionCamera {
public:
Eigen::Matrix4f projectionMatrix;
Eigen::Matrix4f toScreenMatrix;
Eigen::Vector3f position;
int hwidth;
int hheight;
void init(float nearplane, float farplane, int width, int height, float FOV) {
// Your initialization code here
// Example matrix initialization
projectionMatrix << m00, 0, 0, 0,
0, m11, 0, 0,
0, 0, m22, 1,
0, 0, m32, 0;
toScreenMatrix << static_cast<float>(width) / 2, 0, 0, 0,
0, -static_cast<float>(height) / 2, 0, 0,
0, 0, 1, 0,
static_cast<float>(width) / 2, static_cast<float>(height) / 2, 0, 0;
}
std::vector<Eigen::Vector3f> transformVertices(const Object3D& object) {
std::vector<Eigen::Vector3f> transformedVertices;
transformedVertices.reserve(object.vertices.size());
for (const auto& vertex : object.vertices) {
Eigen::Vector4f transformedVertex = projectionMatrix * (vertex + Eigen::Vector4f(position.x(), position.y(), position.z(), 1.0f));
transformedVertices.emplace_back(transformedVertex.head<3>());
}
return transformedVertices;
}
};
int main() {
PerspectiveProjectionCamera camera;
camera.init(/* nearplane, farplane, width, height, FOV */);
Object3D object;
// Initialize object.vertices and object.triangles
// Perform vertex transformations
std::vector<Eigen::Vector3f> transformedVertices = camera.transformVertices(object);
// Example usage: printing transformed vertices
for (const auto& vertex : transformedVertices) {
std::cout << "Transformed Vertex: " << vertex.transpose() << std::endl;
}
return 0;
}