NoEdge/Danbias
NoEdge
/
Danbias
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Deffered Render Update

This commit is contained in:
Dennis 2013-12-17 14:49:45 +01:00
parent fb51881fab
commit 6f48e6a13a
31 changed files with 1247 additions and 619 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Code/OysterGraphics/Core/Buffer.cpp
View File

@ -205,3 +205,13 @@ Core::Buffer::operator const ID3D11Buffer *() const
{
return this->mBuffer;
}
UINT32 Core::Buffer::GetElementCount()
{
return this->mElementCount;
}
UINT32 Core::Buffer::GetVertexSize()
{
return this->mElementSize;
}

5
Code/OysterGraphics/Core/Core.cpp
View File

@ -20,7 +20,12 @@ ID3D11RenderTargetView* Core::backBufferRTV = NULL;
ID3D11UnorderedAccessView* Core::backBufferUAV = NULL;
ID3D11DepthStencilView* Core::depthStencil = NULL;
ID3D11ShaderResourceView* Core::depthStencilUAV = NULL;
D3D11_VIEWPORT* Core::viewPort = NULL;
Oyster::Math::Float2 Core::resolution = Oyster::Math::Float2::null;
ID3D11ShaderResourceView* Core::srvNULL[16] = {0};
ID3D11RenderTargetView* Core::rtvNULL[8] = {0};
ID3D11UnorderedAccessView* Core::uavNULL[8] = {0};

48
Code/OysterGraphics/Core/Core.h
View File

@ -30,11 +30,16 @@ namespace Oyster
static ID3D11UnorderedAccessView* backBufferUAV;
//DepthStencil
static ID3D11DepthStencilView* depthStencil;
static ID3D11ShaderResourceView* depthStencilUAV;
//ViewPort
static D3D11_VIEWPORT* viewPort;
static Oyster::Math::Float2 resolution;
static ID3D11ShaderResourceView* srvNULL[16];
static ID3D11RenderTargetView* rtvNULL[8];
static ID3D11UnorderedAccessView* uavNULL[8];
class Buffer
{
public:
@ -102,10 +107,10 @@ namespace Oyster
};
class ShaderManager
class PipelineManager
{
public:
struct ShaderEffect
struct RenderPass
{
struct
{
@ -125,16 +130,36 @@ namespace Oyster
ID3D11SamplerState **SampleState;
int SampleCount;
ID3D11BlendState *BlendState;
}RenderStates;
struct
{
std::vector<Buffer*> Vertex;
std::vector<Buffer*> Geometry;
std::vector<Buffer*> Pixel;
std::vector<ID3D11Buffer*> Vertex;
std::vector<ID3D11Buffer*> Geometry;
std::vector<ID3D11Buffer*> Pixel;
std::vector<ID3D11Buffer*> Compute;
}CBuffers;
ShaderEffect()
struct
{
std::vector<ID3D11ShaderResourceView*> Vertex;
std::vector<ID3D11ShaderResourceView*> Geometry;
std::vector<ID3D11ShaderResourceView*> Pixel;
std::vector<ID3D11ShaderResourceView*> Compute;
}SRV;
std::vector<ID3D11RenderTargetView*> RTV;
struct
{
std::vector<ID3D11UnorderedAccessView*> Pixel;
std::vector<ID3D11UnorderedAccessView*> Compute;
}UAV;
ID3D11DepthStencilView* depth;
RenderPass()
{
RenderStates.BlendState=NULL;
RenderStates.DepthStencil=NULL;
@ -164,7 +189,7 @@ namespace Oyster
char* data;
};
static void SetShaderEffect(ShaderEffect);
static void SetRenderPass(RenderPass);
static void CreateInputLayout(const D3D11_INPUT_ELEMENT_DESC *desc, int ElementCount,int VertexIndex,ID3D11InputLayout *&Layout);
@ -192,6 +217,7 @@ namespace Oyster
};
static void Clean();
static void CleanPipeline();
};
//Set resulotion Before Calling Full Init
@ -200,7 +226,7 @@ namespace Oyster
public:
enum State
{
Sucsess,
Success,
Fail
};
@ -217,6 +243,12 @@ namespace Oyster
static State FullInit(HWND Window, bool MSAA_Quality, bool Fullscreen);
static State ReInitialize(HWND Window, bool MSAA_Quality, bool Fullscreen);
static State CreateLinkedShaderResourceFromTexture(ID3D11RenderTargetView** rtv, ID3D11ShaderResourceView** srv, ID3D11UnorderedAccessView** uav);
static State CreateLinkedShaderResourceFromStructuredBuffer(Buffer** Structured, ID3D11ShaderResourceView** srv, ID3D11UnorderedAccessView** uav);
static State CreateLinkedShaderResourceFromStructuredBuffer(void* InitData, int numElem, int ElemSize, Buffer** Structured, ID3D11ShaderResourceView** srv, ID3D11UnorderedAccessView** uav);
};
};
}

118
Code/OysterGraphics/Core/Init.cpp
View File

@ -83,7 +83,7 @@ namespace Oyster
}
}
if(Core::device)
return Init::Sucsess;
return Init::Success;
return Init::Fail;
}
@ -168,7 +168,7 @@ namespace Oyster
dxgiFactory->Release();
return Init::Sucsess;
return Init::Success;
}
Core::Init::State Core::Init::CreateDepthStencil(bool MSAA_Quality, Oyster::Math::Float2 Size)
@ -176,9 +176,9 @@ namespace Oyster
D3D11_TEXTURE2D_DESC desc;
desc.MipLevels=1;
desc.ArraySize=1;
desc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
desc.Format = DXGI_FORMAT_R32_TYPELESS;
desc.Usage = D3D11_USAGE_DEFAULT;
desc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
desc.BindFlags = D3D11_BIND_DEPTH_STENCIL | D3D11_BIND_SHADER_RESOURCE;
desc.CPUAccessFlags=0;
desc.MiscFlags=0;
desc.Height = (UINT)Size.y;
@ -211,15 +211,32 @@ namespace Oyster
ID3D11Texture2D* depthstencil;
if(FAILED(Core::device->CreateTexture2D(&desc,0,&depthstencil)))
{
return Init::Fail;
if(FAILED(Core::device->CreateDepthStencilView(depthstencil,0,&Core::depthStencil)))
}
D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc;
dsvDesc.Format = DXGI_FORMAT_D32_FLOAT;
dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
dsvDesc.Flags = 0;
dsvDesc.Texture2D.MipSlice = 0;
if(Core::device->CreateDepthStencilView(depthstencil,&dsvDesc,&Core::depthStencil) != S_OK)
{
depthstencil->Release();
return Init::Fail;
}
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
srvDesc.Format = DXGI_FORMAT_R32_FLOAT;
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srvDesc.Texture2D.MipLevels = 1;
srvDesc.Texture2D.MostDetailedMip = 0;
if(FAILED(Core::device->CreateShaderResourceView(depthstencil,&srvDesc,&Core::depthStencilUAV)))
{
depthStencil->Release();
return Init::Fail;
}
depthstencil->Release();
return Init::Sucsess;
return Init::Success;
}
Core::Init::State Core::Init::CreateBackBufferViews()
@ -261,7 +278,7 @@ namespace Oyster
backBuffer->Release();
return Init::Sucsess;
return Init::Success;
}
Core::Init::State Core::Init::CreateViewPort(Oyster::Math::Float2 Origin, Oyster::Math::Float2 Size)
@ -277,7 +294,7 @@ namespace Oyster
Core::viewPort->MinDepth = 0.0f;
Core::viewPort->MaxDepth = 1.0f;
return Init::Sucsess;
return Init::Success;
}
Core::Init::State Core::Init::FullInit(HWND Window, bool MSAA_Quality, bool Fullscreen)
@ -307,7 +324,7 @@ namespace Oyster
return Init::Fail;
}
return Init::Sucsess;
return Init::Success;
}
Core::Init::State Core::Init::ReInitialize(HWND Window, bool MSAA_Quality, bool Fullscreen)
@ -332,7 +349,88 @@ namespace Oyster
return Init::Fail;
}
return Init::Sucsess;
return Init::Success;
}
Core::Init::State Core::Init::CreateLinkedShaderResourceFromTexture(ID3D11RenderTargetView** rtv, ID3D11ShaderResourceView** srv, ID3D11UnorderedAccessView** uav)
{
ID3D11Texture2D* tex;
D3D11_TEXTURE2D_DESC texDesc;
texDesc.Width = Core::resolution.x;
texDesc.Height = Core::resolution.y;
texDesc.MipLevels = 1;
texDesc.ArraySize = 1;
texDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
texDesc.SampleDesc.Count = 1;
texDesc.SampleDesc.Quality = 0;
texDesc.Usage = D3D11_USAGE_DEFAULT;
texDesc.CPUAccessFlags = 0;
texDesc.MiscFlags = 0;
texDesc.BindFlags = 0;
if(rtv)
{
texDesc.BindFlags |= D3D11_BIND_RENDER_TARGET;
}
if(srv)
{
texDesc.BindFlags |= D3D11_BIND_SHADER_RESOURCE;
}
if(uav)
{
texDesc.BindFlags |= D3D11_BIND_UNORDERED_ACCESS;
}
if(FAILED(Core::device->CreateTexture2D(&texDesc,NULL,&tex)))
return State::Fail;
if(rtv)
{
D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
rtvDesc.Format = texDesc.Format;
rtvDesc.Texture2D.MipSlice = 0;
rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
Core::device->CreateRenderTargetView(tex, &rtvDesc, rtv);
}
if(srv)
{
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
srvDesc.Texture2D.MipLevels = 1;
srvDesc.Texture2D.MostDetailedMip = 0;
srvDesc.Format = texDesc.Format;
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
Core::device->CreateShaderResourceView(tex,&srvDesc,srv);
}
if(uav)
{
D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc;
uavDesc.Texture2D.MipSlice = 0;
uavDesc.Format = texDesc.Format;
uavDesc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2D;
Core::device->CreateUnorderedAccessView(tex,&uavDesc,uav);
}
SAFE_RELEASE(tex);
return State::Success;
}
Core::Init::State Core::Init::CreateLinkedShaderResourceFromStructuredBuffer(Buffer** Structured, ID3D11ShaderResourceView** srv, ID3D11UnorderedAccessView** uav)
{
D3D11_SHADER_RESOURCE_VIEW_DESC desc;
desc.Buffer.FirstElement=0;
desc.Buffer.ElementWidth = (*Structured)->GetElementCount();
desc.Format = DXGI_FORMAT_UNKNOWN;
desc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
if(Core::device->CreateShaderResourceView(**(Structured),&desc, srv)==S_OK)
{
return State::Success;
}
return State::Fail;
}
}
}

