From 0a2da4f82435a49212e276d9d603e84ac298246d Mon Sep 17 00:00:00 2001 From: Mateja Date: Sun, 27 Dec 2020 00:09:34 +0100 Subject: Reorganize entire project. --- src/Bitmap.cpp | 34 ++++++++++++++++++ src/Bitmap.h | 12 +++++++ src/Matrix4f.cpp | 104 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/Matrix4f.h | 15 ++++++++ src/ObjModel.cpp | 93 +++++++++++++++++++++++++++++++++++++++++++++++++ src/ObjModel.h | 31 +++++++++++++++++ src/Render.cpp | 98 +++++++++++++++++++++++++++++++++++++++++++++++++++ src/Render.h | 13 +++++++ src/Vector4f.cpp | 32 +++++++++++++++++ src/Vector4f.h | 12 +++++++ src/Vertice.cpp | 46 ++++++++++++++++++++++++ src/Vertice.h | 14 ++++++++ src/main.cpp | 83 ++++++++++++++++++++++++++++++++++++++++++++ 13 files changed, 587 insertions(+) create mode 100644 src/Bitmap.cpp create mode 100644 src/Bitmap.h create mode 100644 src/Matrix4f.cpp create mode 100644 src/Matrix4f.h create mode 100644 src/ObjModel.cpp create mode 100644 src/ObjModel.h create mode 100644 src/Render.cpp create mode 100644 src/Render.h create mode 100644 src/Vector4f.cpp create mode 100644 src/Vector4f.h create mode 100644 src/Vertice.cpp create mode 100644 src/Vertice.h create mode 100644 src/main.cpp (limited to 'src') diff --git a/src/Bitmap.cpp b/src/Bitmap.cpp new file mode 100644 index 0000000..363145f --- /dev/null +++ b/src/Bitmap.cpp @@ -0,0 +1,34 @@ +#include "Bitmap.h" + +Bitmap::Bitmap(int width_, int height_) { + width = width_; + height = height_; + pixels = new unsigned char[width * height * 4]; +} + +Bitmap::~Bitmap() { + delete[] pixels; +} + +void Bitmap::fill(int r, int g, int b) { + for (int i = 0; i < width * height * 4; i+=4) + { + pixels[i + 0] = r; + pixels[i + 1] = g; + pixels[i + 2] = b; + pixels[i + 3] = 255; + } +} + +void Bitmap::setPixel(int x, int y, int r, int g, int b) { + int hlp = ((y * width) + x) * 4; + if (!(hlp < 0 || hlp >(width * height * 4) - 3)) { + pixels[hlp + 0] = r; + pixels[hlp + 1] = g; + pixels[hlp + 2] = b; + pixels[hlp + 3] = 255; + } + else { + std::cout << "Position of pixel:\t" << hlp << "\tX: " << x << "\tY: "<< y << "\n"; + } +} diff --git a/src/Bitmap.h b/src/Bitmap.h new file mode 100644 index 0000000..c4064ad --- /dev/null +++ b/src/Bitmap.h @@ -0,0 +1,12 @@ +#include +class Bitmap +{ +public: + int width, height; + unsigned char *pixels; + Bitmap(int width_, int height_); + ~Bitmap(); + void fill(int r, int g, int b); + void setPixel(int x, int y, int r, int g, int b); +}; + diff --git a/src/Matrix4f.cpp b/src/Matrix4f.cpp new file mode 100644 index 0000000..2cf2d9a --- /dev/null +++ b/src/Matrix4f.cpp @@ -0,0 +1,104 @@ +#include "Matrix4f.h" + + + +Matrix4f::Matrix4f() +{ + m[0][0] = 1; m[0][1] = 0; m[0][2] = 0; m[0][3] = 0; + m[1][0] = 0; m[1][1] = 1; m[1][2] = 0; m[1][3] = 0; + m[2][0] = 0; m[2][1] = 0; m[2][2] = 1; m[2][3] = 0; + m[3][0] = 0; m[3][1] = 0; m[3][2] = 0; m[3][3] = 1; +} + +Matrix4f Matrix4f::multiply(Matrix4f& a) +{ + Matrix4f b = identity(); + for (int i = 0; i < 4; i++) + { + for (int j = 0; j < 4; j++) + { + b.m[i][j] = ((m[i][0] * a.m[0][j]) + (m[i][1] * a.m[1][j]) + (m[i][2] * a.m[2][j]) + (m[i][3] * a.m[3][j])); + } + } + return b; +} + +Matrix4f Matrix4f::operator*(Matrix4f& a) +{ + Matrix4f b = identity(); + for (int i = 0; i < 4; i++) + { + for (int j = 0; j < 4; j++) + { + b.m[i][j] = ((m[i][0] * a.m[0][j]) + (m[i][1] * a.m[1][j]) + (m[i][2] * a.m[2][j]) + (m[i][3] * a.m[3][j])); + } + } + return b; +} + +Matrix4f Matrix4f::identity() +{ + return Matrix4f(); +} + +Matrix4f Matrix4f::move(float kx, float ky, float kz) +{ + Matrix4f b; + b.m[0][0] = 1; b.m[0][1] = 0; b.m[0][2] = 0; b.m[0][3] = kx; + b.m[1][0] = 0; b.m[1][1] = 1; b.m[1][2] = 0; b.m[1][3] = ky; + b.m[2][0] = 0; b.m[2][1] = 0; b.m[2][2] = 1; b.m[2][3] = kz; + b.m[3][0] = 0; b.m[3][1] = 0; b.m[3][2] = 0; b.m[3][3] = 1; + return b; +} + +Matrix4f Matrix4f::rotate(float xs, float ys, float zs) +{ + double hlp = 3.14159265 / 180.0; + xs *= hlp; + ys *= hlp; + zs *= hlp; + Matrix4f b; + b.m[0][0] = 1; b.m[0][1] = 0; b.m[0][2] = 0; b.m[0][3] = 0; + b.m[1][0] = 0; b.m[1][1] = cos(xs); b.m[1][2] = -sin(xs); b.m[1][3] = 0; + b.m[2][0] = 0; b.m[2][1] = sin(xs); b.m[2][2] = cos(xs); b.m[2][3] = 0; + b.m[3][0] = 0; b.m[3][1] = 0; b.m[3][2] = 0; b.m[3][3] = 1; + + Matrix4f c; + c.m[0][0] = cos(ys); c.m[0][1] = 0; c.m[0][2] = sin(ys); c.m[0][3] = 0; + c.m[1][0] = 0; c.m[1][1] = 1; c.m[1][2] = 0; c.m[1][3] = 0; + c.m[2][0] = -sin(ys); c.m[2][1] = 0; c.m[2][2] = cos(ys); c.m[2][3] = 0; + c.m[3][0] = 0; c.m[3][1] = 0; c.m[3][2] = 0; c.m[3][3] = 1; + + Matrix4f d; + d.m[0][0] = cos(zs); d.m[0][1] = -sin(zs); d.m[0][2] = 0; d.m[0][3] = 0; + d.m[1][0] = sin(zs); d.m[1][1] = cos(zs); d.m[1][2] = 0; d.m[1][3] = 0; + d.m[2][0] = 0; d.m[2][1] = 0; d.m[2][2] = 1; d.m[2][3] = 0; + d.m[3][0] = 0; d.m[3][1] = 0; d.m[3][2] = 0; d.m[3][3] = 1; + + return d * c * b; +} + +Matrix4f Matrix4f::scale(float px, float py, float pz) +{ + Matrix4f b; + b.m[0][0] = px; b.m[0][1] = 0; b.m[0][2] = 0; b.m[0][3] = 0; + b.m[1][0] = 0; b.m[1][1] = py; b.m[1][2] = 0; b.m[1][3] = 0; + b.m[2][0] = 0; b.m[2][1] = 0; b.m[2][2] = pz; b.m[2][3] = 0; + b.m[3][0] = 0; b.m[3][1] = 0; b.m[3][2] = 0; b.m[3][3] = 1; + return b; +} + +Matrix4f Matrix4f::perspective(float n, float f, float fov, float aspectRatio) +{ + float l, r, t, b; + t = n * tan((fov / 2.0f) * (3.14159265 / 180.0)); + b = -t; + r = aspectRatio * t; + l = -r; + Matrix4f a; + a.m[0][0] = ((2.0f * n) / (r - l)); a.m[0][1] = 0; a.m[0][2] = - ((r + l) / (r - l)); a.m[0][3] = 0; + a.m[1][0] = 0; a.m[1][1] = ((2.0f * n) / (t - b)); a.m[1][2] = - ((t + b) / (t - b)); a.m[1][3] = 0; + a.m[2][0] = 0; a.m[2][1] = 0; a.m[2][2] = - (f / (n - f)); a.m[2][3] = ((n * f) / (n - f)); + a.m[3][0] = 0; a.m[3][1] = 0; a.m[3][2] = 1; a.m[3][3] = 0; + return a; +} diff --git a/src/Matrix4f.h b/src/Matrix4f.h new file mode 100644 index 0000000..85946c0 --- /dev/null +++ b/src/Matrix4f.h @@ -0,0 +1,15 @@ +#include +class Matrix4f +{ +public: + float m[4][4]; + Matrix4f(); + Matrix4f multiply(Matrix4f& a); + Matrix4f operator* (Matrix4f& a); + static Matrix4f identity(); + static Matrix4f move(float kx, float ky, float kz); + static Matrix4f rotate(float xs, float ys, float zs); + static Matrix4f scale(float px, float py, float pz); + static Matrix4f perspective(float near, float far, float fov, float aspectRatio); +}; + diff --git a/src/ObjModel.cpp b/src/ObjModel.cpp new file mode 100644 index 0000000..f23cfc3 --- /dev/null +++ b/src/ObjModel.cpp @@ -0,0 +1,93 @@ +#include "ObjModel.h" + + + +ObjModel::ObjModel() {} + +ObjModel::ObjModel(std::string fileName) +{ + int hlp = 0; + std::ifstream f(fileName); + std::string s0; + while (getline(f, s0)) { + std::stringstream ss0(s0); + std::string s1 = ""; + ss0 >> s1; + if (s1.compare(0, s1.length(), "v") == 0) { + ss0 >> s1; + float x = std::stof(s1); + ss0 >> s1; + float y = std::stof(s1); + ss0 >> s1; + float z = std::stof(s1); + Vertice t(x, y, z, 1.0f, 0.0f, 0.0f); + vertices.push_back(t); + } + else if (s1.compare(0, s1.length(), "vn") == 0) { + ss0 >> s1; + float x = std::stof(s1); + ss0 >> s1; + float y = std::stof(s1); + ss0 >> s1; + float z = std::stof(s1); + Vector4f v(x, y, z, 0.0f); + normals.push_back(v); + } + else if (s1.compare(0, s1.length(), "vt") == 0) { + ss0 >> s1; + float u = std::stof(s1); + ss0 >> s1; + float v = std::stof(s1); + Texture_Coordinates kt; + kt.u = u; kt.v = v; + uvcoo.push_back(kt); + } + else if (s1.compare(0, s1.length(), "f") == 0) { + Triangle pt; + for (int i = 0; i < 3; i++) { + ss0 >> s1; + std::stringstream ss1(s1); + std::string s2; + for (int j = 0; std::getline(ss1, s2, '/'); j++) { + pt.p[i][j] = std::stoi(s2); + } + } + faces.push_back(pt); + } + } + +} + +ObjModel::ObjModel(const ObjModel& a) +{ + vertices = a.vertices; + uvcoo = a.uvcoo; + normals = a.normals; + faces = a.faces; +} + +ObjModel ObjModel::multiplyMatrix(Matrix4f& a) +{ + ObjModel hlp = *this; + for (int i = 0; i < vertices.size(); i++) + { + hlp.vertices[i] = hlp.vertices[i].multiplyMatrix(a); + } + return hlp; +} + +void ObjModel::divideW() +{ + for (int i = 0; i < vertices.size(); i++) + { + vertices[i] = vertices[i].divideW(); + } +} + +void ObjModel::screenspace(int width, int height) +{ + for (int i = 0; i < vertices.size(); i++) + { + vertices[i].screenspace(width, height); + } +} diff --git a/src/ObjModel.h b/src/ObjModel.h new file mode 100644 index 0000000..9f66867 --- /dev/null +++ b/src/ObjModel.h @@ -0,0 +1,31 @@ +#include"Vertice.h" +#include"Bitmap.h" +#include +#include +#include +#include +#include + +struct Triangle { + int p[3][3]; +}; + +struct Texture_Coordinates { + float u, v; +}; + +class ObjModel +{ +public: + std::vector vertices; + std::vector uvcoo; + std::vector normals; + std::vector faces; + ObjModel(); + ObjModel(std::string fileName); + ObjModel(const ObjModel& a); + ObjModel multiplyMatrix(Matrix4f& a); + void divideW(); + void screenspace(int width, int height); +}; + diff --git a/src/Render.cpp b/src/Render.cpp new file mode 100644 index 0000000..7aabc43 --- /dev/null +++ b/src/Render.cpp @@ -0,0 +1,98 @@ +#include + +#include "Render.h" + +Render::Render(int width_, int height_) : Bitmap(width_, height_) +{ + zBuffer = new float[width * height]; + for (int i = 0; i < width * height; i++) + zBuffer[i] = std::numeric_limits::infinity(); +} + +float Render::edgeFun(const Vertice& A, const Vertice& B, const Vertice& P) +{ + return ((P.x - A.x)*(B.y - A.y) - (P.y - A.y)*(B.x - A.x)); +} + +void Render::drawTriangle(Vertice t1, Vertice t2, Vertice t3, Bitmap& texture) +{ + int maxx = fmax(t1.x, fmax(t2.x, t3.x)); + int minx = fmin(t1.x, fmin(t2.x, t3.x)); + int maxy = fmax(t1.y, fmax(t2.y, t3.y)); + int miny = fmin(t1.y, fmin(t2.y, t3.y)); + + Vertice p((float)minx + 0.5f, (float)miny + 0.5f, 0.0f, 0.0f, 0.0f, 0.0f); + + int surface = edgeFun(t1, t2, t3); + int w1_row = edgeFun(t2, t3, p); int w1xk = (t3.y - t2.y), w1yk = -(t3.x - t2.x); + int w2_row = edgeFun(t3, t1, p); int w2xk = (t1.y - t3.y), w2yk = -(t1.x - t3.x); + int w3_row = edgeFun(t1, t2, p); int w3xk = (t2.y - t1.y), w3yk = -(t2.x - t1.x); + + for (int y = miny; y < maxy; y++) { + int w1_vertice = w1_row; + int w2_vertice = w2_row; + int w3_vertice = w3_row; + for (int x = minx; x < maxx; x++) { + + float w1 = w1_vertice; + float w2 = w2_vertice; + float w3 = w3_vertice; + + if ((w3 >= 0 && w1 >= 0 && w2 >= 0) || (w3 <= 0 && w1 <= 0 && w2 <= 0)) + { + w1 /= surface; + w2 /= surface; + w3 /= surface; + + float w = 1.0f / (w1 * t1.w + w2 * t2.w + w3 * t3.w); + float z =/* w * */1.0f / ((w1 * t1.z + w2 * t2.z + w3 * t3.z) * w); + if (zBuffer[(y * (width)) + x] > z) { + zBuffer[(y * (width)) + x] = z; + float u = w * (w1 * t1.u + w2 * t2.u + w3 * t3.u); + float v = w * (w1 * t1.v + w2 * t2.v + w3 * t3.v); + + u = round((u * texture.width)); + v = round((v * (texture.height - 1))); + + int hlp = ((v * texture.width) + u) * 4; + int r = texture.pixels[hlp + 0]; + int g = texture.pixels[hlp + 1]; + int b = texture.pixels[hlp + 2]; + setPixel(x, y, r, g, b); + } + } + + w1_vertice += w1xk; + w2_vertice += w2xk; + w3_vertice += w3xk; + } + + w1_row += w1yk; + w2_row += w2yk; + w3_row += w3yk; + } +} + + +void Render::renderModel(ObjModel& model, Bitmap& texture) +{ + for (int i = 0; i < model.faces.size(); i++) { + + model.vertices[model.faces[i].p[0][0] - 1].u = model.uvcoo[model.faces[i].p[0][1] - 1].u * model.vertices[model.faces[i].p[0][0] - 1].w; + model.vertices[model.faces[i].p[0][0] - 1].v = model.uvcoo[model.faces[i].p[0][1] - 1].v * model.vertices[model.faces[i].p[0][0] - 1].w; + + model.vertices[model.faces[i].p[1][0] - 1].u = model.uvcoo[model.faces[i].p[1][1] - 1].u * model.vertices[model.faces[i].p[1][0] - 1].w; + model.vertices[model.faces[i].p[1][0] - 1].v = model.uvcoo[model.faces[i].p[1][1] - 1].v * model.vertices[model.faces[i].p[1][0] - 1].w; + + model.vertices[model.faces[i].p[2][0] - 1].u = model.uvcoo[model.faces[i].p[2][1] - 1].u * model.vertices[model.faces[i].p[2][0] - 1].w; + model.vertices[model.faces[i].p[2][0] - 1].v = model.uvcoo[model.faces[i].p[2][1] - 1].v * model.vertices[model.faces[i].p[2][0] - 1].w; + + + drawTriangle(model.vertices[model.faces[i].p[0][0] - 1], model.vertices[model.faces[i].p[1][0] - 1], model.vertices[model.faces[i].p[2][0] - 1], texture); + } +} + +void Render::resetZBuf() { + for (int i = 0; i < width * height; i++) + zBuffer[i] = std::numeric_limits::infinity(); +} diff --git a/src/Render.h b/src/Render.h new file mode 100644 index 0000000..386cbcb --- /dev/null +++ b/src/Render.h @@ -0,0 +1,13 @@ +#include"ObjModel.h" +class Render : public Bitmap +{ +private: + float edgeFun(const Vertice& A, const Vertice& B, const Vertice& P); +public: + float* zBuffer; + Render(int width_, int height_); + void drawTriangle(Vertice t1, Vertice t2, Vertice t3, Bitmap& texture); + void renderModel(ObjModel& model, Bitmap& texture); + void resetZBuf(); +}; + diff --git a/src/Vector4f.cpp b/src/Vector4f.cpp new file mode 100644 index 0000000..506dc22 --- /dev/null +++ b/src/Vector4f.cpp @@ -0,0 +1,32 @@ +#include "Vector4f.h" + +Vector4f::Vector4f() {} + +Vector4f::Vector4f(float x_, float y_, float z_, float w_) +{ + x = x_; + y = y_; + z = z_; + w = w_; +} + +float Vector4f::dotProduct(const Vector4f& a) +{ + return ((x * a.x) + (y * a.y) + (z * a.z)); +} + +Vector4f Vector4f::crossProduct(const Vector4f& a) +{ + return Vector4f((y * a.z - z * a.y), (z * a.x - x * a.z), (x * a.y - y * a.x), (w * a.w)); +} + +Vector4f Vector4f::multiplyMatrix(const Matrix4f& a) +{ + float x1, y1, z1, w1; + x1 = ((x * a.m[0][0]) + (y * a.m[0][1]) + (z * a.m[0][2]) + (w * a.m[0][3])); + y1 = ((x * a.m[1][0]) + (y * a.m[1][1]) + (z * a.m[1][2]) + (w * a.m[1][3])); + z1 = ((x * a.m[2][0]) + (y * a.m[2][1]) + (z * a.m[2][2]) + (w * a.m[2][3])); + w1 = ((x * a.m[3][0]) + (y * a.m[3][1]) + (z * a.m[3][2]) + (w * a.m[3][3])); + return Vector4f(x1, y1, z1, w1); +} + diff --git a/src/Vector4f.h b/src/Vector4f.h new file mode 100644 index 0000000..ee1846a --- /dev/null +++ b/src/Vector4f.h @@ -0,0 +1,12 @@ +#include"Matrix4f.h" +class Vector4f +{ +public: + float x, y, z, w; + Vector4f(); + Vector4f(float x_, float y_, float z_, float w_); + float dotProduct(const Vector4f& a); + Vector4f crossProduct(const Vector4f& a); + Vector4f multiplyMatrix(const Matrix4f& a); +}; + diff --git a/src/Vertice.cpp b/src/Vertice.cpp new file mode 100644 index 0000000..022c477 --- /dev/null +++ b/src/Vertice.cpp @@ -0,0 +1,46 @@ +#include "Vertice.h" + +Vertice::Vertice() : Vector4f() {} + +Vertice::Vertice(float x_, float y_, float z_, float u_, float v_) : Vector4f (x_, y_, z_, 1) +{ + u = u_; + v = v_; +} + +Vertice::Vertice(float x_, float y_, float z_, float w_, float u_, float v_) : Vector4f(x_, y_, z_, w_) +{ + u = u_; + v = v_; +} + +void Vertice::screenspace(int screenWidth, int screenHeight) +{ + x = round(((x + 1.0f) / 2.0f) * screenWidth); + y = round(((-y + 1.0f) / 2.0f) * screenHeight); +} + +Vertice Vertice::multiplyMatrix(const Matrix4f& a) +{ + float x1, y1, z1, w1; + x1 = ((x * a.m[0][0]) + (y * a.m[0][1]) + (z * a.m[0][2]) + (w * a.m[0][3])); + y1 = ((x * a.m[1][0]) + (y * a.m[1][1]) + (z * a.m[1][2]) + (w * a.m[1][3])); + z1 = ((x * a.m[2][0]) + (y * a.m[2][1]) + (z * a.m[2][2]) + (w * a.m[2][3])); + w1 = ((x * a.m[3][0]) + (y * a.m[3][1]) + (z * a.m[3][2]) + (w * a.m[3][3])); + return Vertice(x1, y1, z1, w1, u, v); +} + +Vertice& Vertice::operator=(const Vector4f& a) +{ + x = a.x; + y = a.y; + z = a.z; + w = a.w; + return *this; +} + +Vertice Vertice::divideW() +{ + float rw = 1.0f / w; + return Vertice(x * rw, y * rw, (z * rw), rw, u * rw, v * rw); +} diff --git a/src/Vertice.h b/src/Vertice.h new file mode 100644 index 0000000..c4a591b --- /dev/null +++ b/src/Vertice.h @@ -0,0 +1,14 @@ +#include"Vector4f.h" +class Vertice : public Vector4f +{ +public: + float u, v; + Vertice(); + Vertice(float x_, float y_, float z_, float u_, float v_); + Vertice(float x_, float y_, float z_, float w_, float u_, float v_); + void screenspace(int screenWidth, int screenHeight); + Vertice multiplyMatrix(const Matrix4f& a); + Vertice& operator= (const Vector4f& a); + Vertice divideW(); +}; + diff --git a/src/main.cpp b/src/main.cpp new file mode 100644 index 0000000..94a8b30 --- /dev/null +++ b/src/main.cpp @@ -0,0 +1,83 @@ +#include + +#include +#include + +#include"Render.h" + +int main() +{ + float width, height; + float fov; + std::cout << "Enter window width and height.\n"; + std::cin >> width >> height; + std::cout << "Enter Field of View.\n"; + std::cin >> fov; + std::cout << "Loading...\n"; + + sf::RenderWindow window(sf::VideoMode(width, height), "C++ CPU Renderer", sf::Style::Titlebar | sf::Style::Close); + sf::Event event; + + window.setFramerateLimit(60); + + sf::Texture texture; + texture.create(width, height); + + sf::Sprite sprite(texture); + + sf::Clock clock; + sf::Time time; + + Render render(width, height); + + sf::Image image; + image.loadFromFile("model/modelTexture.png"); + Bitmap map(image.getSize().x, image.getSize().y); + const sf::Uint8* pp = image.getPixelsPtr(); + for (int i = 0; i < image.getSize().x * image.getSize().y * 4; i += 4) { + map.pixels[i + 0] = (unsigned char)pp[i + 0]; + map.pixels[i + 1] = (unsigned char)pp[i + 1]; + map.pixels[i + 2] = (unsigned char)pp[i + 2]; + map.pixels[i + 3] = (unsigned char)pp[i + 3]; + } + + std::chrono::high_resolution_clock::time_point time1 = std::chrono::high_resolution_clock::now(); + ObjModel vehicle("model/model.obj"); + std::chrono::high_resolution_clock::time_point time2 = std::chrono::high_resolution_clock::now(); + std::chrono::duration speed = std::chrono::duration_cast>(time2 - time1); + std::cout << "Model loading time: " << speed.count() << "s\n"; + std::cout << "Vertice count: " << vehicle.vertices.size() << "\nNumber of normals: " << vehicle.normals.size() << "\nUV count: " << vehicle.uvcoo.size() << "\n"; + std::cout << "Number of faces: " << vehicle.faces.size() << "\n"; + + while (window.isOpen()) + { + while (window.pollEvent(event)) + if (event.type == sf::Event::Closed) + window.close(); + + time = clock.getElapsedTime(); + + Vertice a1, b1, c1, d1, e1, f1; + + Matrix4f move = Matrix4f::move(0.0f, -150.0f, 600.0f); + Matrix4f rotate = Matrix4f::rotate(0.0f, time.asSeconds() * 25.0f, 0.0f); + Matrix4f scale = Matrix4f::scale(1.0f, 1.0f, 1.0f); + Matrix4f project = Matrix4f::perspective(1.0f, 10000.0f, fov, width / height); + Matrix4f end_matrix = project * move * rotate * scale; + + ObjModel vehicle2 = vehicle.multiplyMatrix(end_matrix); + vehicle2.divideW(); + vehicle2.screenspace(width, height); + + + render.fill(255, 255, 255); + render.resetZBuf(); + render.renderModel(vehicle2, map); + + texture.update((sf::Uint8*)render.pixels); + window.draw(sprite); + window.display(); + } + + return 0; +} -- cgit v1.2.3