Software/Hardware Rasterizer

Elite::RGBColor Elite::Renderer::PixelShading(const HitRecord& hitRecord, const MaterialManager& materialManager, const std::vector<Light*>& pLights, const KeyBindInfo& keyBindInfo)
{
	//Coloring in the returned result
	RGBColor finalColor{};
	if (keyBindInfo.UseDepthBufferAsColor)
	{
		//Use depth as gradient for color
		float depthColor = Elite::Remap(hitRecord.InterpolatedZ, 0.985f, 1.f);
		finalColor = { depthColor, depthColor, depthColor };
	}
	else
	{
		//If not using material, then use the color defined in the triangle
		if (keyBindInfo.UseMaterial)
		{
			//Get sampled texture color from texture matching the triangle
			Material* pMat = materialManager.GetMaterialByID(hitRecord.MatID);
			if (!pMat)
				return RGBColor(0, 0, 0);

			//------ Diffuse ------
			Elite::RGBColor diffuse{};
			float diffuseReflectance = pMat->GetDiffuseReflectance();
			if (pMat->UseDiffuseMap())
			{
				diffuse = pMat->GetDiffuseTexture()->Sample(hitRecord.InterpolatedUV) * diffuseReflectance;
			}
			else
			{
				diffuse = pMat->GetDiffuseColor() * diffuseReflectance;
			}

			//------ Normal ------
			FVector3 newNormal{};
			if (pMat->UseNormalMap())
			{
				//We define our tangent space
				FVector3 binormal = Cross(hitRecord.InterpolatedTangent, hitRecord.InterpolatedVertexNormal);
				FMatrix3 localTangentSpace = FMatrix3(hitRecord.InterpolatedTangent, binormal, hitRecord.InterpolatedVertexNormal);

				//Sample normal map
				Elite::RGBColor normalSample = pMat->GetNormalTexture()->Sample(hitRecord.InterpolatedUV);

				//An RBG Color goes from [0, 255] range, while we will need this in [-1, 1]
				//Sampled value is already returned in range [0, 1]
				normalSample = (normalSample * 2.f) - RGBColor(1.f, 1.f, 1.f);

				//Transform to tangent space
				newNormal = GetNormalized(localTangentSpace * FVector3(normalSample.r, normalSample.g, normalSample.b));
			}
			else
			{
				//This value is already normalized
				newNormal = hitRecord.InterpolatedVertexNormal;
			}

			//Data to store information while contributing every light
			for (Light* pLight : pLights)
			{
				//------ Irradiance ------
				Elite::RGBColor irradiance = pLight->GetCalculatedIrradianceColor(newNormal, true);

				//Decide what BRDF to use:
				Material::MaterialWorkflow workflow{ pMat->GetMaterialWorkflow() };
				if (workflow == Material::MaterialWorkflow::SpecGloss)
				{
					//------ Phong BRDF ------
					//------ Specular ------
					//Color
					RGBColor specColor{};
					if (pMat->UseSpecularMap())
					{
						specColor = pMat->GetSpecularTexture()->Sample(hitRecord.InterpolatedUV);
					}
					else
					{
						specColor = pMat->GetSpecularColor();
					}

					//Shininess
					float shininess = pMat->GetShininess();
					if (pMat->UseGlossinessMap())
					{
						shininess *= pMat->GetGlossinessTexture()->Sample(hitRecord.InterpolatedUV).r;
					}

					//Reflectance
					float specReflectance = pMat->GetSpecularReflectance();

					//Because of lightDir being initialized for a LHS in DX, we have to invert Z to get same effect
					FVector3 lightDir = pLight->GetDirection(hitRecord, true);
					RGBColor specularReflect = BRDF::Phong(specReflectance, shininess, -lightDir, hitRecord.ViewDirection, newNormal);
					Elite::RGBColor phongSpecular = specColor * specularReflect;

					//Adding up contribution
					finalColor += irradiance * (diffuse / float(E_PI)) + phongSpecular;
					
				}
				else if (workflow == Material::MaterialWorkflow::MetalRough)
				{
					//------ Lambert Cook-Torrance BRDF ------
					//Because of lightDir being initialized for a LHS in DX, we have to invert Z to get same effec
					FVector3 lightDir = pLight->GetDirection(hitRecord, true);

					//------ Roughness ------
					float roughness = 0.6f;
					if (pMat->UseRoughnessMap())
					{
						roughness = pMat->GetRoughnessTexture()->Sample(hitRecord.InterpolatedUV).r;
					}

					//------ Metallic ------
					int metallic = 0;
					if (pMat->UseMetalnessMap())
					{
						float metalSample = pMat->GetMetalnessTexture()->Sample(hitRecord.InterpolatedUV).r;
						if (metalSample > 0.5f)
							metallic = 1;
						else if (metalSample < 0.5f)
							metallic = 0;
					}

					//LambertCookTorrance BRDF
					RGBColor lamertCookTorranceBRDF = BRDF::LambertCookTorrance(diffuse, metallic, roughness, -lightDir, hitRecord.ViewDirection, newNormal);

					//Adding up contribution
					finalColor += irradiance * lamertCookTorranceBRDF;
				}
			}
		}
		else
		{
			finalColor = hitRecord.InterpolatedColor;
		}
	}

	//Call max to one on color overflow
	if (finalColor.r > 1.f || finalColor.g > 1.f || finalColor.b > 1.f)
		finalColor.MaxToOne();

	return finalColor;
}