Rendering-Engine/rasterizer.h at master · alexjcarolan/Rendering-Engine · GitHub

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
#ifndef RAZTERIZER_H
#define RAZTERIZER_H
#include "camera.h"

using namespace std;
using namespace glm;

CanvasPoint projectPoint(vec3 point);
CanvasTriangle projectTriangle(ModelTriangle tri);
std::vector<CanvasPoint> calculateLine(CanvasPoint start, CanvasPoint end);
void drawLine(CanvasPoint start, CanvasPoint end, Colour colour);
void drawStrokedTriangle(CanvasTriangle tri);
void drawFilledTriangle(CanvasTriangle tri);
void drawFrame(OBJ obj);
void drawRaster(OBJ obj);
void drawTexture(PPM ppm);

CanvasPoint projectPoint(vec3 point)
{
	point = (point - cameraPosition) * cameraRotation;
	return CanvasPoint((point.x / -point.z) * FOCAL_LENGTH + w, (point.y / point.z) * FOCAL_LENGTH + h, 1 / point.z);
}

CanvasTriangle projectTriangle(ModelTriangle tri)
{
	return CanvasTriangle(projectPoint(tri.vertices[0]), projectPoint(tri.vertices[1]), projectPoint(tri.vertices[2]), Colour(tri.mtl.Kd));
}

std::vector<CanvasPoint> calculateLine(CanvasPoint start, CanvasPoint end)
{
	std::vector<CanvasPoint> points;
	float xDiff = end.x - start.x;
	float yDiff = end.y - start.y;
	float zDiff = end.depth - start.depth;
	float numberOfSteps = std::max((std::max(abs(xDiff), abs(yDiff))), abs(zDiff));
	float xStepSize = xDiff / numberOfSteps;
	float yStepSize = yDiff / numberOfSteps;
	float zStepSize = zDiff / numberOfSteps;
	for (float i = 0.0; i < numberOfSteps; i++)
	{
		float z = start.depth + (zStepSize * i);
		float x = round(start.x + (xStepSize * i));
		float y = round(start.y + (yStepSize * i));
		points.push_back(CanvasPoint(x, y, z));
	}

	return points;
}

void drawLine(CanvasPoint start, CanvasPoint end, Colour colour)
{
	std::vector<CanvasPoint> points = calculateLine(start, end);
	for (uint i = 0; i < points.size(); i++)
	{
		window.setPixelColour(points[i].x, points[i].y, points[i].depth, colour.pack());
	}
}

void drawStrokedTriangle(CanvasTriangle tri)
{
	drawLine(tri.vertices[0], tri.vertices[1], tri.colour);
	drawLine(tri.vertices[1], tri.vertices[2], tri.colour);
	drawLine(tri.vertices[2], tri.vertices[0], tri.colour);
}

void drawFilledTriangle(CanvasTriangle tri)
{
	if (tri.vertices[1].y < tri.vertices[0].y)
	{
		swap(tri.vertices[0], tri.vertices[1]);
	}
	if (tri.vertices[2].y < tri.vertices[1].y)
	{
		swap(tri.vertices[2], tri.vertices[1]);
	}
	if (tri.vertices[1].y < tri.vertices[0].y)
	{
		swap(tri.vertices[0], tri.vertices[1]);
	}
	std::vector<vector<CanvasPoint>> lines;
	lines.push_back(calculateLine(tri.vertices[0], tri.vertices[2]));
	lines.push_back(calculateLine(tri.vertices[0], tri.vertices[1]));
	lines.push_back(calculateLine(tri.vertices[1], tri.vertices[2]));

	drawStrokedTriangle(tri);
	uint d = 0;
	for (uint i = 1; i < 3; i++)
	{
		for (uint j = 0; j < lines[i].size(); j++)
		{
			while (lines[0][d].y != lines[i][j].y && d != (lines[0].size() - 1))
			{
				if (lines[0][d].y > lines[i][j].y)
				{
					d--;
				}
				else if (lines[0][d].y < lines[i][j].y)
				{
					d++;
				}
			}
			if (j == 0)
			{
				drawLine(lines[i][j], lines[0][d], tri.colour);
			}
			else if (lines[i][j].y != lines[i][j - 1].y)
			{
				drawLine(lines[i][j], lines[0][d], tri.colour);
			}
		}
	}
}

void drawFrame(OBJ obj)
{
	for (uint i = 0; i < obj.faces.size(); i++)
	{
		drawStrokedTriangle(projectTriangle(obj.faces.at(i)));
	}
}

void drawRaster(OBJ obj)
{
	for (uint i = 0; i < obj.faces.size(); i++)
	{
		drawFilledTriangle(projectTriangle(obj.faces.at(i)));
	}
}

void drawTexture(PPM ppm)
{
	for (int i = 0; i < ppm.height; i++)
	{
		for (int j = 0; j < ppm.width; j++)
		{
			window.setPixelColour(j, i, 0, ppm.image[i][j]);
		}
	}
}
#endif