172
Code/OysterGraphics/Core/ShaderManager.cpp → Code/OysterGraphics/Core/PipelineManager.cpp
View File

@ -28,12 +28,14 @@ namespace Oyster
std::map<std::wstring,int> HSMap;
std::vector<ID3D11VertexShader*> VS;
std::vector<Core::ShaderManager::ShaderData> VData;
std::vector<Core::PipelineManager::ShaderData> VData;
std::map<std::wstring,int> VSMap;
Core::PipelineManager::RenderPass Current;
}
#pragma region Init
bool Core::ShaderManager::Init(std::wstring filename, ShaderType type, std::wstring name)
bool Core::PipelineManager::Init(std::wstring filename, ShaderType type, std::wstring name)
{
void* data;
bool ForceReload;
@ -44,7 +46,7 @@ namespace Oyster
#endif
switch (type)
{
case Oyster::Graphics::Core::ShaderManager::Vertex:
case Oyster::Graphics::Core::PipelineManager::Vertex:
if(!VSMap.count(name) || ForceReload)
{
data = Resource::OysterResource::LoadResource(filename.c_str(),Loading::LoadShaderV, -1, ForceReload);
@ -55,7 +57,7 @@ namespace Oyster
}
}
break;
case Oyster::Graphics::Core::ShaderManager::Hull:
case Oyster::Graphics::Core::PipelineManager::Hull:
data = Resource::OysterResource::LoadResource(filename.c_str(),Loading::LoadShaderH, -1, ForceReload);
if(!HSMap.count(name) || ForceReload)
{
@ -66,7 +68,7 @@ namespace Oyster
}
}
break;
case Oyster::Graphics::Core::ShaderManager::Domain:
case Oyster::Graphics::Core::PipelineManager::Domain:
data = Resource::OysterResource::LoadResource(filename.c_str(),Loading::LoadShaderD, -1, ForceReload);
if(!DSMap.count(name) || ForceReload)
{
@ -77,7 +79,7 @@ namespace Oyster
}
}
break;
case Oyster::Graphics::Core::ShaderManager::Geometry:
case Oyster::Graphics::Core::PipelineManager::Geometry:
data = Resource::OysterResource::LoadResource(filename.c_str(),Loading::LoadShaderG, -1, ForceReload);
if(!GSMap.count(name) || ForceReload)
{
@ -88,7 +90,7 @@ namespace Oyster
}
}
break;
case Oyster::Graphics::Core::ShaderManager::Pixel:
case Oyster::Graphics::Core::PipelineManager::Pixel:
data = Resource::OysterResource::LoadResource(filename.c_str(),Loading::LoadShaderP, -1, ForceReload);
if(!PSMap.count(name) || ForceReload)
{
@ -99,7 +101,7 @@ namespace Oyster
}
}
break;
case Oyster::Graphics::Core::ShaderManager::Compute:
case Oyster::Graphics::Core::PipelineManager::Compute:
data = Resource::OysterResource::LoadResource(filename.c_str(),Loading::LoadShaderC, -1, ForceReload);
if(!CSMap.count(name) || ForceReload)
{
@ -116,44 +118,44 @@ namespace Oyster
return true;
}
void* Core::ShaderManager::CreateShader(Core::ShaderManager::ShaderData data, Core::ShaderManager::ShaderType type)
void* Core::PipelineManager::CreateShader(Core::PipelineManager::ShaderData data, Core::PipelineManager::ShaderType type)
{
HRESULT hr;
switch (type)
{
case Oyster::Graphics::Core::ShaderManager::Vertex:
case Oyster::Graphics::Core::PipelineManager::Vertex:
ID3D11VertexShader* vs;
hr = Core::device->CreateVertexShader(data.data,data.size,NULL,&vs);
if(hr == S_OK)
VData.push_back(data);
return vs;
break;
case Oyster::Graphics::Core::ShaderManager::Hull:
case Oyster::Graphics::Core::PipelineManager::Hull:
ID3D11HullShader* hs;
Core::device->CreateHullShader(data.data,data.size,NULL,&hs);
delete[] data.data;
return hs;
break;
case Oyster::Graphics::Core::ShaderManager::Domain:
case Oyster::Graphics::Core::PipelineManager::Domain:
ID3D11DomainShader* ds;
Core::device->CreateDomainShader(data.data,data.size,NULL,&ds);
delete[] data.data;
return ds;
break;
case Oyster::Graphics::Core::ShaderManager::Geometry:
case Oyster::Graphics::Core::PipelineManager::Geometry:
ID3D11GeometryShader* gs;
Core::device->CreateGeometryShader(data.data,data.size,NULL,&gs);
delete[] data.data;
return gs;
break;
case Oyster::Graphics::Core::ShaderManager::Pixel:
case Oyster::Graphics::Core::PipelineManager::Pixel:
ID3D11PixelShader* ps;
Core::device->CreatePixelShader(data.data,data.size,NULL,&ps);
delete[] data.data;
return ps;
break;
case Oyster::Graphics::Core::ShaderManager::Compute:
case Oyster::Graphics::Core::PipelineManager::Compute:
ID3D11ComputeShader* cs;
Core::device->CreateComputeShader(data.data,data.size,NULL,&cs);
delete[] data.data;
@ -164,7 +166,7 @@ namespace Oyster
}
#pragma endregion
void Core::ShaderManager::CreateInputLayout(const D3D11_INPUT_ELEMENT_DESC *desc, int ElementCount,int VertexIndex,ID3D11InputLayout *&Layout)
void Core::PipelineManager::CreateInputLayout(const D3D11_INPUT_ELEMENT_DESC *desc, int ElementCount,int VertexIndex,ID3D11InputLayout *&Layout)
{
if(VertexIndex==-1)
{
@ -175,79 +177,113 @@ namespace Oyster
}
#pragma region Get
int Core::ShaderManager::Get::Pixel(std::wstring Name)
int Core::PipelineManager::Get::Pixel(std::wstring Name)
{
if(PSMap.count(Name))
return PSMap[Name];
return -1;
}
int Core::ShaderManager::Get::Vertex(std::wstring Name)
int Core::PipelineManager::Get::Vertex(std::wstring Name)
{
if(VSMap.count(Name))
return VSMap[Name];
return -1;
}
int Core::ShaderManager::Get::Geometry(std::wstring Name)
int Core::PipelineManager::Get::Geometry(std::wstring Name)
{
if(GSMap.count(Name))
return GSMap[Name];
return -1;
}
int Core::ShaderManager::Get::Compute(std::wstring Name)
int Core::PipelineManager::Get::Compute(std::wstring Name)
{
if(CSMap.count(Name))
return CSMap[Name];
return -1;
}
int Core::ShaderManager::Get::Hull(std::wstring Name)
int Core::PipelineManager::Get::Hull(std::wstring Name)
{
return -1;
}
int Core::ShaderManager::Get::Domain(std::wstring Name)
int Core::PipelineManager::Get::Domain(std::wstring Name)
{
return -1;
}
#pragma endregion
#pragma region Set
/// \todo smart set
void Core::ShaderManager::Set::Pixel(int Index)
void Core::PipelineManager::Set::Pixel(int Index)
{
if(Current.Shaders.Pixel != Index)
{
if(Index==-1)
{
Core::deviceContext->PSSetShader( NULL,NULL,0);
}
else
{
Core::deviceContext->PSSetShader( PS[Index],NULL,0);
}
void Core::ShaderManager::Set::Vertex(int Index)
Current.Shaders.Pixel=Index;
}
}
void Core::PipelineManager::Set::Vertex(int Index)
{
if(Current.Shaders.Vertex != Index)
{
if(Index==-1)
{
Core::deviceContext->VSSetShader( NULL,NULL,0);
}
else
{
Core::deviceContext->VSSetShader( VS[Index],NULL,0);
}
void Core::ShaderManager::Set::Geometry(int Index)
Current.Shaders.Vertex = Index;
}
}
void Core::PipelineManager::Set::Geometry(int Index)
{
if(Current.Shaders.Geometry != Index)
{
if(Index==-1)
{
Core::deviceContext->GSSetShader( NULL,NULL,0);
}
else
{
Core::deviceContext->GSSetShader( GS[Index],NULL,0);
}
void Core::ShaderManager::Set::Compute(int Index)
Current.Shaders.Geometry = Index;
}
}
void Core::PipelineManager::Set::Compute(int Index)
{
if(Current.Shaders.Compute != Index)
{
if(Index==-1)
{
Core::deviceContext->CSSetShader( NULL,NULL,0);
}
else
{
Core::deviceContext->CSSetShader( CS[Index],NULL,0);
}
Current.Shaders.Compute = Index;
}
}
/// \todo set Hull
void Core::ShaderManager::Set::Hull(int Index)
void Core::PipelineManager::Set::Hull(int Index)
{
return;
}
/// \todo set Domain
void Core::ShaderManager::Set::Domain(int Index)
void Core::PipelineManager::Set::Domain(int Index)
{
return;
}
@ -256,33 +292,95 @@ namespace Oyster
/// \todo smart Set ie. not resetting the shader
/// \todo research states
/// \todo smart buffer set
void Core::ShaderManager::SetShaderEffect(ShaderEffect se)
void Core::PipelineManager::SetRenderPass(RenderPass se)
{
CleanPipeline();
Set::Pixel(se.Shaders.Pixel);
Set::Vertex(se.Shaders.Vertex);
Set::Geometry(se.Shaders.Geometry);
Set::Compute(se.Shaders.Compute);
Core::deviceContext->IASetInputLayout(se.IAStage.Layout);
Core::deviceContext->IASetPrimitiveTopology(se.IAStage.Topology);
for(unsigned int i=0;i<se.CBuffers.Vertex.size();++i)
se.CBuffers.Vertex[i]->Apply(i);
for(unsigned int i=0;i<se.CBuffers.Geometry.size();++i)
se.CBuffers.Geometry[i]->Apply(i);
for(unsigned int i=0;i<se.CBuffers.Pixel.size();++i)
se.CBuffers.Pixel[i]->Apply(i);
if(se.CBuffers.Vertex.size())
{
deviceContext->VSSetConstantBuffers(0,se.CBuffers.Vertex.size(),&se.CBuffers.Vertex[0]);
}
if(se.CBuffers.Pixel.size())
{
deviceContext->PSSetConstantBuffers(0,se.CBuffers.Pixel.size(),&se.CBuffers.Pixel[0]);
}
if(se.CBuffers.Geometry.size())
{
deviceContext->GSSetConstantBuffers(0,se.CBuffers.Geometry.size(),&se.CBuffers.Geometry[0]);
}
if(se.CBuffers.Compute.size())
{
deviceContext->CSSetConstantBuffers(0,se.CBuffers.Compute.size(),&se.CBuffers.Compute[0]);
}
Core::deviceContext->RSSetState(se.RenderStates.Rasterizer);
Core::deviceContext->PSSetSamplers(0,se.RenderStates.SampleCount,se.RenderStates.SampleState);
Core::deviceContext->OMSetDepthStencilState(se.RenderStates.DepthStencil,0);
float test[4] = {0};
Core::deviceContext->OMSetBlendState(se.RenderStates.BlendState,test,-1);
if(se.SRV.Vertex.size())
{
Core::deviceContext->VSSetShaderResources(0,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]);
}
if(se.SRV.Pixel.size())
{
Core::deviceContext->PSSetShaderResources(0,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]);
}
void Core::ShaderManager::Clean()
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);
}
else
{
deviceContext->OMSetRenderTargets(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);
}
}
if(se.UAV.Compute.size())
{
deviceContext->CSSetUnorderedAccessViews(0,se.UAV.Compute.size(),&se.UAV.Compute[0],0);
}
}
void Core::PipelineManager::Clean()
{
for(int i = 0; i < (int)VData.size(); ++i)
{
delete[] VData[i].data;
}
}
void Core::PipelineManager::CleanPipeline()
{
deviceContext->VSSetShaderResources(0,16,Core::srvNULL);
deviceContext->GSSetShaderResources(0,16,Core::srvNULL);
deviceContext->PSSetShaderResources(0,16,Core::srvNULL);
deviceContext->CSSetShaderResources(0,16,Core::srvNULL);
deviceContext->CSSetUnorderedAccessViews(0,8,Core::uavNULL,NULL);
deviceContext->OMSetRenderTargets(8,Core::rtvNULL, NULL);
}
}
}

