GameLogic - Merged with graphics

Code/Game/DanBiasGame/GameClientState/GameState.cpp

@@ -69,7 +69,7 @@ bool GameState::LoadModels(std::wstring mapFile)
 	Oyster::Math3D::Float4x4 translate =  Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(-2,-2,-2));
 	modelData.world = modelData.world * translate;
 	modelData.visible = true;
-	modelData.modelPath = L"..\\Content\\worldDummy";
+	modelData.modelPath = L"..\\Content\\Models\\char_white.dan";
 	modelData.id = 0;
 	// load models
 	C_Object* obj =  new C_Player();
@@ -78,7 +78,7 @@ bool GameState::LoadModels(std::wstring mapFile)
 
 	translate =  Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(-2,2,2));
 	modelData.world = modelData.world * translate;
-	modelData.modelPath = L"..\\Content\\worldDummy";
+	modelData.modelPath = L"..\\Content\\Models\\char_white.dan";
 	modelData.id ++;
 
 	obj = new C_DynamicObj();
@@ -87,7 +87,7 @@ bool GameState::LoadModels(std::wstring mapFile)
 
 	translate =  Oyster::Math3D::TranslationMatrix(Oyster::Math::Float3(-2,-2,-2));
 	modelData.world = modelData.world * translate;
-	modelData.modelPath = L"..\\Content\\worldDummy";
+	modelData.modelPath = L"..\\Content\\Models\\char_white.dan";
 	modelData.id ++;
 
 	obj = new C_DynamicObj();

Code/Game/DanBiasGame/GameClientState/LobbyState.cpp

@@ -54,7 +54,7 @@ bool LobbyState::LoadModels(std::wstring file)
 
 	modelData.world = Oyster::Math3D::Float4x4::identity;
 	modelData.visible = true;
-	modelData.modelPath = L"..\\Content\\crate";
+	modelData.modelPath = L"..\\Content\\Models\\box_2.dan";
 	// load models
 	privData->object[0] = new C_StaticObj();
 	privData->object[0]->Init(modelData);

Code/OysterGraphics/Core/Buffer.cpp

@@ -215,3 +215,8 @@ UINT32 Core::Buffer::GetVertexSize()
 {
 	return this->mElementSize;
 }
+
+ID3D11Buffer* Core::Buffer::GetBufferPointer()
+{
+	return this->mBuffer;
+}

Code/OysterGraphics/Core/Core.h

@@ -7,7 +7,7 @@
 #include "Dx11Includes.h"
 #include <sstream>
 #include "OysterMath.h"
-#include <vld.h>
+//#include <vld.h>
 
 namespace Oyster
 {

Code/OysterGraphics/Core/Init.cpp

@@ -356,8 +356,8 @@ namespace Oyster
 		{
 			ID3D11Texture2D* tex;
 			D3D11_TEXTURE2D_DESC texDesc;
-			texDesc.Width = Core::resolution.x;
+			texDesc.Width = (UINT)Core::resolution.x;
-			texDesc.Height = Core::resolution.y;
+			texDesc.Height = (UINT)Core::resolution.y;
 			texDesc.MipLevels = 1;
 			texDesc.ArraySize = 1;
 			texDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;

Code/OysterGraphics/Core/PipelineManager.cpp

@@ -58,7 +58,7 @@ namespace Oyster
 						}
 						else
 						{
-							VSMap[name] = VS.size();
+							VSMap[name] = (int)VS.size();
 							VS.push_back((ID3D11VertexShader*)data);
 						}
 					}
@@ -76,7 +76,7 @@ namespace Oyster
 						}
 						else
 						{
-							HSMap[name] = HS.size();
+							HSMap[name] = (int)HS.size();
 							HS.push_back((ID3D11HullShader*)data);
 						}
 						
@@ -95,7 +95,7 @@ namespace Oyster
 						}
 						else
 						{
-							DSMap[name] = DS.size();
+							DSMap[name] = (int)DS.size();
 							DS.push_back((ID3D11DomainShader*)data);
 						}
 					}
