SigRenderer3/main.cpp

#define OLC_PGE_APPLICATION
#include "pixelGameEngine.h"
#include <strstream>
#include <algorithm>

using namespace olc;

struct vec2d
{
	float u,v;
};


struct vec3d
{
	float x, y, z;
};

struct triangle
{
	vec3d p[3];
	vec2d uv[3];
	Pixel col;
};

struct mesh
{
	std::vector<triangle> tris;

	bool LoadFromObjectFile(std::string sFilename)
	{
		std::ifstream f(sFilename);
		if (!f.is_open())
			return false;

		// Local cache of verts
		std::vector<vec3d> verts;
		std::vector<vec2d> uvs;

		while (!f.eof())
		{
			char line[128];
			f.getline(line, 128);

			std::strstream s;
			s << line;

			char junk;

			if (line[0] == 'v')
			{
				if (line[1]=='t') {
					vec2d v;
					s >> junk >> junk >> v.u >> v.v;
					uvs.push_back(v);
					//std::cout<<"Line: "<<line<<"\n";
					//std::cout<<"Tex coords: "<<v.u<<","<<v.v<<"\n";
				} else
				if (line[1] != 'n')
				{
					vec3d v;
					s >> junk >> v.x >> v.y >> v.z;
					verts.push_back(v);
					//std::cout<<"Line: "<<line<<"\n";
					//std::cout<<"Vertex: "<<v.x<<","<<v.y<<","<<v.z<<"\n";
				}
			}
			if (line[0] == 'f')
				{
					s >> junk;

					std::string tokens[9];
					int nTokenCount = -1;


					while (!s.eof())
					{
						char c = s.get();
						if (c == ' ' || c == '/')
							nTokenCount++;
						else
							tokens[nTokenCount].append(1, c);
					}

					tokens[nTokenCount].pop_back();

					tris.push_back({ verts[stoi(tokens[0]) - 1], verts[stoi(tokens[3]) - 1], verts[stoi(tokens[6]) - 1],
					0,0,0
					/*uvs[stoi(tokens[1]) - 1], uvs[stoi(tokens[4]) - 1], uvs[stoi(tokens[7]) - 1]*/});
				}
		}

		return true;
	}

};

struct mat4x4
{
	float m[4][4] = { 0 };
};

class olcEngine3D : public PixelGameEngine
{

public:

	Decal*texture;
	olcEngine3D()
	{
		sAppName = "3D Demo";
	}


private:
	mesh meshCube;
	mat4x4 matProj;

	vec3d vCamera={0,0,0};

	float zOffset=2;

	float fTheta=0;

	void MultiplyMatrixVector(vec3d &i, vec3d &o, mat4x4 &m)
	{
		o.x = i.x * m.m[0][0] + i.y * m.m[1][0] + i.z * m.m[2][0] + m.m[3][0];
		o.y = i.x * m.m[0][1] + i.y * m.m[1][1] + i.z * m.m[2][1] + m.m[3][1];
		o.z = i.x * m.m[0][2] + i.y * m.m[1][2] + i.z * m.m[2][2] + m.m[3][2];
		float w = i.x * m.m[0][3] + i.y * m.m[1][3] + i.z * m.m[2][3] + m.m[3][3];

		if (w != 0.0f)
		{
			o.x /= w; o.y /= w; o.z /= w;
		}
	}

public:
	bool OnUserCreate() override
	{
		texture = new Decal(new Sprite("Body.png"));
		meshCube.LoadFromObjectFile("Nia.obj");

		// Projection Matrix
		float fNear = 0.1f;
		float fFar = 1000.0f;
		float fFov = 90.0f;
		float fAspectRatio = (float)ScreenHeight() / (float)ScreenWidth();
		float fFovRad = 1.0f / tanf(fFov * 0.5f / 180.0f * 3.14159f);

		matProj.m[0][0] = fAspectRatio * fFovRad;
		matProj.m[1][1] = fFovRad;
		matProj.m[2][2] = fFar / (fFar - fNear);
		matProj.m[3][2] = (-fFar * fNear) / (fFar - fNear);
		matProj.m[2][3] = 1.0f;
		matProj.m[3][3] = 0.0f;

		return true;
	}