18
Code/OysterGraphics/Definitions/GraphicalDefinition.h
View File

@ -1,5 +1,5 @@
#include "..\OysterGraphics\Core\Dx11Includes.h"
#include "OysterMath.h"
#pragma once
namespace Oyster
{
@ -31,6 +31,22 @@ namespace Oyster
Oyster::Math::Float4 boneWeights;
};
struct LightConstants
{
Math::Float4x4 InvProj;
Math::Float2 Pixels;
int Lights;
float Pad;
};
struct Pointlight
{
Math::Float3 Pos;
float Radius;
Math::Float3 Color;
float Bright;
};
}
}
}

30
Code/OysterGraphics/DllInterfaces/GFXAPI.cpp
View File

@ -1,6 +1,7 @@
#include "GFXAPI.h"
#include "../Core/Core.h"
#include "../Render/Resources/Resources.h"
#include "../Render/Resources/Debug.h"
#include "../Render/Resources/Deffered.h"
#include "../Render/Rendering/Render.h"
#include "../FileLoader/ObjReader.h"
#include "../../Misc/Resource/OysterResource.h"
@ -14,6 +15,7 @@ namespace Oyster
{
Math::Float4x4 View;
Math::Float4x4 Projection;
std::vector<Definitions::Pointlight> Lights;
}
API::State API::Init(HWND Window, bool MSAA_Quality, bool Fullscreen, Math::Float2 resulotion)
@ -24,10 +26,13 @@ namespace Oyster
{
return API::Fail;
}
if(Render::Resources::Init() == Core::Init::Fail)
#ifdef _DEBUG
if(Render::Resources::Debug::Init() == Core::Init::Fail)
{
return API::Fail;
}
#endif
Render::Resources::Deffered::Init();
Render::Preparations::Basic::SetViewPort();
return API::Sucsess;
@ -45,7 +50,7 @@ namespace Oyster
void API::NewFrame()
{
Render::Rendering::Basic::NewFrame(View, Projection);
Render::Rendering::Basic::NewFrame(View, Projection, &Lights[0], Lights.size());
}
void API::RenderScene(Model::Model models[], int count)
@ -90,10 +95,15 @@ namespace Oyster
{
SAFE_DELETE(Core::viewPort);
Oyster::Resource::OysterResource::Clean();
Oyster::Graphics::Core::ShaderManager::Clean();
Oyster::Graphics::Render::Resources::Clean();
Oyster::Graphics::Core::PipelineManager::Clean();
#ifdef _DEBUG
Oyster::Graphics::Render::Resources::Debug::Clean();
#endif
Oyster::Graphics::Render::Resources::Deffered::Clean();
SAFE_RELEASE(Core::depthStencil);
SAFE_RELEASE(Core::depthStencilUAV);
SAFE_RELEASE(Core::backBufferRTV);
SAFE_RELEASE(Core::backBufferUAV);
@ -101,5 +111,15 @@ namespace Oyster
SAFE_RELEASE(Core::deviceContext);
SAFE_RELEASE(Core::device);
}
void API::AddLight(Definitions::Pointlight light)
{
Lights.push_back(light);
}
void API::ClearLights()
{
Lights.clear();
}
}
}

5
Code/OysterGraphics/DllInterfaces/GFXAPI.h
View File

@ -1,8 +1,10 @@
#pragma once
#include <string>
#include "../Definitions/GraphicalDefinition.h"
#include "..\Model\Model.h"
#include "OysterMath.h"
#include <Windows.h>
//#include <vld.h>
#ifdef GFX_DLL_EXPORT
#define GFX_DLL_USAGE __declspec(dllexport)
@ -41,6 +43,9 @@ namespace Oyster
static Oyster::Graphics::Model::Model* CreateModel(std::wstring filename);
static void DeleteModel(Oyster::Graphics::Model::Model* model);
static void AddLight(Definitions::Pointlight light);
static void ClearLights();
static State SetOptions(Option);
};
}

26
Code/OysterGraphics/FileLoader/ModelLoader.cpp
View File