@@ -113,7 +113,7 @@ namespace Oyster
 						}
 						else
 						{
-							GSMap[name] = GS.size();
+							GSMap[name] = (int)GS.size();
 							GS.push_back((ID3D11GeometryShader*)data);
 						}
 					}
@@ -131,7 +131,7 @@ namespace Oyster
 						}
 						else
 						{
-							PSMap[name] = PS.size();
+							PSMap[name] = (int)PS.size();
 							PS.push_back((ID3D11PixelShader*)data);
 						}
 					}
@@ -149,7 +149,7 @@ namespace Oyster
 						}
 						else
 						{
-							CSMap[name] = CS.size();
+							CSMap[name] = (int)CS.size();
 							CS.push_back((ID3D11ComputeShader*)data);
 						}
 						
@@ -347,19 +347,19 @@ namespace Oyster
 			Core::deviceContext->IASetPrimitiveTopology(se.IAStage.Topology);
 			if(se.CBuffers.Vertex.size())
 			{
-				deviceContext->VSSetConstantBuffers(0,se.CBuffers.Vertex.size(),&se.CBuffers.Vertex[0]);
+				deviceContext->VSSetConstantBuffers(0,(int)se.CBuffers.Vertex.size(),&se.CBuffers.Vertex[0]);
 			}
 			if(se.CBuffers.Pixel.size())
 			{
-				deviceContext->PSSetConstantBuffers(0,se.CBuffers.Pixel.size(),&se.CBuffers.Pixel[0]);
+				deviceContext->PSSetConstantBuffers(0,(int)se.CBuffers.Pixel.size(),&se.CBuffers.Pixel[0]);
 			}
 			if(se.CBuffers.Geometry.size())
 			{
-				deviceContext->GSSetConstantBuffers(0,se.CBuffers.Geometry.size(),&se.CBuffers.Geometry[0]);
+				deviceContext->GSSetConstantBuffers(0,(int)se.CBuffers.Geometry.size(),&se.CBuffers.Geometry[0]);
 			}
 			if(se.CBuffers.Compute.size())
 			{
-				deviceContext->CSSetConstantBuffers(0,se.CBuffers.Compute.size(),&se.CBuffers.Compute[0]);
+				deviceContext->CSSetConstantBuffers(0,(int)se.CBuffers.Compute.size(),&se.CBuffers.Compute[0]);
 			}
 			Core::deviceContext->RSSetState(se.RenderStates.Rasterizer);
 			Core::deviceContext->PSSetSamplers(0,se.RenderStates.SampleCount,se.RenderStates.SampleState);
@@ -369,43 +369,43 @@ namespace Oyster
 
 			if(se.SRV.Vertex.size())
 			{
-				Core::deviceContext->VSSetShaderResources(0,se.SRV.Vertex.size(),&se.SRV.Vertex[0]);
+				Core::deviceContext->VSSetShaderResources(0,(int)se.SRV.Vertex.size(),&se.SRV.Vertex[0]);
 			}
 			if(se.SRV.Geometry.size())
 			{
-				Core::deviceContext->GSSetShaderResources(0,se.SRV.Geometry.size(),&se.SRV.Geometry[0]);
+				Core::deviceContext->GSSetShaderResources(0,(int)se.SRV.Geometry.size(),&se.SRV.Geometry[0]);
 			}
 			if(se.SRV.Pixel.size())
 			{
-				Core::deviceContext->PSSetShaderResources(0,se.SRV.Pixel.size(),&se.SRV.Pixel[0]);
+				Core::deviceContext->PSSetShaderResources(0,(int)se.SRV.Pixel.size(),&se.SRV.Pixel[0]);
 			}
 			if(se.SRV.Compute.size())
 			{
-				Core::deviceContext->CSSetShaderResources(0,se.SRV.Compute.size(),&se.SRV.Compute[0]);
+				Core::deviceContext->CSSetShaderResources(0,(int)se.SRV.Compute.size(),&se.SRV.Compute[0]);
 			}
 
 			if(se.RTV.size())
 			{
 				if(se.UAV.Pixel.size())
 				{
-					deviceContext->OMSetRenderTargetsAndUnorderedAccessViews(se.RTV.size(),&se.RTV[0],se.depth,se.RTV.size(),se.UAV.Pixel.size(),&se.UAV.Pixel[0],0);
+					deviceContext->OMSetRenderTargetsAndUnorderedAccessViews((int)se.RTV.size(),&se.RTV[0],se.depth,(int)se.RTV.size(),(int)se.UAV.Pixel.size(),&se.UAV.Pixel[0],0);
 				}
 				else
 				{
-					deviceContext->OMSetRenderTargets(se.RTV.size(),&se.RTV[0],se.depth);
+					deviceContext->OMSetRenderTargets((int)se.RTV.size(),&se.RTV[0],se.depth);
 				}
 			}
 			else
 			{
 				if(se.UAV.Pixel.size())
 				{
-					deviceContext->OMSetRenderTargetsAndUnorderedAccessViews(0,NULL,se.depth,0,se.UAV.Pixel.size(),&se.UAV.Pixel[0],0);
+					deviceContext->OMSetRenderTargetsAndUnorderedAccessViews(0,NULL,se.depth,0,(int)se.UAV.Pixel.size(),&se.UAV.Pixel[0],0);
 				}
 			}
 
 			if(se.UAV.Compute.size())
 			{
-				deviceContext->CSSetUnorderedAccessViews(0,se.UAV.Compute.size(),&se.UAV.Compute[0],0);
+				deviceContext->CSSetUnorderedAccessViews(0,(int)se.UAV.Compute.size(),&se.UAV.Compute[0],0);
 			}
 		}
 

