aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/Bitmap.cpp34
-rw-r--r--src/Bitmap.h12
-rw-r--r--src/Matrix4f.cpp104
-rw-r--r--src/Matrix4f.h15
-rw-r--r--src/ObjModel.cpp93
-rw-r--r--src/ObjModel.h31
-rw-r--r--src/Render.cpp98
-rw-r--r--src/Render.h13
-rw-r--r--src/Vector4f.cpp32
-rw-r--r--src/Vector4f.h12
-rw-r--r--src/Vertice.cpp46
-rw-r--r--src/Vertice.h14
-rw-r--r--src/main.cpp83
13 files changed, 587 insertions, 0 deletions
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<iostream>
+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<math.h>
+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<vector>
+#include<string>
+#include<sstream>
+#include<fstream>
+#include<exception>
+
+struct Triangle {
+ int p[3][3];
+};
+
+struct Texture_Coordinates {
+ float u, v;
+};
+
+class ObjModel
+{
+public:
+ std::vector<Vertice> vertices;
+ std::vector<Texture_Coordinates> uvcoo;
+ std::vector<Vector4f> normals;
+ std::vector<Triangle> 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 <limits>
+
+#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<float>::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<float>::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<chrono>
+
+#include<SFML/Window.hpp>
+#include<SFML/Graphics.hpp>
+
+#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<double> speed = std::chrono::duration_cast<std::chrono::duration<double>>(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;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-22 05:02:56 +0000