@ -2,6 +2,7 @@
#include "..\Core\Dx11Includes.h"
#include "..\Core\Core.h"
#include "ObjReader.h"
#include "..\..\Misc\Resource\OysterResource.h"
HRESULT CreateWICTextureFromFileEx( ID3D11Device* d3dDevice,
ID3D11DeviceContext* d3dContext,
@ -38,10 +39,27 @@ void Oyster::Graphics::Loading::UnloadTexture(void* data)
void Oyster::Graphics::Loading::LoadOBJ(const wchar_t filename[], Oyster::Resource::CustomData& out)
{
OBJReader obj;
obj.readOBJFile(filename);
Model::ModelInfo* info;
info = obj.toModel();
FileLoaders::ObjReader* obj = FileLoaders::ObjReader::LoadFile(filename);
Model::ModelInfo* info = new Model::ModelInfo();
Oyster::FileLoaders::ObjReader::Vertex* vdata;
int count;
obj->GetVertexData(&vdata, count);
info->Vertices = new Core::Buffer();
Core::Buffer::BUFFER_INIT_DESC desc;
desc.ElementSize = sizeof(FileLoaders::ObjReader::Vertex);
desc.NumElements = count;
desc.InitData = vdata;
desc.Type = Core::Buffer::VERTEX_BUFFER;
desc.Usage = Core::Buffer::BUFFER_USAGE_IMMUTABLE;
info->VertexCount = count;
info->Vertices->Init(desc);
info->Indexed = false;
void* texture = Oyster::Resource::OysterResource::LoadResource((std::wstring(filename)+ L".png").c_str(),Graphics::Loading::LoadTexture);
info->Material.push_back((ID3D11ShaderResourceView*)texture);
out.loadedData = info;
out.resourceUnloadFnc = Oyster::Graphics::Loading::UnloadOBJ;
}

359
Code/OysterGraphics/FileLoader/ObjReader.cpp
View File

@ -1,152 +1,285 @@
#include "OBJReader.h"
#include "..\Definitions\GraphicalDefinition.h"
#include <sstream>
#include "ObjReader.h"
#include "Utilities.h"
#include "..\Core\Core.h"
#include <fstream>
#include "GeneralLoader.h"
#include <map>
using namespace std;
OBJReader::OBJReader()
using namespace Oyster::FileLoaders;
using namespace Oyster;
using namespace Oyster::Math;
ObjReader *ObjReader::LoadFile(std::wstring fileName, Oyster::Math::Float4x4 transform)
{
_mPos = 0;
_mNormal = 0;
_mTexel = 0;
static std::map<std::wstring, ObjReader *> cache;
ObjReader *reader = NULL;
if (cache.count(fileName))
{
reader = cache[fileName];
}
else
{
reader = new ObjReader();
reader->ParseFile(fileName + L".obj", transform);
cache[fileName] = reader;
}
OBJReader::~OBJReader()
{
return reader;
}
void OBJReader::readOBJFile( std::wstring fileName )
ObjReader::ObjReader(void)
{
std::fstream inStream;
std::string typeOfData = " ";
float vertexData;
std::string face1, face2, face3;
inStream.open( fileName + L".obj", std::fstream::in );
if( inStream.is_open() )
{
while( !inStream.eof() )
{
inStream >> typeOfData;
if( typeOfData == "v" )
{
Oyster::Math::Float3 position;
inStream >> vertexData;
position.x = vertexData;
inStream >> vertexData;
position.y = vertexData;
inStream >> vertexData;
position.z = vertexData;
_mVertexCoord.push_back( position );
}
else if( typeOfData == "vt" )
ObjReader::~ObjReader(void)
{
Oyster::Math::Float2 texel;
inStream >> vertexData;
texel.x = vertexData;
inStream >> vertexData;
texel.y = 1 - vertexData;
_mVertexTexture.push_back( texel );
}
else if( typeOfData == "vn" )
void ObjReader::ParseFile(std::wstring fileName, Float4x4 transform)
{
Oyster::Math::Float3 normal;
inStream >> vertexData;
normal.x = vertexData;
wifstream input;
input.open(fileName.c_str());
inStream >> vertexData;
normal.y = vertexData;
inStream >> vertexData;
normal.z = vertexData;
_mVertexNormal.push_back( normal );
if(!input.is_open())
{
return;
}
else if( typeOfData == "f" )
wstring path;
//Utility::String::ExtractDirPath(path,fileName,'\\');
std::vector<Vertex> VertexList;
std::vector<Float3> vList;
std::vector<Float3> nList;
std::vector<Float2> uvList;
Vertex vertex1, vertex2, vertex3;
Float3 face[3];
Float3 position, normal;
Float2 uv;
wstring s;
while(!input.eof())
{
inStream >> face1;
stringSplit( face1 );
getline(input,s);
int offset = (int)s.find(' ');
addToOBJarray();
if(offset!=-1)
{
wstring c = s.substr(0,offset);
inStream >> face2;
stringSplit( face2 );
if(c==L"v")
{
position = readVertex(offset,s);
vList.push_back(position);
}
else if(c==L"vt")
{
uv = readUV(offset,s);
uvList.push_back(uv);
}
else if(c==L"vn")
{
normal = readNormal(offset,s);
nList.push_back(normal);
}
else if(c==L"f")
{
readFace(offset, s, face);
addToOBJarray();
vertex1.Position = vList[(int)face[0].x];
vertex1.UV = uvList[(int)face[0].y];
vertex1.Normal = nList[(int)face[0].z];
inStream >> face3;
stringSplit( face3 );
vertex2.Position = vList[(int)face[1].x];
vertex2.UV = uvList[(int)face[1].y];
vertex2.Normal = nList[(int)face[1].z];
addToOBJarray();
vertex3.Position = vList[(int)face[2].x];
vertex3.UV = uvList[(int)face[2].y];
vertex3.Normal = nList[(int)face[2].z];
VertexList.push_back(vertex1);
VertexList.push_back(vertex2);
VertexList.push_back(vertex3);
}
else if(c==L"mtllib")
{
//this->materials = GetMaterials(path + s.substr(offset+1));
}
}
}
inStream.close();
input.close();
Mat = Oyster::Resource::OysterResource::LoadResource((fileName + L".png").c_str(),Oyster::Graphics::Loading::LoadTexture);
}
this->numVertices = VertexList.size();
this->vertices = new Vertex[this->numVertices];
Oyster::Graphics::Model::ModelInfo* OBJReader::toModel()
for(size_t i=0;i<this->numVertices;++i)
{
Oyster::Graphics::Core::Buffer* b = new Oyster::Graphics::Core::Buffer();
Oyster::Graphics::Core::Buffer::BUFFER_INIT_DESC desc;
Oyster::Graphics::Model::ModelInfo* modelInfo = new Oyster::Graphics::Model::ModelInfo();
vertices[i].Position=Math::Float4(VertexList[i].Position,1);
vertices[i].Normal=Math::Float4(VertexList[i].Normal,0);
vertices[i].UV = VertexList[i].UV;
}
}
desc.ElementSize = 32;
desc.InitData = &this->_myOBJ[0];
desc.NumElements = this->_myOBJ.size();
desc.Type = Oyster::Graphics::Core::Buffer::BUFFER_TYPE::VERTEX_BUFFER;
desc.Usage = Oyster::Graphics::Core::Buffer::BUFFER_DEFAULT;
HRESULT hr = S_OK;
hr = b->Init(desc);
if(FAILED(hr))
void ObjReader::GetVertexData(Vertex **vertex,int &numVertex, std::map<std::string, ID3D11ShaderResourceView *> &Textures)
{
//Something isn't okay here
}
modelInfo->Indexed = false;
modelInfo->VertexCount = (int)desc.NumElements;
modelInfo->Vertices = b;
modelInfo->Material.push_back((ID3D11ShaderResourceView*)Mat);
return modelInfo;
numVertex=(int)this->numVertices;
(*vertex)=this->vertices;
//Textures = this->materials;
}
//Private functions
void OBJReader::stringSplit( std::string strToSplit )
void ObjReader::GetVertexData(Vertex **vertex,int &numVertex)
{
char delim = '/';
std::string vPos, vNormal, vTexel;
std::stringstream aStream(strToSplit);
getline( aStream, vPos, delim );
getline( aStream, vTexel, delim );
getline( aStream, vNormal );
_mPos = atoi( vPos.c_str() );
_mNormal = atoi( vNormal.c_str() );
_mTexel = atoi( vTexel.c_str() );
numVertex=(int)this->numVertices;
(*vertex)=this->vertices;
}
void OBJReader::addToOBJarray()
Float3 ObjReader::extract(std::string d1)
{
OBJFormat temp;
Float3 data;
int offset=(int)d1.find('/');
//string d1 = Utility::String::WStringToString(d,d1);
data.x=(float)atoi(d1.substr(1,offset).c_str())-1;
temp._d3VertexCoord = _mVertexCoord.at( _mPos - 1 );
temp._d3VertexNormal = _mVertexNormal.at( _mNormal - 1 );
temp._d3VertexTexture = _mVertexTexture.at( _mTexel - 1 );
int newOffset = (int)d1.find('/',offset+1);
string d2=d1.substr(offset+1,newOffset-offset-1);
data.y=(float)atoi(d2.c_str())-1;
offset=newOffset;
_myOBJ.push_back( temp );
newOffset = (int)d1.find('/',offset+1);
string d3=d1.substr(offset+1,newOffset-offset-1);
data.z=(float)atoi(d3.c_str())-1;
return data;
}
Float3 ObjReader::readVertex(int offset,wstring s)
{
int newOffset = (int)s.find(' ',offset+1);
Float3 vertex;
string d;
Utility::String::WStringToString(s.substr(offset,newOffset-offset), d);
vertex.x = (float)atof(d.c_str());
offset=newOffset;
newOffset = (int)s.find(' ',offset+1);
Utility::String::WStringToString(s.substr(offset,newOffset-offset), d);
vertex.y = (float)atof(d.c_str());
offset=newOffset;
newOffset = (int)s.find(' ',offset+1);
Utility::String::WStringToString(s.substr(offset,newOffset-offset), d);
vertex.z = (float)atof(d.c_str());
return vertex;
}
Float2 ObjReader::readUV(int offset,wstring s)
{
int newOffset = (int)s.find(' ',offset+1);
Float2 uv;
string d;
Utility::String::WStringToString(s.substr(offset,newOffset-offset), d);
uv.x =(float)atof(d.c_str());
offset=newOffset;
newOffset = (int)s.find(' ',offset+1);
Utility::String::WStringToString(s.substr(offset,newOffset-offset), d);
uv.y =1- (float)atof(d.c_str());
offset=newOffset;
return uv;
}
Float3 ObjReader::readNormal(int offset,wstring s)
{
int newOffset = (int)s.find(' ',offset+1);
Float3 vertex;
string d;
Utility::String::WStringToString(s.substr(offset,newOffset-offset), d);
vertex.x = (float)atof(d.c_str());
offset=newOffset;
newOffset = (int)s.find(' ',offset+1);
Utility::String::WStringToString(s.substr(offset,newOffset-offset), d);
vertex.y = (float)atof(d.c_str());
offset=newOffset;
newOffset = (int)s.find(' ',offset+1);
Utility::String::WStringToString(s.substr(offset,newOffset-offset), d);
vertex.z = (float)atof(d.c_str());
return vertex;
}
void ObjReader::readFace(int offset,wstring s1, Oyster::Math::Float3 face[3])
{
string s;
Utility::String::WStringToString(s1,s);
int newOffset = (int)s.find(' ',offset+1);
string point1 = s.substr(offset,newOffset-offset);
offset = newOffset;
newOffset = (int)s.find(' ',offset+1);
string point2 = s.substr(offset,newOffset-offset);
offset = newOffset;
newOffset = (int)s.find(' ',offset+1);
string point3 = s.substr(offset,newOffset-offset);
face[0] = extract(point1);
face[1] = extract(point2);
face[2] = extract(point3);
}
std::map<std::string, ID3D11ShaderResourceView *> ObjReader::GetMaterials(std::wstring fileName)
{
ifstream input;
input.open(fileName.c_str());
std::map<std::string, ID3D11ShaderResourceView *> materials;
ID3D11ShaderResourceView *srv;
string texture;
string s;
string path;
//Utility::String::extractDirPath(path,fileName,'\\');
if(!input.is_open())
return materials;
while(!input.eof())
{
getline(input,s);
int offset = (int)s.find(' ');
if(offset!=-1)
{
string c = s.substr(0,offset);
if(c=="map_Kd")
{
texture = path+s.substr(offset+1);
//D3DX11CreateShaderResourceViewFromFile(Oyster::Core::Device,texture.c_str(), NULL, NULL, &srv, NULL);
//materials["Diffuse"] = srv;
}
if(c=="map_G")
{
texture = path+s.substr(offset+1);
//D3DX11CreateShaderResourceViewFromFile(Oyster::Core::Device,texture.c_str(), NULL, NULL, &srv, NULL);
//materials["Glow"] = srv;
}
if(c=="map_Ks")
{
texture = path+s.substr(offset+1);
//D3DX11CreateShaderResourceViewFromFile(Oyster::Core::Device,texture.c_str(), NULL, NULL, &srv, NULL);
//materials["Specular"] = srv;
}
}
}
input.close();
return materials;
}

75
Code/OysterGraphics/FileLoader/ObjReader.h
View File

@ -1,56 +1,43 @@
#ifndef OBJREADER_H
#define OBJREADER_H
#include "..\..\Misc\Utilities.h"
#include "..\..\OysterMath\OysterMath.h"
#include "..\Model\ModelInfo.h"
#pragma once
#include "../Model/ModelInfo.h"
#include "../../OysterMath/OysterMath.h"
//#include <fstream>
class OBJReader
namespace Oyster
{
namespace FileLoaders
{
class ObjReader
{
public:
struct OBJFormat
struct Vertex
{
Oyster::Math::Float3 _d3VertexCoord;
Oyster::Math::Float2 _d3VertexTexture;
Oyster::Math::Float3 _d3VertexNormal;
Oyster::Math::Float3 Position;
Oyster::Math::Float2 UV;
Oyster::Math::Float3 Normal;
};
struct OBJMaterialData
{
std::string _name;
std::string _mapKd;
float _kd[3];
float _ka[3];
float _tf[3];
float _ni;
static ObjReader *LoadFile(std::wstring fileName, Oyster::Math::Float4x4 transform = Oyster::Math::Float4x4::identity);
ObjReader(void);
~ObjReader(void);
void GetVertexData(Vertex **vertex,int &numVertex, std::map<std::string, ID3D11ShaderResourceView *> &textures);
void GetVertexData(Vertex **vertex,int &numVertex);
OBJMaterialData()
{
_name = " ";
_mapKd = " ";
}
};
std::vector<OBJFormat> _myOBJ;
private:
Vertex *vertices;
size_t numVertices;
std::map<std::wstring, ID3D11ShaderResourceView *> materials;
std::vector<Oyster::Math::Float3> _mVertexCoord, _mVertexNormal;
std::vector<Oyster::Math::Float2> _mVertexTexture;
void ParseFile(std::wstring fileName, Oyster::Math::Float4x4 transform = Oyster::Math::Float4x4::identity);
int _mNrOfCoords, _mNrOfNormals, _mNrOfTexels, _mNrOfFaces;
int _mPos, _mNormal, _mTexel;
void stringSplit( std::string strToSplit );
void addToOBJarray();
void* Mat;
public:
OBJReader();
~OBJReader();
void readOBJFile( std::wstring fileName);
Oyster::Graphics::Model::ModelInfo* toModel();
Oyster::Math::Float3 extract(std::string d);
Oyster::Math::Float3 readVertex(int offset,std::wstring s);
Oyster::Math::Float2 readUV(int offset,std::wstring s);
Oyster::Math::Float3 readNormal(int offset,std::wstring s);
void readFace(int offset,std::wstring s, Oyster::Math::Float3 face[3]);
std::map<std::string, ID3D11ShaderResourceView *> GetMaterials(std::wstring fileName);
};
#endif
}
}

30
Code/OysterGraphics/FileLoader/ShaderLoader.cpp
View File

@ -50,7 +50,7 @@ namespace Oyster
void LoadShaderP(const wchar_t filename[], Oyster::Resource::CustomData& out)
{
LoadShader(filename,out,Core::ShaderManager::Pixel);
LoadShader(filename,out,Core::PipelineManager::Pixel);
if(out.loadedData==NULL)
{
memset(&out,0,sizeof(out));
@ -62,7 +62,7 @@ namespace Oyster
void LoadShaderG(const wchar_t filename[], Oyster::Resource::CustomData& out)
{
LoadShader(filename,out,Core::ShaderManager::Geometry);
LoadShader(filename,out,Core::PipelineManager::Geometry);
if(out.loadedData==NULL)
{
memset(&out,0,sizeof(out));
@ -74,7 +74,7 @@ namespace Oyster
void LoadShaderC(const wchar_t filename[], Oyster::Resource::CustomData& out)
{
LoadShader(filename,out,Core::ShaderManager::Compute);
LoadShader(filename,out,Core::PipelineManager::Compute);
if(out.loadedData==NULL)
{
memset(&out,0,sizeof(out));
@ -86,7 +86,7 @@ namespace Oyster
void LoadShaderH(const wchar_t filename[], Oyster::Resource::CustomData& out)
{
LoadShader(filename,out,Core::ShaderManager::Hull);
LoadShader(filename,out,Core::PipelineManager::Hull);
if(out.loadedData==NULL)
{
memset(&out,0,sizeof(out));
@ -98,7 +98,7 @@ namespace Oyster
void LoadShaderD(const wchar_t filename[], Oyster::Resource::CustomData& out)
{
LoadShader(filename,out,Core::ShaderManager::Domain);
LoadShader(filename,out,Core::PipelineManager::Domain);
if(out.loadedData==NULL)
{
memset(&out,0,sizeof(out));
@ -110,7 +110,7 @@ namespace Oyster
void LoadShaderV(const wchar_t filename[], Oyster::Resource::CustomData& out)
{
LoadShader(filename,out,Core::ShaderManager::Vertex);
LoadShader(filename,out,Core::PipelineManager::Vertex);
if(out.loadedData==NULL)
{
memset(&out,0,sizeof(out));
@ -121,28 +121,28 @@ namespace Oyster
void LoadShader(const wchar_t filename[], Oyster::Resource::CustomData& out, int type)
{
Core::ShaderManager::ShaderData data;
Core::PipelineManager::ShaderData data;
#ifdef _DEBUG
ID3DBlob *Shader=NULL, *Error=NULL;
HRESULT hr;
switch (Core::ShaderManager::ShaderType(type))
switch (Core::PipelineManager::ShaderType(type))
{
case Oyster::Graphics::Core::ShaderManager::Vertex:
case Oyster::Graphics::Core::PipelineManager::Vertex:
hr = D3DCompileFromFile(filename,NULL,D3D_COMPILE_STANDARD_FILE_INCLUDE,"main","vs_5_0",D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION,0,&Shader,&Error);
break;
case Oyster::Graphics::Core::ShaderManager::Hull:
case Oyster::Graphics::Core::PipelineManager::Hull:
hr = D3DCompileFromFile(filename,NULL,D3D_COMPILE_STANDARD_FILE_INCLUDE,"main","hs_5_0",D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION,0,&Shader,&Error);
break;
case Oyster::Graphics::Core::ShaderManager::Domain:
case Oyster::Graphics::Core::PipelineManager::Domain:
hr = D3DCompileFromFile(filename,NULL,D3D_COMPILE_STANDARD_FILE_INCLUDE,"main","ds_5_0",D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION,0,&Shader,&Error);
break;
case Oyster::Graphics::Core::ShaderManager::Geometry:
case Oyster::Graphics::Core::PipelineManager::Geometry:
hr = D3DCompileFromFile(filename,NULL,D3D_COMPILE_STANDARD_FILE_INCLUDE,"main","gs_5_0",D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION,0,&Shader,&Error);
break;
case Oyster::Graphics::Core::ShaderManager::Pixel:
case Oyster::Graphics::Core::PipelineManager::Pixel:
hr = D3DCompileFromFile(filename,NULL,D3D_COMPILE_STANDARD_FILE_INCLUDE,"main","ps_5_0",D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION,0,&Shader,&Error);
break;
case Oyster::Graphics::Core::ShaderManager::Compute:
case Oyster::Graphics::Core::PipelineManager::Compute:
hr = D3DCompileFromFile(filename,NULL,D3D_COMPILE_STANDARD_FILE_INCLUDE,"main","cs_5_0",D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION,0,&Shader,&Error);
break;
default:
@ -185,7 +185,7 @@ namespace Oyster
return;
}
#endif
out.loadedData = Core::ShaderManager::CreateShader(data, Core::ShaderManager::ShaderType(type));
out.loadedData = Core::PipelineManager::CreateShader(data, Core::PipelineManager::ShaderType(type));
}
}
}

40
Code/OysterGraphics/Render/Rendering/BasicRender.cpp
View File

@ -1,5 +1,5 @@
#include "Render.h"
#include "../Resources/Resources.h"
#include "../Resources/Deffered.h"
#include "../../Definitions/GraphicalDefinition.h"
#include "../../Model/ModelInfo.h"
#include <map>
@ -13,22 +13,34 @@ namespace Oyster
{
namespace Rendering
{
Definitions::Pointlight pl;
void Basic::NewFrame(Oyster::Math::Float4x4 View, Oyster::Math::Float4x4 Projection)
void Basic::NewFrame(Oyster::Math::Float4x4 View, Oyster::Math::Float4x4 Projection, Definitions::Pointlight* Lights, int numLights)
{
Preparations::Basic::ClearBackBuffer(Oyster::Math::Float4(1,0,0,1));
Core::ShaderManager::SetShaderEffect(Graphics::Render::Resources::obj);
Preparations::Basic::BindBackBufferRTV();
Preparations::Basic::ClearRTV(Resources::Deffered::GBufferRTV,Resources::Deffered::GBufferSize,Math::Float4(1,0,0,1));
Core::PipelineManager::SetRenderPass(Graphics::Render::Resources::Deffered::GeometryPass);
Definitions::VP vp;
vp.V = View;
vp.P = Projection;
void* data = Resources::VPData.Map();
void* data = Resources::Deffered::VPData.Map();
memcpy(data, &vp, sizeof(Definitions::VP));
Resources::VPData.Unmap();
Resources::Deffered::VPData.Unmap();
Resources::VPData.Apply();
Definitions::LightConstants lc;
lc.InvProj = Projection.GetInverse();
lc.Pixels = Core::resolution;
lc.Lights = numLights;
data = Resources::Deffered::LightConstantsData.Map();
memcpy(data, &lc, sizeof(Definitions::LightConstants));
Resources::Deffered::LightConstantsData.Unmap();
data = Resources::Deffered::PointLightsData.Map();
memcpy(data, Lights, sizeof(Definitions::Pointlight) * numLights);
Resources::Deffered::PointLightsData.Unmap();
}
void Basic::RenderScene(Model::Model* models, int count)
@ -37,14 +49,17 @@ namespace Oyster
{
if(models[i].Visible)
{
void* data = Resources::ModelData.Map();
void* data = Resources::Deffered::ModelData.Map();
memcpy(data,&(models[i].WorldMatrix),sizeof(Math::Float4x4));
Resources::ModelData.Unmap();
Resources::Deffered::ModelData.Unmap();
Model::ModelInfo* info = (Model::ModelInfo*)models[i].info;
if(info->Material.size())
{
Core::deviceContext->PSSetShaderResources(0,info->Material.size(),&(info->Material[0]));
}
info->Vertices->Apply();
@ -62,8 +77,11 @@ namespace Oyster
}
void Basic::EndFrame()
{
IDXGISwapChain* chain = Core::swapChain;
chain->Present(0,0);
Core::PipelineManager::SetRenderPass(Resources::Deffered::LightPass);
Core::deviceContext->Dispatch((Core::resolution.x + 15U) / 16U,(Core::resolution.y + 15U) / 16U,1);
Core::swapChain->Present(0,0);
}
}
}

4
Code/OysterGraphics/Render/Rendering/Render.h
View File

@ -1,5 +1,5 @@
#pragma once
#include "..\..\Definitions\GraphicalDefinition.h"
#include "..\..\Core\Core.h"
#include "..\Preparations\Preparations.h"
#include "..\..\Model\Model.h"
@ -16,7 +16,7 @@ namespace Oyster
{
public:
static void NewFrame(Oyster::Math::Float4x4 View, Oyster::Math::Float4x4 Projection);
static void NewFrame(Oyster::Math::Float4x4 View, Oyster::Math::Float4x4 Projection, Definitions::Pointlight* Lights, int numLights);
static void RenderScene(Model::Model* models, int count);
static void EndFrame();
};

53
Code/OysterGraphics/Render/Resources/Debug.cpp Normal file
View File

@ -0,0 +1,53 @@
#include "Debug.h"
#include "..\OysterGraphics\Definitions\GraphicalDefinition.h"
#ifdef _DEBUG
// /Bin/Executable/Tester ->
// /Code/OysterGraphics/Shader/HLSL
const std::wstring PathFromExeToCso = L"..\\Content\\Shaders\\";
const std::wstring PathFromExeToHlsl = L"..\\..\\Code\\OysterGraphics\\Shader\\HLSL\\";
const std::wstring VertexTransformDebug = L"TransformDebugVertex";
const std::wstring VertexDebug = L"DebugVertex";
const std::wstring PixelRed = L"DebugPixel";
const std::wstring PixelTexture = L"Texture";
const std::wstring ComputeDebug = L"Debug";
typedef Oyster::Graphics::Core::PipelineManager::ShaderType ShaderType;
typedef Oyster::Graphics::Core::PipelineManager::Get GetShader;
typedef Oyster::Graphics::Core::PipelineManager Shader;
typedef Oyster::Graphics::Core::Buffer Buffer;
namespace Oyster
{
namespace Graphics
{
namespace Render
{
//Shader::RenderPass Resources::Debug::obj;
Shader::RenderPass Resources::Debug::debugCompute;// = Shader::ShaderEffect();;
//Buffer Resources::Debug::ModelData = Buffer();
//Buffer Resources::Debug::VPData = Buffer();
//ID3D11ShaderResourceView* Resources::Debug::srv = NULL;
//ID3D11RenderTargetView* Resources::Debug::rtv = NULL;
Core::Init::State Resources::Debug::Init()
{
#pragma region LoadShaders
/** Load Compute Shaders for d3dcompile */
Core::PipelineManager::Init(PathFromExeToHlsl + L"ComputeDebug\\" + L"DebugCompute.hlsl", ShaderType::Compute, ComputeDebug);
#pragma endregion
return Core::Init::Success;
}
void Resources::Debug::Clean()
{
}
}
}
}
#endif

39
Code/OysterGraphics/Render/Resources/Debug.h Normal file
View File

@ -0,0 +1,39 @@
#pragma once
#ifndef Reources_h
#define Reources_h
#ifdef _DEBUG
#include "../OysterGraphics/Core/Core.h"
namespace Oyster
{
namespace Graphics
{
namespace Render
{
namespace Resources
{
class Debug
{
public:
//static Core::PipelineManager::RenderPass obj;
static Core::PipelineManager::RenderPass debugCompute;
//static Core::Buffer ModelData;
//static Core::Buffer VPData;
//static ID3D11ShaderResourceView* srv;
//static ID3D11RenderTargetView* rtv;
static Core::Init::State Init();
static void Clean();
};
}
}
}
}
#endif
#endif

227
Code/OysterGraphics/Render/Resources/Deffered.cpp Normal file
View File

@ -0,0 +1,227 @@
#pragma once
#include "Deffered.h"
#include "..\..\Definitions\GraphicalDefinition.h"
typedef Oyster::Graphics::Core::PipelineManager::ShaderType ShaderType;
typedef Oyster::Graphics::Core::PipelineManager::Get GetShader;
typedef Oyster::Graphics::Core::PipelineManager Shader;
typedef Oyster::Graphics::Core::Buffer Buffer;
const std::wstring PathToHLSL = L"..\\..\\Code\\OysterGraphics\\Shader\\HLSL\\Deffered Shaders\\";
const std::wstring PathToCSO = L"..\\Content\\Shaders\\";
namespace Oyster
{
namespace Graphics
{
namespace Render
{
namespace Resources
{
ID3D11RenderTargetView* Deffered::GBufferRTV[2] = {0};
ID3D11ShaderResourceView* Deffered::GBufferSRV[2] = {0};
Shader::RenderPass Deffered::GeometryPass;
Shader::RenderPass Deffered::LightPass;
Buffer Deffered::ModelData = Buffer();
Buffer Deffered::VPData = Buffer();
Buffer Deffered::LightConstantsData = Buffer();
Buffer Deffered::PointLightsData = Buffer();
ID3D11ShaderResourceView* Deffered::PointLightView = NULL;
Core::Init::State Deffered::Init()
{
#ifdef _DEBUG
std::wstring path = PathToHLSL;
std::wstring end = L".hlsl";
#else
std::wstring path = PathToCSO;
std::wstring end = L".cso";
#endif
//Load Shaders
Core::PipelineManager::Init(path + L"PixelGatherData" + end, ShaderType::Pixel, L"Geometry");
Core::PipelineManager::Init(path + L"VertexGatherData" + end, ShaderType::Vertex, L"Geometry");
Core::PipelineManager::Init(path + L"LightPass" + end, ShaderType::Compute, L"LightPass");
//Create Buffers
Buffer::BUFFER_INIT_DESC desc;
desc.ElementSize = sizeof(Oyster::Math::Matrix);
desc.NumElements = 1;
desc.InitData = NULL;
desc.Type = Buffer::BUFFER_TYPE::CONSTANT_BUFFER_VS;
desc.Usage = Buffer::BUFFER_USAGE::BUFFER_CPU_WRITE_DISCARD;
ModelData.Init(desc);
desc.NumElements = 2;
VPData.Init(desc);
desc.ElementSize = sizeof(Definitions::LightConstants);
desc.NumElements = 1;
desc.Type = Buffer::BUFFER_TYPE::CONSTANT_BUFFER_CS;
LightConstantsData.Init(desc);
desc.ElementSize = sizeof(Definitions::Pointlight);
desc.NumElements = MaxLightSize;
desc.Type = Buffer::STRUCTURED_BUFFER;
PointLightsData.Init(desc);
//Create States
D3D11_RASTERIZER_DESC rdesc;
rdesc.CullMode = D3D11_CULL_BACK;
rdesc.FillMode = D3D11_FILL_SOLID;
rdesc.FrontCounterClockwise = true;
rdesc.DepthBias = 0;
rdesc.DepthBiasClamp = 0;
rdesc.DepthClipEnable = true;
rdesc.SlopeScaledDepthBias = 0;
rdesc.ScissorEnable = false;
rdesc.MultisampleEnable = false;
rdesc.AntialiasedLineEnable = false;
ID3D11RasterizerState* rs = NULL;
Oyster::Graphics::Core::device->CreateRasterizerState(&rdesc,&rs);
D3D11_SAMPLER_DESC sdesc;
sdesc.Filter = D3D11_FILTER_ANISOTROPIC;
sdesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
sdesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
sdesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
sdesc.MipLODBias = 0;
sdesc.MaxAnisotropy =4;
sdesc.ComparisonFunc = D3D11_COMPARISON_LESS_EQUAL;
*sdesc.BorderColor = *Oyster::Math::Float4(1,1,1,1).element;
sdesc.MinLOD = 0;
sdesc.MaxLOD = D3D11_FLOAT32_MAX;
ID3D11SamplerState** ss = new ID3D11SamplerState*[1];
Oyster::Graphics::Core::device->CreateSamplerState(&sdesc,ss);
D3D11_DEPTH_STENCIL_DESC ddesc;
ddesc.DepthEnable = true;
ddesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
ddesc.DepthFunc = D3D11_COMPARISON_LESS;
ddesc.StencilEnable = true;
ddesc.StencilReadMask = 0xFF;
ddesc.StencilWriteMask = 0xFF;
ddesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
ddesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
ddesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
ddesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
ddesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
ddesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
ddesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
ddesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
ID3D11DepthStencilState* dsState;
Core::device->CreateDepthStencilState(&ddesc,&dsState);
//Create Views
for(int i = 0; i< Resources::Deffered::GBufferSize; ++i)
{
Core::Init::CreateLinkedShaderResourceFromTexture(&GBufferRTV[i],&GBufferSRV[i],NULL);
}
Buffer* b = &PointLightsData;
Core::Init::CreateLinkedShaderResourceFromStructuredBuffer(&b,&PointLightView,NULL);
//Create ShaderEffects
GeometryPass.Shaders.Pixel = GetShader::Pixel(L"Geometry");
GeometryPass.Shaders.Vertex = GetShader::Vertex(L"Geometry");
D3D11_INPUT_ELEMENT_DESC indesc[] =
{
{ "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 }
};
Shader::CreateInputLayout(indesc,3,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);
GeometryPass.RenderStates.Rasterizer = rs;
GeometryPass.RenderStates.SampleCount = 1;
GeometryPass.RenderStates.SampleState = ss;
GeometryPass.RenderStates.DepthStencil = dsState;
for(int i = 0; i<Deffered::GBufferSize;++i)
{
GeometryPass.RTV.push_back(GBufferRTV[i]);
}
GeometryPass.depth = Core::depthStencil;
LightPass.Shaders.Compute = GetShader::Compute(L"LightPass");
LightPass.UAV.Compute.push_back(Core::backBufferUAV);
for(int i = 0; i<Deffered::GBufferSize;++i)
{
LightPass.SRV.Compute.push_back(GBufferSRV[i]);
}
LightPass.SRV.Compute.push_back(Core::depthStencilUAV);
LightPass.CBuffers.Compute.push_back(LightConstantsData);
LightPass.SRV.Compute.push_back(PointLightView);
return Core::Init::State::Success;
}
void Deffered::Clean()
{
Resources::Deffered::ModelData.~Buffer();
Resources::Deffered::VPData.~Buffer();
Resources::Deffered::LightConstantsData.~Buffer();
Resources::Deffered::PointLightsData.~Buffer();
for(int i = 0; i< GBufferSize; ++i)
{
SAFE_RELEASE(GBufferRTV[i]);
SAFE_RELEASE(GBufferSRV[i]);
}
for(int i = 0; i < (int)GeometryPass.CBuffers.Vertex.size(); ++i)
{
SAFE_RELEASE(GeometryPass.CBuffers.Vertex[i]);
}
for(int i = 0; i < (int)GeometryPass.CBuffers.Pixel.size(); ++i)
{
SAFE_RELEASE(GeometryPass.CBuffers.Pixel[i]);
}
for(int i = 0; i < (int)GeometryPass.CBuffers.Geometry.size(); ++i)
{
SAFE_RELEASE(GeometryPass.CBuffers.Geometry[i]);
}
for(int i = 0; i < (int)GeometryPass.CBuffers.Compute.size(); ++i)
{
SAFE_RELEASE(GeometryPass.CBuffers.Compute[i]);
}
SAFE_RELEASE(GeometryPass.IAStage.Layout);
SAFE_RELEASE(GeometryPass.RenderStates.BlendState);
SAFE_RELEASE(GeometryPass.RenderStates.DepthStencil);
SAFE_RELEASE(GeometryPass.RenderStates.Rasterizer);
for(int i = 0; i < GeometryPass.RenderStates.SampleCount; ++i)
{
SAFE_RELEASE(GeometryPass.RenderStates.SampleState[i]);
}
SAFE_DELETE_ARRAY(GeometryPass.RenderStates.SampleState);
}
}
}
}
}

42
Code/OysterGraphics/Render/Resources/Deffered.h Normal file
View File

@ -0,0 +1,42 @@
#pragma once
#include "../../Core/Core.h"
namespace Oyster
{
namespace Graphics
{
namespace Render
{
namespace Resources
{
class Deffered
{
public:
static const int GBufferSize = 2;
static const int MaxLightSize = 100;
//! GBuffers
//! 0 = Diffuse + SpecKoeff
//! 1 = Normal + Glow
static ID3D11RenderTargetView* GBufferRTV[GBufferSize];
static ID3D11ShaderResourceView* GBufferSRV[GBufferSize];
static Core::PipelineManager::RenderPass GeometryPass;
static Core::PipelineManager::RenderPass LightPass;
static Core::Buffer ModelData;
static Core::Buffer VPData;
static Core::Buffer LightConstantsData;
static Core::Buffer PointLightsData;
static ID3D11ShaderResourceView* PointLightView;
static Core::Init::State Init();
static void Clean();
};
}
}
}
}

192
Code/OysterGraphics/Render/Resources/Resources.cpp
View File

@ -1,192 +0,0 @@
#include "Resources.h"
#include "..\OysterGraphics\Definitions\GraphicalDefinition.h"
// /Bin/Executable/Tester ->
// /Code/OysterGraphics/Shader/HLSL
const std::wstring PathFromExeToCso = L"..\\Content\\Shaders\\";
const std::wstring PathFromExeToHlsl = L"..\\..\\Code\\OysterGraphics\\Shader\\HLSL\\";
const std::wstring VertexTransformDebug = L"TransformDebugVertex";
const std::wstring VertexDebug = L"DebugVertex";
const std::wstring PixelRed = L"DebugPixel";
const std::wstring PixelTexture = L"Texture";
typedef Oyster::Graphics::Core::ShaderManager::ShaderType ShaderType;
typedef Oyster::Graphics::Core::ShaderManager::Get GetShader;
typedef Oyster::Graphics::Core::ShaderManager Shader;
typedef Oyster::Graphics::Core::Buffer Buffer;
namespace Oyster
{
namespace Graphics
{
namespace Render
{
Shader::ShaderEffect Resources::obj;// = Shader::ShaderEffect();;
Buffer Resources::ModelData = Buffer();
Buffer Resources::VPData = Buffer();
Core::Init::State Resources::Init()
{
#pragma region LoadShaders
#ifdef _DEBUG
/** Load Vertex Shader for d3dcompile*/
Core::ShaderManager::Init(PathFromExeToHlsl + L"SimpleDebug\\" +L"DebugCameraVertex.hlsl",ShaderType::Vertex, VertexTransformDebug);
Core::ShaderManager::Init(PathFromExeToHlsl + L"SimpleDebug\\" +L"DebugVertex.hlsl",ShaderType::Vertex, VertexDebug);
/** Load Pixel Shader for d3dcompile */
Core::ShaderManager::Init(PathFromExeToHlsl + L"SimpleDebug\\" + L"DebugPixel.hlsl", ShaderType::Pixel, PixelRed);
Core::ShaderManager::Init(PathFromExeToHlsl + L"SimpleDebug\\" + L"TextureDebug.hlsl", ShaderType::Pixel, PixelTexture);
#else
/** Load Vertex Shader with Precompiled */
Core::ShaderManager::Init(PathFromExeToCso + L"DebugCameraVertex.cso",ShaderType::Vertex, VertexTransformDebug);
Core::ShaderManager::Init(PathFromExeToCso + L"DebugVertex.cso",ShaderType::Vertex, VertexDebug);
/** Load Pixel Shader with Precompiled */
Core::ShaderManager::Init(PathFromExeToCso + L"DebugPixel.cso",ShaderType::Pixel, PixelRed);
Core::ShaderManager::Init(PathFromExeToCso + L"TextureDebug.cso",ShaderType::Pixel, PixelTexture);
#endif
#pragma endregion
#pragma region CreateBuffers
Buffer::BUFFER_INIT_DESC desc;
desc.ElementSize = sizeof(Oyster::Math::Matrix);
desc.NumElements = 1;
desc.InitData = NULL;
desc.Type = Buffer::BUFFER_TYPE::CONSTANT_BUFFER_VS;
desc.Usage = Buffer::BUFFER_USAGE::BUFFER_CPU_WRITE_DISCARD;
ModelData.Init(desc);
desc.NumElements = 2;
VPData.Init(desc);
#pragma endregion
#pragma region Setup Render States
/** @todo Create DX States */
D3D11_RASTERIZER_DESC rdesc;
rdesc.CullMode = D3D11_CULL_BACK;
rdesc.FillMode = D3D11_FILL_SOLID;
rdesc.FrontCounterClockwise = true;
rdesc.DepthBias = 0;
rdesc.DepthBiasClamp = 0;
rdesc.DepthClipEnable = true;
rdesc.SlopeScaledDepthBias = 0;
rdesc.ScissorEnable = false;
rdesc.MultisampleEnable = false;
rdesc.AntialiasedLineEnable = false;
ID3D11RasterizerState* rs = NULL;
Oyster::Graphics::Core::device->CreateRasterizerState(&rdesc,&rs);
D3D11_SAMPLER_DESC sdesc;
sdesc.Filter = D3D11_FILTER_ANISOTROPIC;
/// @todo parata med fredrik om wraping
sdesc.AddressU = D3D11_TEXTURE_ADDRESS_CLAMP;
sdesc.AddressV = D3D11_TEXTURE_ADDRESS_CLAMP;
sdesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
sdesc.MipLODBias = 0;
sdesc.MaxAnisotropy =4;
sdesc.ComparisonFunc = D3D11_COMPARISON_LESS_EQUAL;
*sdesc.BorderColor = *Oyster::Math::Float4(1,1,1,1).element;
sdesc.MinLOD = 0;
sdesc.MaxLOD = D3D11_FLOAT32_MAX;
ID3D11SamplerState** ss = new ID3D11SamplerState*[1];
Oyster::Graphics::Core::device->CreateSamplerState(&sdesc,ss);
D3D11_DEPTH_STENCIL_DESC ddesc;
ddesc.DepthEnable = true;
ddesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
ddesc.DepthFunc = D3D11_COMPARISON_LESS;
ddesc.StencilEnable = true;
ddesc.StencilReadMask = 0xFF;
ddesc.StencilWriteMask = 0xFF;
ddesc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
ddesc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR;
ddesc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
ddesc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
ddesc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
ddesc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR;
ddesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
ddesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
ID3D11DepthStencilState* dsState;
Core::device->CreateDepthStencilState(&ddesc,&dsState);
#pragma endregion
#pragma region Setup Views
/** @todo Create Views */
#pragma endregion
#pragma region Create Shader Effects
/** @todo Create ShaderEffects */
obj.Shaders.Pixel = GetShader::Pixel(PixelTexture);
obj.Shaders.Vertex = GetShader::Vertex(VertexTransformDebug);
D3D11_INPUT_ELEMENT_DESC indesc[] =
{
{ "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 }
};
Shader::CreateInputLayout(indesc,3,GetShader::Vertex(VertexTransformDebug),obj.IAStage.Layout);
obj.IAStage.Topology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
obj.CBuffers.Vertex.push_back(&VPData);
obj.RenderStates.Rasterizer = rs;
obj.RenderStates.SampleCount = 1;
obj.RenderStates.SampleState = ss;
obj.RenderStates.DepthStencil = dsState;
ModelData.Apply(1);
#pragma endregion
return Core::Init::Sucsess;
}
void Resources::Clean()
{
Resources::ModelData.~Buffer();
for(int i = 0; i < obj.CBuffers.Vertex.size(); ++i)
{
obj.CBuffers.Vertex[i]->~Buffer();
}
for(int i = 0; i < obj.CBuffers.Pixel.size(); ++i)
{
SAFE_DELETE(obj.CBuffers.Pixel[i]);
}
for(int i = 0; i < obj.CBuffers.Geometry.size(); ++i)
{
SAFE_DELETE(obj.CBuffers.Geometry[i]);
}
SAFE_RELEASE(obj.IAStage.Layout);
SAFE_RELEASE(obj.RenderStates.BlendState);
SAFE_RELEASE(obj.RenderStates.DepthStencil);
SAFE_RELEASE(obj.RenderStates.Rasterizer);
for(int i = 0; i < obj.RenderStates.SampleCount; ++i)
{
SAFE_RELEASE(obj.RenderStates.SampleState[i]);
}
SAFE_DELETE_ARRAY(obj.RenderStates.SampleState);
}
}
}
}

29
Code/OysterGraphics/Render/Resources/Resources.h
View File

@ -1,29 +0,0 @@
#pragma once
#ifndef Reources_h
#define Reources_h
#include <map>
#include "../OysterGraphics/Core/Core.h"
namespace Oyster
{
namespace Graphics
{
namespace Render
{
class Resources
{
public:
static Core::ShaderManager::ShaderEffect obj;
static Core::Buffer ModelData;
static Core::Buffer VPData;
static Core::Init::State Init();
static void Clean();
};
}
}
}
#endif

22
Code/OysterGraphics/Shader/HLSL/Deffered Shaders/Render/Defines.hlsli → Code/OysterGraphics/Shader/HLSL/Deffered Shaders/Defines.hlsli
View File

@ -3,8 +3,10 @@
struct PointLight
{
float4 PosRadius;
float4 ColorBright;
float3 Pos;
float Radius;
float3 Color;
float Bright;
};
struct DiffSpec
@ -13,19 +15,21 @@ struct DiffSpec
float3 Specular;
};
cbuffer PointLights : register(b0)
{
PointLight pl;
}
cbuffer LightConstants : register(b1)
cbuffer LightConstants : register(b0)
{
float4x4 InvProj;
int2 Pixels;
float2 Pixels;
int Lights;
float Pad;
}
Texture2D DiffuseGlow : register(t0);
Texture2D NormalSpec : register(t1);
Texture2D DepthTexture : register(t2);
StructuredBuffer<PointLight> Points : register(t3);
RWTexture2D<float4> Output : register(u0);
#endif

16
Code/OysterGraphics/Shader/HLSL/Deffered Shaders/GatherGBuffer/GBufferHeader.hlsli → Code/OysterGraphics/Shader/HLSL/Deffered Shaders/GBufferHeader.hlsli
View File

@ -3,10 +3,10 @@ struct VertexIn
float3 pos : POSITION;
float2 UV : TEXCOORD;
float3 normal : NORMAL;
float3 tangent : TANGENT;
float3 biTangent : BITANGENT;
float4 boneIndex : BONEINDEX;
float4 boneWeight : BONEWEIGHT;
//float3 tangent : TANGENT;
//float3 biTangent : BITANGENT;
//float4 boneIndex : BONEINDEX;
//float4 boneWeight : BONEWEIGHT;
};
struct VertexOut
@ -15,8 +15,8 @@ struct VertexOut
float4 ViewPos : POSITION;
float2 UV : TEXCOORD;
float3 normal : NORMAL;
float3 tangent : TANGENT;
float3 biTangent : BITANGENT;
//float3 tangent : TANGENT;
//float3 biTangent : BITANGENT;
};
struct PixelOut
@ -26,7 +26,9 @@ struct PixelOut
};
Texture2D Diffuse : register(t0);
Texture2D Specular : register(t1);
Texture2D Normal : register(t1);
SamplerState S1 : register(s0);
cbuffer PerFrame : register(b0)
{

9
Code/OysterGraphics/Shader/HLSL/Deffered Shaders/GatherGBuffer/PixelGatherData.hlsl
View File

@ -1,9 +0,0 @@
#include "GBufferHeader.hlsli"
PixelOut main(VertexOut input)
{
PixelOut output;
output.DiffuseGlow = float4(1.0f, 0.0f, 0.0f, 1.0f);
output.NormalSpec = float4(input.normal, 1.0f);
return output;
}

12
Code/OysterGraphics/Shader/HLSL/Deffered Shaders/GatherGBuffer/VertexGatherData.hlsl
View File

@ -1,12 +0,0 @@
#include "GBufferHeader.hlsli"
VertexOut main( VertexIn input )
{
VertexOut output;
matrix WV = mul(View, World);
output.ViewPos = mul(WV, float4(input.pos,1));
output.pos = mul(Projection, output.ViewPos);
output.UV = input.UV;
output.normal = float4(input.normal, 0);
return output;
}

15
Code/OysterGraphics/Shader/HLSL/Deffered Shaders/Render/LightCalc.hlsli → Code/OysterGraphics/Shader/HLSL/Deffered Shaders/LightCalc.hlsli
View File

@ -4,7 +4,7 @@ DiffSpec LightCalc(PointLight pl, float3 pos, int2 texCoord)
{
DiffSpec output;
float4 normalSpec = NormalSpec[texCoord];
float3 lightVec = pl.PosRadius.xyz - pos.xyz;
float3 lightVec = pl.Pos - pos.xyz;
float d = length(lightVec);
lightVec = lightVec/d;
@ -12,12 +12,17 @@ DiffSpec LightCalc(PointLight pl, float3 pos, int2 texCoord)
float3 v = reflect(-lightVec, normalSpec.xyz);
float specFactor = pow(max(dot(v,normalize(-pos)), 0.0f),normalSpec.w);
//Check att later
float att = (max(d-pl.PosRadius.w,0)/pow(pl.PosRadius.w,2));
float att = max( 0, 1 - (d / pl.Radius));
//att = 1;
//fix Ilum calcs instead of PhongBlinn
output.Diffuse = pl.ColorBright.w * att * diffFactor * pl.ColorBright.xyz;
output.Specular = pl.ColorBright.w * att * specFactor * pl.ColorBright.xyz;
output.Diffuse = pl.Bright * att * diffFactor * pl.Color;
output.Specular = pl.Bright * att * specFactor * pl.Color;
if(diffFactor == 0)
output.Specular * 0;
if(d > pl.Radius)
{
output.Diffuse = float4(0,0,0,1);
output.Specular = float4(0,0,0,1);
}
return output;
}

31
Code/OysterGraphics/Shader/HLSL/Deffered Shaders/LightPass.hlsl Normal file
View File

@ -0,0 +1,31 @@
#include "Defines.hlsli"
#include "LightCalc.hlsli"
#include "PosManipulation.hlsli"
//todo
//LightCulling
//Calc Diff + Spec
//Calc Ambience
//Write Glow
[numthreads(16, 16, 1)]
void main( uint3 DTid : SV_DispatchThreadID )
{
float3 ViewPos = ToVpos(DTid.xy);
DiffSpec Shaded;
Shaded.Diffuse = float4(0,0,0,0);
Shaded.Specular = float4(0,0,0,0);
for(int i = 0; i < Lights; ++i)
{
DiffSpec light = LightCalc(Points[i], ViewPos, DTid.xy);
Shaded.Diffuse = light.Diffuse;
Shaded.Specular = light.Specular;
}
//Output[DTid.xy] = float4(ViewPos,1);
//Output[DTid.xy] = DepthTexture[DTid.xy].x;
//Output[DTid.xy] = float4(DTid.xy/ Pixels,1,1);
//Output[DTid.xy] = NormalSpec[DTid.xy];
//Output[DTid.xy] = float4(light.Diffuse, 1);
//Output[DTid.xy] = float4(light.Specular, 1);
Output[DTid.xy] = float4( Shaded.Diffuse * DiffuseGlow[DTid.xy].xyz + /*Shaded.Specular +*/ DiffuseGlow[DTid.xy].xyz * 0.2f, 1);
}

9
Code/OysterGraphics/Shader/HLSL/Deffered Shaders/PixelGatherData.hlsl Normal file
View File

@ -0,0 +1,9 @@
#include "GBufferHeader.hlsli"
PixelOut main(VertexOut input)
{
PixelOut output;
output.DiffuseGlow = Diffuse.Sample(S1, input.UV);
output.NormalSpec = float4(normalize(input.normal), 1.0f);
return output;
}

7
Code/OysterGraphics/Shader/HLSL/Deffered Shaders/Render/PosManipulation.hlsli → Code/OysterGraphics/Shader/HLSL/Deffered Shaders/PosManipulation.hlsli
View File

@ -4,18 +4,19 @@
float3 ToVpos(float2 texCoord)
{
//Get proper UV
float2 UV = float2(texCoord) / float2(Pixels);
float2 UV = texCoord / Pixels;
float4 ViewPos;
float4 ViewPos = float4(0,0,0,0);
// Get the depth value for this pixel
ViewPos.z= DepthTexture[texCoord].x;
//Get X/w
ViewPos.x = UV.x * 2 - 1;
//Get Y/w
//ViewPos.y = -(UV.y * 2) + 1;
ViewPos.y = 1 - 2 * UV.y;
ViewPos.w = 1;
//Un project
ViewPos = mul(ViewPos, InvProj);
ViewPos = mul(InvProj, ViewPos);
return ViewPos.xyz / ViewPos.w;
}

16
Code/OysterGraphics/Shader/HLSL/Deffered Shaders/Render/LightPass.hlsl
View File

@ -1,16 +0,0 @@
#include "Defines.hlsli"
#include "LightCalc.hlsli"
#include "PosManipulation.hlsli"
//todo
//LightCulling
//Calc Diff + Spec
//Calc Ambience
//Write Glow
[numthreads(1, 1, 1)]
void main( uint3 DTid : SV_DispatchThreadID )
{
float3 ViewPos = ToVpos(DTid.xy);
//DiffSpec LightCalc(pl, float3 pos)
}

17
Code/OysterGraphics/Shader/HLSL/Deffered Shaders/VertexGatherData.hlsl Normal file
View File

@ -0,0 +1,17 @@
#include "GBufferHeader.hlsli"
VertexOut main( VertexIn input )
{
VertexOut output;
float4 WorldPos = mul(World, float4(input.pos,1));
float4 ViewPos = mul(View, WorldPos);
output.pos = mul(Projection, ViewPos);
float4 WorldNor = mul(World, float4(input.normal,0));
float4 ViewNor = mul(View, WorldNor);
output.normal = ViewNor;
output.normal.z *= -1;
output.UV = input.UV;
//output.normal = ViewNor;
return output;
}

26
Code/Tester/MainTest.cpp
View File

@ -19,6 +19,7 @@ HINSTANCE g_hInst = NULL;
HWND g_hWnd = NULL;
Oyster::Graphics::Model::Model* m = NULL;
Oyster::Graphics::Model::Model* m2 = NULL;
Oyster::Graphics::Model::Model* m3 = NULL;
Oyster::Math::Float4x4 V;
Oyster::Math::Float4x4 P;
@ -188,9 +189,11 @@ HRESULT InitDirect3D()
#pragma endregion
#pragma region Obj
m = Oyster::Graphics::API::CreateModel(L"crate");
m2 = Oyster::Graphics::API::CreateModel(L"crate");
m = Oyster::Graphics::API::CreateModel(L"Orca");
m2 = Oyster::Graphics::API::CreateModel(L"identityCube");
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"identityCube");
m3->WorldMatrix = Oyster::Math3D::OrientationMatrix(Oyster::Math::Float3::null,Oyster::Math::Float3(0,5,0),Oyster::Math::Float3::null);
#pragma endregion
@ -199,7 +202,18 @@ HRESULT InitDirect3D()
P.Invert();
V = Oyster::Math3D::OrientationMatrix_LookAtDirection(Oyster::Math::Float3(0,0,-1),Oyster::Math::Float3(0,1,0),Oyster::Math::Float3(0,0,5.4f));
V = Oyster::Math3D::InverseOrientationMatrix(V);
//V = Oyster::Math3D::OrientationMatrix_LookAtPos(Oyster::Math::Float3(0,0,0), Oyster::Math::Float3(0,1,0), Oyster::Math::Float3(0,0,-5.4f));
//V.v[3][2] *= -1;
V = V.GetInverse();
Oyster::Graphics::Definitions::Pointlight pl;
pl.Color = Oyster::Math::Float3(1,1,1);
pl.Bright = 30;
pl.Pos = (V * Oyster::Math::Float4(Oyster::Math::Float3(5,-5,5.4f), 1)).xyz;
pl.Radius = 15;
Oyster::Graphics::API::AddLight(pl);
return S_OK;
@ -207,9 +221,10 @@ HRESULT InitDirect3D()
float angle = 0;
HRESULT Update(float deltaTime)
{
angle += Oyster::Math::pi/30000;
angle += Oyster::Math::pi/10000;
m->WorldMatrix = Oyster::Math3D::RotationMatrix_AxisY(angle);
m2->WorldMatrix = Oyster::Math3D::OrientationMatrix(Oyster::Math::Float3(0,0,1)*-angle,Oyster::Math::Float3(0,4,0),Oyster::Math::Float3::null);
m2->WorldMatrix = Oyster::Math3D::OrientationMatrix(Oyster::Math::Float3(1,0,0)*-angle,Oyster::Math::Float3(0,-4,0),Oyster::Math::Float3::null);
m3->WorldMatrix = Oyster::Math3D::OrientationMatrix(Oyster::Math::Float3(1,0,0)*-0,Oyster::Math::Float3(3,4,-1*angle),Oyster::Math::Float3::null);
return S_OK;
}
@ -220,6 +235,7 @@ HRESULT Render(float deltaTime)
Oyster::Graphics::API::RenderModel(*m);
Oyster::Graphics::API::RenderModel(*m2);
Oyster::Graphics::API::RenderModel(*m3);
Oyster::Graphics::API::EndFrame();