Set light to uniforms

include/Render/RenderMisc.h

@@ -54,12 +54,19 @@ namespace SE
 	{
 		std::vector<vec3> PositionData;
 		std::vector<vec2> TexCoordData;
+		std::vector<vec3> NormalData;
+		std::vector<vec3> TangentData;
+		std::vector<vec3> BitangentData;
 
 		std::shared_ptr<VAOHolder> vao;
 		std::shared_ptr<VBOHolder> positionVBO;
 		std::shared_ptr<VBOHolder> texCoordVBO;
-
+		std::shared_ptr<VBOHolder> normalVBO;
+		std::shared_ptr<VBOHolder> tangentVBO;
+		std::shared_ptr<VBOHolder> bitangentVBO;
 		void RefreshVBO();
+
+		void CalcTangentBitangent();
 	};
 
 struct T2DQuad

include/Render/SalmonRender/SalmonRenderInterface.h

@@ -37,6 +37,7 @@ protected:
 	float FogEndDistance;
 	vec4 FogColor;
 
+	vec3 lightPos;
 
 	void CalcCamPosVec();
 
@@ -101,6 +102,8 @@ public:
 	void SetFogBeginDistance(float distance);
 	void SetFogEndDistance(float distance);
 
+	void SetLightPos(vec3 newLightPos);
+	
 };
 
 } //namespace SE

src/ModelManager/ModelManager.cpp

@@ -119,6 +119,9 @@ bool TLiteModel::LoadModel(const std::string& s)
 
 	vertexDataStruct.PositionData = res.VertexArr;
 	vertexDataStruct.TexCoordData = res.TexCoordArr;