Code/OysterGraphics/DllInterfaces/GFXAPI.cpp

@@ -6,6 +6,7 @@
 #include "../FileLoader/ObjReader.h"
 #include "../../Misc/Resource/OysterResource.h"
 #include "../FileLoader/GeneralLoader.h"
+#include "../Model/ModelInfo.h"
 #include <vld.h>
 
 namespace Oyster
@@ -47,7 +48,7 @@ namespace Oyster
 		{
 			if(Lights.size())
 			{
-				Render::Rendering::Basic::NewFrame(View, Projection, &Lights[0], Lights.size());
+				Render::Rendering::Basic::NewFrame(View, Projection, &Lights[0], (int)Lights.size());
 			}
 			else
 			{
@@ -75,19 +76,29 @@ namespace Oyster
 			return API::Sucsess;
 		}
 
+		//returns null for invalid filenames
 		Model::Model* API::CreateModel(std::wstring filename)
 		{
 			Model::Model* m = new Model::Model();
 			m->WorldMatrix = Oyster::Math::Float4x4::identity;
 			m->Visible = true;
 
-			m->info = Oyster::Resource::OysterResource::LoadResource(filename.c_str(),Oyster::Graphics::Loading::LoadOBJ);
+			m->info = Oyster::Resource::OysterResource::LoadResource(filename.c_str(),Oyster::Graphics::Loading::LoadDAN);
+
+			Model::ModelInfo* mi = (Model::ModelInfo*)m->info;
+			if(!mi || mi->Vertices->GetBufferPointer() == NULL)
+			{
+				delete m;
+				return NULL;
+			}
 
 			return m;
 		}
 
 		void API::DeleteModel(Model::Model* model)
 		{
+			if(model==NULL)
+				return;
 			Model::ModelInfo* info = (Model::ModelInfo*)model->info;
 			delete model;
 			Oyster::Resource::OysterResource::ReleaseResource((Oyster::Resource::OHRESOURCE)info);

Code/OysterGraphics/DllInterfaces/GFXAPI.h

@@ -4,7 +4,7 @@
 #include "..\Model\Model.h"
 #include "OysterMath.h"
 #include <Windows.h>
-#include <vld.h>
+//#include <vld.h>
 
 #ifdef GFX_DLL_EXPORT
 	#define GFX_DLL_USAGE __declspec(dllexport)

Code/OysterGraphics/FileLoader/DanLoader.cpp

@@ -0,0 +1,307 @@
+#include "GeneralLoader.h"
+#include "../Definitions/GraphicalDefinition.h"
+#include "../Model/ModelInfo.h"
+#include "../Core/Core.h"
+#include <fstream>
+#include <string>
+
+#define DANFILEVERSIONMAJOR 1
+#define DANFILEVERSIONMINOR 1
+
+#define FILEHEADERSIZE		8
+#define VERTEXHEADERSIZE	4
+#define VERTEXSIZE			88
+
+
+
+/// 
+enum HeaderType
+{
+	VERTEXHEADER	= 0,	///< 
+	INDEXHEADER		= 1,	///<
+	MATERIALHEADER	= 2,	///<
+	SKELETONHEADER	= 3,	///<
+	ANIMATIONHEADER	= 4		///<
+};
+
+/// 
+struct FileHeader
+{
+	unsigned int versionMajor;	///< 
+	unsigned int versionMinor;	///< 
+
+	///
+	FileHeader(char* data)
+	{
+		char* memPos = data; //
+
+		memcpy(&versionMajor, memPos, sizeof(unsigned int));
+		memPos += 4;
+		memcpy(&versionMinor, memPos, sizeof(unsigned int));
+	}
+};
+
+///
+struct VertexHeader
+{
+	unsigned int numVertices;
+	
+	///
+	VertexHeader(char* data)
+	{
+		memcpy(&numVertices, data, sizeof(unsigned int));
+	}
+};
+
+///
+typedef Oyster::Graphics::Definitions::FinalVertex Vertex;
+
+///
+struct IndexHeader
+{
+	unsigned int numIndices;
+	
+	///
+	IndexHeader(char* data)
+	{
+		memcpy(&numIndices, data, sizeof(unsigned int));
+	}
+};
+
+///
+struct MaterialHeader
+{
+	unsigned int	diffuseMapPathLength;
+	char*			diffuseMapPath;
+
+	unsigned int	normalMapPathLength;
+	char*			normalMapPath;
+	/*
+	///
+	MaterialHeader(char* data)
+	{
+		char* memPos = data; //
+
+		memcpy(&diffuseMapPathLength, memPos, sizeof(unsigned int));
+		memPos += 4;
+
+		diffuseMapPath = new char[diffuseMapPathLength];
+		memcpy(diffuseMapPath, memPos, diffuseMapPathLength);
+		memPos += diffuseMapPathLength;
+
+		memcpy(&normalMapPathLength, memPos, sizeof(unsigned int));
+		memPos += 4;
+
+		normalMapPath = new char[normalMapPathLength];
+		memcpy(normalMapPath, memPos, normalMapPathLength);
+		memPos += normalMapPathLength;
+	}
+	*/
+};
+
+///
+struct SkeletonHeader
+{
+	// do this...
+};
+
+///
+struct AnimationHeader
+{
+	// do this...
+};
+
+struct Frame
+{
+	// do this...
+};
+
+///
+void Oyster::Graphics::Loading::UnloadDAN(void* data)
+{
+	Model::ModelInfo* info = (Model::ModelInfo*) data;
+	SAFE_DELETE(info->Vertices);
+	if(info->Indexed)
+	{
+		SAFE_DELETE(info->Indecies);
+	}
+	for(int i =0;i<info->Material.size();++i)
+	{
+		Oyster::Resource::OysterResource::ReleaseResource(info->Material[i]);
+	}
+	delete info;
+}
+
+static wchar_t* charToWChar(const char* text)
+{
+    // Convert to a wchar_t*
+    size_t origsize = strlen(text) + 1;
+    size_t convertedChars = 0;
+	wchar_t* wcstring = new wchar_t[origsize];
+    mbstowcs_s(&convertedChars, wcstring, origsize, text, _TRUNCATE);
+   return wcstring;
+}
+
+///
+void Oyster::Graphics::Loading::LoadDAN(const wchar_t filename[], Oyster::Resource::CustomData& out)
+{
+	// 
+	Oyster::Graphics::Model::ModelInfo* modelInfo = new Oyster::Graphics::Model::ModelInfo();
+	modelInfo->Indexed = false;
+	// Open file in binary mode
+	std::ifstream danFile;
+	danFile.open(filename, std::ios::binary);
+	if (!danFile.is_open())
+		return;
+
+	// Read file header
+	char* buffer = new char[sizeof(FileHeader)];
+	danFile.read(buffer, sizeof(FileHeader));
+	FileHeader fileHeader(buffer);
+	delete[] buffer; // ( note: may crash here.)
+
+	// If problem with compatability then close file and return from method
+	if (fileHeader.versionMajor != DANFILEVERSIONMAJOR)
+	{
+		danFile.close();
+		return;
+	}
+
+	// Read the .dan-file
+	while (!danFile.eof())
+	{
+		// read header type
+		unsigned int headerType;
+		buffer = new char[4];
+		danFile.read(buffer, 4);
+		memcpy(&headerType, buffer, 4);
+		//delete[] buffer; // ( note: may crash here.)
+
+		// handle header type
+		switch ((HeaderType)headerType)
+		{
+			// vertex header
+			case HeaderType::VERTEXHEADER:
+			{
+				// Fetch vertex header, number of vertices
+				buffer = new char[4];
+				danFile.read(buffer, 4);
+				VertexHeader vertexHeader(buffer);
+				delete[] buffer; // ( note: may crash here.)
+
+				// Fetch all vertices
+				Vertex* vertices = new Vertex[vertexHeader.numVertices];
+				unsigned int bufferSize = VERTEXSIZE * vertexHeader.numVertices;
+				buffer = new char[bufferSize];
+				danFile.read(buffer, bufferSize);
+				memcpy(vertices, buffer, bufferSize);
+				delete[] buffer; // ( note: may crash here.)
+
+				// Do the deed
+				Oyster::Graphics::Core::Buffer*						vertexBuffer = new Oyster::Graphics::Core::Buffer();
+				Oyster::Graphics::Core::Buffer::BUFFER_INIT_DESC	bufferInitDesc;
+				bufferInitDesc.ElementSize	= sizeof(Vertex);
+				bufferInitDesc.InitData		= vertices;
+				bufferInitDesc.NumElements	= vertexHeader.numVertices;
+				bufferInitDesc.Type			= Oyster::Graphics::Core::Buffer::BUFFER_TYPE::VERTEX_BUFFER;
+				bufferInitDesc.Usage		= Oyster::Graphics::Core::Buffer::BUFFER_USAGE::BUFFER_DEFAULT;
+				vertexBuffer->Init(bufferInitDesc);
+				modelInfo->VertexCount = vertexHeader.numVertices;
+				modelInfo->Vertices = vertexBuffer;
+
+				delete[] vertices; // ( note: may crash here.)
+
+				break;
+			}
+			case HeaderType::INDEXHEADER:
+			{
+				// Fetch vertex header, number of vertices
+				buffer = new char[4];
+				danFile.read(buffer, 4);
+				IndexHeader indexHeader(buffer);
+				delete[] buffer; // ( note: may crash here.)
+
+				// Fetch all indices
+				unsigned int* indices = new unsigned int[indexHeader.numIndices];
+				unsigned int bufferSize = sizeof(unsigned int) * indexHeader.numIndices;
+				buffer = new char[bufferSize];
+				danFile.read(buffer, bufferSize);
+				memcpy(indices, buffer, bufferSize);
+				delete[] buffer; // ( note: may crash here.)
+
+				// Do the deed
+				Oyster::Graphics::Core::Buffer*						indexBuffer = new Oyster::Graphics::Core::Buffer();
+				Oyster::Graphics::Core::Buffer::BUFFER_INIT_DESC	bufferInitDesc;
+				bufferInitDesc.ElementSize	= sizeof(unsigned int);
+				bufferInitDesc.InitData		= indices;
+				bufferInitDesc.NumElements	= indexHeader.numIndices;
+				bufferInitDesc.Type			= Oyster::Graphics::Core::Buffer::BUFFER_TYPE::INDEX_BUFFER;
+				bufferInitDesc.Usage		= Oyster::Graphics::Core::Buffer::BUFFER_USAGE::BUFFER_DEFAULT;
+				indexBuffer->Init(bufferInitDesc);
+				modelInfo->IndexCount = indexHeader.numIndices;
+				modelInfo->Indecies = indexBuffer;
+				modelInfo->Indexed = true;
+
+				delete[] indices; // ( note: may crash here.)
+
+				break;
+			}
+			// material header
+			case HeaderType::MATERIALHEADER:
+			{
+				// Fetch material header, 2 texture path strings
+				MaterialHeader materialHeader;
+				buffer = new char[4];
+				danFile.read(buffer, 4);
+				memcpy(&materialHeader.diffuseMapPathLength, buffer, 4);
+				delete[] buffer; // ( note: may crash here.)
+
+				buffer = new char[materialHeader.diffuseMapPathLength];
+				danFile.read(buffer, materialHeader.diffuseMapPathLength);
+				materialHeader.diffuseMapPath = new char[materialHeader.diffuseMapPathLength+1];
+				memcpy(materialHeader.diffuseMapPath, buffer, materialHeader.diffuseMapPathLength);
+				materialHeader.diffuseMapPath[materialHeader.diffuseMapPathLength] = 0;
+				delete[] buffer; // ( note: may crash here.)
+				
+				buffer = new char[4];
+				danFile.read(buffer, 4);
+				memcpy(&materialHeader.normalMapPathLength, buffer, 4);
+				delete[] buffer; // ( note: may crash here.)
+
+				buffer = new char[materialHeader.normalMapPathLength];
+				danFile.read(buffer, materialHeader.normalMapPathLength);
+				materialHeader.normalMapPath = new char[materialHeader.normalMapPathLength + 1];
+				memcpy(materialHeader.normalMapPath, buffer, materialHeader.normalMapPathLength);
+				materialHeader.normalMapPath[materialHeader.normalMapPathLength] = 0;
+				delete[] buffer; // ( note: may crash here.)
+
+				// 
+				ID3D11ShaderResourceView* diffuseMap = (ID3D11ShaderResourceView*)Oyster::Resource::OysterResource::LoadResource(charToWChar(materialHeader.diffuseMapPath), Oyster::Graphics::Loading::LoadTexture);
+				ID3D11ShaderResourceView* normalMap  = (ID3D11ShaderResourceView*)Oyster::Resource::OysterResource::LoadResource(charToWChar(materialHeader.normalMapPath),  Oyster::Graphics::Loading::LoadTexture);
+				modelInfo->Material.push_back(diffuseMap);
+				modelInfo->Material.push_back(normalMap);
+
+				break;
+			}
+			// skeleton header
+			case HeaderType::SKELETONHEADER:
+			{
+				// not implemented...
+				break;
+			}
+			// animation header
+			case HeaderType::ANIMATIONHEADER:
+			{
+				// not implemented...
+				break;
+			}
+		}
+	}
+
+	// close file
+	danFile.close();
+
+	// Set modelinfo as output data
+	out.loadedData = modelInfo;
+	out.resourceUnloadFnc = Oyster::Graphics::Loading::UnloadDAN;
+}

Code/OysterGraphics/FileLoader/GeneralLoader.h

@@ -29,6 +29,9 @@ namespace Oyster
 
 			void UnloadOBJ(void* loadedData);
 			void LoadOBJ(const wchar_t filename[], Oyster::Resource::CustomData& out);
+
+			void UnloadDAN(void* loadedData);
+			void LoadDAN(const wchar_t filename[], Oyster::Resource::CustomData& out);
 		}
 	}
 }