	bool OnUserUpdate(float fElapsedTime) override
	{
		if (GetKey(olc::DOWN).bHeld) {
			zOffset-=1*fElapsedTime;
		}
		if (GetKey(olc::UP).bHeld) {
			zOffset+=1*fElapsedTime;
		}
		if (GetKey(olc::RIGHT).bHeld) {
			fTheta-=1*fElapsedTime;
		}
		if (GetKey(olc::LEFT).bHeld) {
			fTheta+=1*fElapsedTime;
		}

		// Set up rotation matrices
		mat4x4 matRotZ, matRotX;

		// Rotation Z
		matRotZ.m[0][0] = cosf(fTheta);
		matRotZ.m[0][1] = sinf(fTheta);
		matRotZ.m[1][0] = -sinf(fTheta);
		matRotZ.m[1][1] = cosf(fTheta);
		matRotZ.m[2][2] = 1;
		matRotZ.m[3][3] = 1;

		// Rotation X
		matRotX.m[0][0] = 1;
		matRotX.m[1][1] = cosf(fTheta * 0.5f);
		matRotX.m[1][2] = sinf(fTheta * 0.5f);
		matRotX.m[2][1] = -sinf(fTheta * 0.5f);
		matRotX.m[2][2] = cosf(fTheta * 0.5f);
		matRotX.m[3][3] = 1;

		std::vector<triangle>vecTrianglesToRaster;

		// Draw Triangles
		for (auto&tri : meshCube.tris)
		{
			triangle triProjected, triTranslated, triRotatedZ, triRotatedZX;

			// Rotate in Z-Axis
			MultiplyMatrixVector(tri.p[0], triRotatedZ.p[0], matRotZ);
			MultiplyMatrixVector(tri.p[1], triRotatedZ.p[1], matRotZ);
			MultiplyMatrixVector(tri.p[2], triRotatedZ.p[2], matRotZ);

			// Rotate in X-Axis
			MultiplyMatrixVector(triRotatedZ.p[0], triRotatedZX.p[0], matRotX);
			MultiplyMatrixVector(triRotatedZ.p[1], triRotatedZX.p[1], matRotX);
			MultiplyMatrixVector(triRotatedZ.p[2], triRotatedZX.p[2], matRotX);

			// Offset into the screen
			triTranslated = triRotatedZX;
			triTranslated.p[0].z = triRotatedZX.p[0].z + zOffset;
			triTranslated.p[1].z = triRotatedZX.p[1].z + zOffset;
			triTranslated.p[2].z = triRotatedZX.p[2].z + zOffset;

			vec3d normal,line1,line2;
			line1.x=triTranslated.p[1].x-triTranslated.p[0].x;
			line1.y=triTranslated.p[1].y-triTranslated.p[0].y;
			line1.z=triTranslated.p[1].z-triTranslated.p[0].z;
			line2.x=triTranslated.p[2].x-triTranslated.p[0].x;
			line2.y=triTranslated.p[2].y-triTranslated.p[0].y;
			line2.z=triTranslated.p[2].z-triTranslated.p[0].z;

			normal.x=line1.y*line2.z-line1.z*line2.y;
			normal.y=line1.z*line2.x-line1.x*line2.z;
			normal.z=line1.x*line2.y-line1.y*line2.x;

			float l = sqrtf(normal.x*normal.x+normal.y*normal.y+normal.z*normal.z);
			normal.x/=l;normal.y/=l;normal.z/=l;

			if (normal.x*(triTranslated.p[0].x-vCamera.x)+
				normal.y*(triTranslated.p[0].y-vCamera.y)+
				normal.z*(triTranslated.p[0].z-vCamera.z)<0) {

				vec3d light_dir = {0,0,-1};
				float l = sqrtf(light_dir.x*light_dir.x+light_dir.y*light_dir.y+light_dir.z*light_dir.z);
				light_dir.x/=l;light_dir.y/=l;light_dir.z/=l;

				float dp = normal.x*(light_dir.x-vCamera.x)+
					normal.y*(light_dir.y-vCamera.y)+
					normal.z*(light_dir.z-vCamera.z);


				// Project triangles from 3D --> 2D
				MultiplyMatrixVector(triTranslated.p[0], triProjected.p[0], matProj);
				MultiplyMatrixVector(triTranslated.p[1], triProjected.p[1], matProj);
				MultiplyMatrixVector(triTranslated.p[2], triProjected.p[2], matProj);

				// Scale into view
				triProjected.p[0].x += 1.0f; triProjected.p[0].y += 1.0f;
				triProjected.p[1].x += 1.0f; triProjected.p[1].y += 1.0f;
				triProjected.p[2].x += 1.0f; triProjected.p[2].y += 1.0f;
				triProjected.p[0].x *= 0.5f * (float)ScreenWidth();
				triProjected.p[0].y *= 0.5f * (float)ScreenHeight();
				triProjected.p[1].x *= 0.5f * (float)ScreenWidth();
				triProjected.p[1].y *= 0.5f * (float)ScreenHeight();
				triProjected.p[2].x *= 0.5f * (float)ScreenWidth();
				triProjected.p[2].y *= 0.5f * (float)ScreenHeight();
				triProjected.col=Pixel(255*dp*dp,255*dp*dp,255*dp*dp);

				vecTrianglesToRaster.push_back(triProjected);

			}
		}

		std::sort(vecTrianglesToRaster.begin(),vecTrianglesToRaster.end(),[](triangle&t1,triangle&t2){return (t1.p[0].z+t1.p[1].z+t1.p[2].z)/3.0f>(t2.p[0].z+t2.p[1].z+t2.p[2].z)/3.0f;});

		for (auto&triProjected:vecTrianglesToRaster) {

			// Rasterize triangle
			SetDecalStructure(DecalStructure::LIST);
			SetDecalMode(DecalMode::NORMAL);
			DrawPolygonDecal(nullptr,{
				{triProjected.p[0].x, triProjected.p[0].y},
				{triProjected.p[1].x, triProjected.p[1].y},
				{triProjected.p[2].x, triProjected.p[2].y}
			},{
				{triProjected.uv[0].u,triProjected.uv[0].v},
				{triProjected.uv[1].u,triProjected.uv[1].v},
				{triProjected.uv[2].u,triProjected.uv[2].v},
			},triProjected.col);
			/*SetDecalMode(DecalMode::WIREFRAME);
			DrawPolygonDecal(nullptr,{
				{triProjected.p[0].x, triProjected.p[0].y},
				{triProjected.p[1].x, triProjected.p[1].y},
				{triProjected.p[2].x, triProjected.p[2].y}
			},{
				{0,0},
				{0,0},
				{0,0},
			},BLACK);*/
			SetDecalStructure(DecalStructure::FAN);
		}

		SetDecalMode(DecalMode::NORMAL);
		DrawStringDecal({0,0},"Triangles: "+std::to_string(meshCube.tris.size()));


		return true;
	}

};




int main()
{
	olcEngine3D demo;
	if (demo.Construct(1280, 720, 1, 1))
		demo.Start();
    return 0;
}