+	vertexDataStruct.NormalData = res.NormalArr;
+
+	vertexDataStruct.CalcTangentBitangent();
 
 	vertexDataStruct.RefreshVBO();
 	/*
@@ -237,12 +240,20 @@ void TLiteModel::DrawVBO()
 
 	EnableVertexAttribArray("vPosition");
 	EnableVertexAttribArray("vTexCoord");
+	EnableVertexAttribArray("vNormal");
+	EnableVertexAttribArray("vTangent");
+	EnableVertexAttribArray("vBitangent");
 
 	//Renderer->DrawTriangleList(TriangleList);
 	DrawVertexDataStruct(vertexDataStruct);
 
-	DisableVertexAttribArray("vPosition");
+	DisableVertexAttribArray("vBitangent");
+	DisableVertexAttribArray("vTangent");
+	DisableVertexAttribArray("vNormal");
 	DisableVertexAttribArray("vTexCoord");
+	DisableVertexAttribArray("vPosition");
+
+
 
 	RenderUniform1i(CONST_STRING_NORMALMAPEXISTS_UNIFORM, 1);
 
@@ -250,8 +261,6 @@ void TLiteModel::DrawVBO()
 }
 
 
-
-
 void TLiteModel::MoveModel(const vec3& v)
 {
 	for (cardinal i = 0; i < TriangleCount * 3; i++)
@@ -267,6 +276,9 @@ void TLiteModel::RotateModel(const mat3& r)
 	for (cardinal i = 0; i < TriangleCount * 3; i++)
 	{
 		vertexDataStruct.PositionData[i] = r * vertexDataStruct.PositionData[i];
+		vertexDataStruct.NormalData[i] = r * vertexDataStruct.NormalData[i];
+		vertexDataStruct.TangentData[i] = r * vertexDataStruct.TangentData[i];
+		vertexDataStruct.BitangentData[i] = r * vertexDataStruct.BitangentData[i];
 		//TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB][i] = r * TriangleList.Data.Vec3CoordArr[CONST_STRING_POSITION_ATTRIB][i];
 		//TriangleList.Data.Vec3CoordArr[CONST_STRING_NORMAL_ATTRIB][i] = r * TriangleList.Data.Vec3CoordArr[CONST_STRING_NORMAL_ATTRIB][i];
 		//TriangleList.Data.Vec3CoordArr[CONST_STRING_TANGENT_ATTRIB][i] = r * TriangleList.Data.Vec3CoordArr[CONST_STRING_TANGENT_ATTRIB][i];

src/Render/RenderMisc.cpp

@@ -66,17 +66,115 @@ namespace SE
 
 		glBufferData(GL_ARRAY_BUFFER, TexCoordData.size() * 8, &TexCoordData[0], GL_STATIC_DRAW);
 
+		if (NormalData.size() > 0)
+		{
+			if (!normalVBO)
+			{
+				normalVBO = std::make_shared<VBOHolder>();
+			}
+
+			glBindBuffer(GL_ARRAY_BUFFER, normalVBO->getBuffer());
+
+			glBufferData(GL_ARRAY_BUFFER, NormalData.size() * 12, &NormalData[0], GL_STATIC_DRAW);
+
+		}
+
+		if (TangentData.size() > 0)
+		{
+			if (!tangentVBO)
+			{
+				tangentVBO = std::make_shared<VBOHolder>();
+			}
+
+			glBindBuffer(GL_ARRAY_BUFFER, tangentVBO->getBuffer());
+
+			glBufferData(GL_ARRAY_BUFFER, TangentData.size() * 12, &TangentData[0], GL_STATIC_DRAW);
+
+		}
+
+		if (BitangentData.size() > 0)
+		{
+			if (!bitangentVBO)
+			{
+				bitangentVBO = std::make_shared<VBOHolder>();
+			}
+
+			glBindBuffer(GL_ARRAY_BUFFER, bitangentVBO->getBuffer());
+
+			glBufferData(GL_ARRAY_BUFFER, BitangentData.size() * 12, &BitangentData[0], GL_STATIC_DRAW);
+
+		}
+
+	}
+
+	void VertexDataStruct::CalcTangentBitangent()
+	{
+		TangentData.clear();
+		BitangentData.clear();
+
+		for (int i = 0; i < PositionData.size() / 3; i++)
+		{
+			vec3 v0 = PositionData[i * 3];
+			vec3 v1 = PositionData[i * 3 + 1];
+			vec3 v2 = PositionData[i * 3 + 2];
+
+			vec2 t0 = TexCoordData[i * 3];
+			vec2 t1 = TexCoordData[i * 3 + 1];
+			vec2 t2 = TexCoordData[i * 3 + 2];
+
+			vec3 deltaPos1 = v1 - v0;
+			vec3 deltaPos2 = v2 - v0;
+			vec2 deltaUV1 = t1 - t0;
+			vec2 deltaUV2 = t2 - t0;
+
+			float r = 1.0f / (deltaUV1.v[0] * deltaUV2.v[1] - deltaUV1.v[1] * deltaUV2.v[0]);
+
+			vec3 tangent = (deltaPos1 * deltaUV2.v[1] - deltaPos2 * deltaUV1.v[1]) * r;
+			vec3 bitangent = (deltaPos2 * deltaUV1.v[0] - deltaPos1 * deltaUV2.v[0]) * r;
+
+			TangentData.push_back(tangent);
+			TangentData.push_back(tangent);
+			TangentData.push_back(tangent);
+
+			BitangentData.push_back(bitangent);
+			BitangentData.push_back(bitangent);
+			BitangentData.push_back(bitangent);
+
+		}
+
+		RefreshVBO();
 	}
 
 	void DrawVertexDataStruct(const VertexDataStruct& vertexDataStruct)
 	{
 		static const std::string vTexCoord("vTexCoord");
 		static const std::string vPosition("vPosition");
+		static const std::string vNormal("vNormal");
+		static const std::string vTangent("vTangent");
+		static const std::string vBitangent("vBitangent");
 
 		//Check if main thread, check if data is not empty...
 		glBindBuffer(GL_ARRAY_BUFFER, vertexDataStruct.texCoordVBO->getBuffer());
 		VertexAttribPointer2fv(vTexCoord, 0, NULL);
 
+		if (vertexDataStruct.normalVBO)
+		{
+			glBindBuffer(GL_ARRAY_BUFFER, vertexDataStruct.normalVBO->getBuffer());
+			VertexAttribPointer3fv(vNormal, 0, NULL);
+		}
+
+		if (vertexDataStruct.tangentVBO)
+		{
+			glBindBuffer(GL_ARRAY_BUFFER, vertexDataStruct.tangentVBO->getBuffer());
+			VertexAttribPointer3fv(vTangent, 0, NULL);
+		}
+
+		if (vertexDataStruct.bitangentVBO)
+		{
+			glBindBuffer(GL_ARRAY_BUFFER, vertexDataStruct.bitangentVBO->getBuffer());
+			VertexAttribPointer3fv(vBitangent, 0, NULL);
+		}
+
 		glBindBuffer(GL_ARRAY_BUFFER, vertexDataStruct.positionVBO->getBuffer());
 		VertexAttribPointer3fv(vPosition, 0, NULL);
 

src/Render/SalmonRender/SalmonRenderInterface.cpp

@@ -64,6 +64,8 @@ void TSalmonRendererInterface::SetUniforms()
 
 	RenderUniform3fv(CONST_STRING_CAMPOS_UNIFORM, GetCamPos().v);
 
+	RenderUniform3fv("lightPos", lightPos.v);
+
 	ResourceManager->LightManager.SetLightUniforms();
 }
 
@@ -976,6 +978,11 @@ void TSalmonRendererInterface::SetFogEndDistance(float distance)
 	FogEndDistance = distance;
 }
 
+void TSalmonRendererInterface::SetLightPos(vec3 newLightPos)
+{
+	lightPos = newLightPos;
+}
+
 
 } //namespace SE
 

src/SimpleLand/SimpleLand.cpp

@@ -73,7 +73,7 @@ void TSimpleLandClass::CreateVBO()
 
 	vertexDataStruct.PositionData.clear();
 	vertexDataStruct.TexCoordData.clear();
-
+	vertexDataStruct.NormalData.clear();
 	for (i = 0; i < Height - 1; i++)
 	{
 		for (j = 0; j < Width - 1; j++)
@@ -98,6 +98,16 @@ void TSimpleLandClass::CreateVBO()
 			vertexDataStruct.PositionData.push_back(VertexMatrix[k_up].pos);
 			vertexDataStruct.PositionData.push_back(VertexMatrix[k_right].pos);
 
+
+			vertexDataStruct.NormalData.push_back(VertexMatrix[k].norm);
+			vertexDataStruct.NormalData.push_back(VertexMatrix[k_right].norm);
+			vertexDataStruct.NormalData.push_back(VertexMatrix[k_up].norm);
+
+
+			vertexDataStruct.NormalData.push_back(VertexMatrix[k_right_up].norm);
+			vertexDataStruct.NormalData.push_back(VertexMatrix[k_up].norm);
+			vertexDataStruct.NormalData.push_back(VertexMatrix[k_right].norm);
+
 			vertexDataStruct.TexCoordData.push_back({ tx0, ty0 });
 			vertexDataStruct.TexCoordData.push_back({ tx1, ty0 });
 			vertexDataStruct.TexCoordData.push_back({ tx0, ty1 });
@@ -361,7 +371,7 @@ bool TSimpleLandClass::LoadFromFile(const std::string& filename)
 
 	//Replace old matrices with new
 
-	TriangleMatrix.resize(2*(Width-1)*(Height-1));
+	TriangleMatrix.resize(2*(Width)*(Height));
 	VertexMatrix = tempVertexMatrix;
 	
 	UpdateTriangleMatrix();
@@ -556,12 +566,15 @@ void TSimpleLandClass::DrawVBO()
 
 	EnableVertexAttribArray("vPosition");
 	EnableVertexAttribArray("vTexCoord");
+	EnableVertexAttribArray("vNormal");
 
 	//Renderer->DrawTriangleList(TriangleList);
 	DrawVertexDataStruct(vertexDataStruct);
 
 	DisableVertexAttribArray("vPosition");
 	DisableVertexAttribArray("vTexCoord");
+	DisableVertexAttribArray("vNormal");
+
 
 
 	/*
@@ -876,6 +889,25 @@ void TSimpleLandClass::RecalcNormalVectors()
 {
 	int i,j,ifrom,ito,jfrom,jto;
 	vec3 v1,v2;
+	for (i = 1; i < Height-1; i++)
+	{
+		for (j = 1; j < Width-1; j++)
+		{
+			ifrom = i - 1;
+			ito = i + 1;
+
+			jfrom = j - 1;
+			jto = j + 1;
+
+			v1 = Normalize(VertexMatrix[j + ito * Width].pos - VertexMatrix[j + ifrom * Width].pos);
+
+			v2 = Normalize(VertexMatrix[jto + i * Width].pos - VertexMatrix[jfrom + i * Width].pos);
+
+			VertexMatrix[j+i*Width].norm = CrossProduct(v2, v1);
+		}
+	}
+
+	/*
 
 	for (i=0;i<Height;i++)
 		for (j=0;j<Width;j++)
@@ -894,7 +926,12 @@ void TSimpleLandClass::RecalcNormalVectors()
 			VertexMatrix[j+i*Width].tangent = v2;
 			VertexMatrix[j+i*Width].norm = CrossProduct(v2, v1);
 
+			if (VertexMatrix[j + i * Width].norm.v[1] < fabs(VertexMatrix[j + i * Width].norm.v[2]))
+			{
+				std::cout << "Wait..." << std::endl;
 			}
+
+		}*/
 }