Code/OysterGraphics/FileLoader/ObjReader.cpp

@@ -230,7 +230,6 @@ std::map<std::string, ID3D11ShaderResourceView *> ObjReader::GetMaterials(std::w
 	input.open(fileName.c_str());
 
 	std::map<std::string, ID3D11ShaderResourceView *> materials;
-	ID3D11ShaderResourceView *srv;
 	string texture;
 	string s;
 	string path;

Code/OysterGraphics/Model/ModelInfo.h

@@ -16,7 +16,7 @@ namespace Oyster
 				std::vector<ID3D11ShaderResourceView*> Material;
 				Core::Buffer *Vertices,*Indecies;
 				bool Indexed;
-				int VertexCount;
+				int VertexCount, IndexCount;
 			};	
 		}
 	}

Code/OysterGraphics/OysterGraphics.vcxproj

@@ -176,6 +176,7 @@
     <ClCompile Include="Core\Init.cpp" />
     <ClCompile Include="Core\PipelineManager.cpp" />
     <ClCompile Include="DllInterfaces\GFXAPI.cpp" />
+    <ClCompile Include="FileLoader\DanLoader.cpp" />
     <ClCompile Include="FileLoader\ObjReader.cpp" />
     <ClCompile Include="FileLoader\ShaderLoader.cpp" />
     <ClCompile Include="FileLoader\ModelLoader.cpp" />

Code/OysterGraphics/Render/Rendering/BasicRender.cpp

@@ -50,6 +50,8 @@ namespace Oyster
 				{
 					for(int i = 0; i < count; ++i)
 					{
+						if(&models[i] == NULL)
+							continue;
 						if(models[i].Visible)
 						{
 							Definitions::PerModel pm;
@@ -65,7 +67,7 @@ namespace Oyster
 
 							if(info->Material.size())
 							{
-								Core::deviceContext->PSSetShaderResources(0,info->Material.size(),&(info->Material[0]));
+								Core::deviceContext->PSSetShaderResources(0,(UINT)info->Material.size(),&(info->Material[0]));
 							}
 
 
@@ -73,7 +75,7 @@ namespace Oyster
 							if(info->Indexed)
 							{
 								info->Indecies->Apply();
-								Oyster::Graphics::Core::deviceContext->DrawIndexed(info->VertexCount,0,0);
+								Oyster::Graphics::Core::deviceContext->DrawIndexed(info->IndexCount,0,0);
 							}
 							else
 							{
@@ -86,11 +88,11 @@ namespace Oyster
 				{
 					Core::PipelineManager::SetRenderPass(Resources::Deffered::LightPass);
 
-					Core::deviceContext->Dispatch((Core::resolution.x + 15U) / 16U,(Core::resolution.y + 15U) / 16U,1);
+					Core::deviceContext->Dispatch((UINT)((Core::resolution.x + 15U) / 16U), (UINT)((Core::resolution.y + 15U) / 16U), 1);
 
 					Core::PipelineManager::SetRenderPass(Resources::Deffered::PostPass);
 
-					Core::deviceContext->Dispatch((Core::resolution.x + 15U) / 16U,(Core::resolution.y + 15U) / 16U,1);
+					Core::deviceContext->Dispatch((UINT)((Core::resolution.x + 15U) / 16U), (UINT)((Core::resolution.y + 15U) / 16U), 1);
 
 					Core::swapChain->Present(0,0);
 				}

Code/OysterGraphics/Render/Resources/Deffered.cpp

@@ -92,7 +92,7 @@ namespace Oyster
 					D3D11_RASTERIZER_DESC rdesc;
 					rdesc.CullMode = D3D11_CULL_BACK;
 					rdesc.FillMode = D3D11_FILL_SOLID;
-					rdesc.FrontCounterClockwise = true;
+					rdesc.FrontCounterClockwise = false;
 					rdesc.DepthBias = 0;
 					rdesc.DepthBiasClamp = 0;
 					rdesc.DepthClipEnable = true;
@@ -155,7 +155,7 @@ namespace Oyster
 					Buffer* b = &PointLightsData;
 
 					Core::Init::CreateLinkedShaderResourceFromStructuredBuffer(&b,&PointLightView,NULL);
-					srand(time(0));
+					srand((unsigned int)time(0));
 					//SSAO
 					Math::Vector3 kernel[KernelSize];
 					Math::Vector3 random[SampleSpread];
@@ -230,11 +230,14 @@ namespace Oyster
 					{
 						{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
 						{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
-						{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 20, D3D11_INPUT_PER_VERTEX_DATA, 0 }
+						{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 20, D3D11_INPUT_PER_VERTEX_DATA, 0 },
-
+						{ "TANGENT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 32, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+						{ "BITANGENT", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 44, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+						{ "BONEINDEX", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 56, D3D11_INPUT_PER_VERTEX_DATA, 0 },
+						{ "BONEWEIGHT", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 72, D3D11_INPUT_PER_VERTEX_DATA, 0 }
 					};
 
-					Shader::CreateInputLayout(indesc,3,GetShader::Vertex(L"Geometry"),GeometryPass.IAStage.Layout);
+					Shader::CreateInputLayout(indesc,7,GetShader::Vertex(L"Geometry"),GeometryPass.IAStage.Layout);
 					GeometryPass.IAStage.Topology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
 					GeometryPass.CBuffers.Vertex.push_back(VPData);
 					GeometryPass.CBuffers.Vertex.push_back(ModelData);

Code/OysterGraphics/Shader/HLSL/Deffered Shaders/GBufferHeader.hlsli

@@ -3,16 +3,16 @@ struct VertexIn
 	float3 pos			: POSITION;
 	float2 UV			: TEXCOORD;
 	float3 normal		: NORMAL;
-	//float3 tangent		: TANGENT;
+	float3 tangent		: TANGENT;
-	//float3 biTangent	: BITANGENT;
+	float3 biTangent	: BITANGENT;
-	//float4 boneIndex	: BONEINDEX;
+	float4 boneIndex	: BONEINDEX;
-	//float4 boneWeight	: BONEWEIGHT;
+	float4 boneWeight	: BONEWEIGHT;
 };
 
 struct VertexOut
 {
 	float4 pos			: SV_POSITION;
-	float4 ViewPos		: POSITION;
+	//float4 ViewPos		: POSITION;
 	float2 UV			: TEXCOORD;
 	float3 normal		: NORMAL;
 	//float3 tangent		: TANGENT;

Code/OysterGraphics/Shader/HLSL/Deffered Shaders/VertexGatherData.hlsl

@@ -4,7 +4,7 @@ VertexOut main( VertexIn input )
 {
 	VertexOut output;
 	output.pos = mul(WVP, float4(input.pos,1));
-	output.normal = mul(WV, float4(input.normal,0));
+	output.normal = mul(WV, float4(input.normal,0)).xyz;
 	output.UV = input.UV;
 	return output;
 }

Code/Tester/MainTest.cpp

@@ -44,18 +44,6 @@ int WINAPI wWinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdL
 {
 
 	BOOL b = SetDllDirectoryW(L"..\\DLL");
-	typedef struct tagLOADPARMS32
-	{ 
-		LPSTR lpEnvAddress;  // address of environment strings 
-		LPSTR lpCmdLine;     // address of command line 
-		LPSTR lpCmdShow;     // how to show new program 
-		DWORD dwReserved;    // must be zero 
-	} LOADPARMS32;
-	LOADPARMS32 params;
-	params.dwReserved=NULL;
-	params.lpCmdLine="";
-	params.lpCmdShow="";
-	params.lpEnvAddress="";
 
 	if( FAILED( InitWindow( hInstance, nCmdShow ) ) )
 		return 0;
@@ -171,10 +159,10 @@ HRESULT InitDirect3D()
 		return E_FAIL;
 	}
 	
-	m =  Oyster::Graphics::API::CreateModel(L"orca_dummy");
+	m =  Oyster::Graphics::API::CreateModel(L"cube_tri.dan");
-	m2 = Oyster::Graphics::API::CreateModel(L"worldDummy");
+	m2 = Oyster::Graphics::API::CreateModel(L"cube_tri.dan");
 	m2->WorldMatrix = Oyster::Math3D::OrientationMatrix(Oyster::Math::Float3::null,Oyster::Math::Float3(0,5,0),Oyster::Math::Float3::null);
-	m3 = Oyster::Graphics::API::CreateModel(L"worldDummy");
+	m3 = Oyster::Graphics::API::CreateModel(L"cube_tri.dan");
 	m3->WorldMatrix = Oyster::Math3D::OrientationMatrix(Oyster::Math::Float3::null,Oyster::Math::Float3(0,5,0),Oyster::Math::Float3::null);
 	
 

Code/Tester/Tester.vcxproj

@@ -58,6 +58,7 @@
     <Link>
       <SubSystem>Windows</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
+      <DelayLoadDLLs>OysterGraphics_$(PlatformShortName)D.dll;</DelayLoadDLLs>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">