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

Fixed OysterGraphics to compile. 

New baseline for engine.
This commit is contained in:
lanariel 2013-11-10 03:19:46 +01:00
parent 9edd98d2b9
commit c021187db9
15 changed files with 562 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
OysterGraphics/Core/Buffer.cpp
View File

@ -1,8 +1,9 @@
#include "Buffer.h"
#include "Core.h"
using namespace Oyster;
Buffer::Buffer()
Oyster::Buffer::Buffer()
{
mBuffer = NULL;
}
@ -118,6 +119,11 @@ HRESULT Buffer::Init(const BUFFER_INIT_DESC& initDesc)
bufferDesc.Usage = D3D11_USAGE_DYNAMIC;
bufferDesc.CPUAccessFlags |= D3D11_CPU_ACCESS_WRITE;
}
else if(mUsage == BUFFER_USAGE_IMMUTABLE)
{
bufferDesc.Usage = D3D11_USAGE_IMMUTABLE;
bufferDesc.CPUAccessFlags = 0;
}
//Desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bufferDesc.MiscFlags = 0;
@ -191,7 +197,7 @@ void Buffer::Unmap()
Oyster::Core::DeviceContext->Unmap( mBuffer, 0 );
}
Buffer::operator ID3D11Buffer *()
Oyster::Buffer::operator ID3D11Buffer *()
{
return this->mBuffer;
}

5
OysterGraphics/Core/Buffer.h
View File

@ -2,7 +2,7 @@
#ifndef CoreBuffer
#define CoreBuffer
#include "Core.h"
#include "CoreIncludes.h"
namespace Oyster
{
@ -28,7 +28,8 @@ namespace Oyster
BUFFER_CPU_WRITE,
BUFFER_CPU_WRITE_DISCARD,
BUFFER_CPU_READ,
BUFFER_USAGE_COUNT
BUFFER_USAGE_COUNT,
BUFFER_USAGE_IMMUTABLE
};
struct BUFFER_INIT_DESC

15
OysterGraphics/Core/Core.cpp
View File

@ -1,5 +1,4 @@
#include "Core.h"
#include "..\Window\Window.h"
using namespace Oyster;
using std::string;
@ -29,10 +28,10 @@ bool Core::Init(bool SingleThreaded, bool Reference,bool ForceDX11)
if(Reference)
driverType = D3D_DRIVER_TYPE_REFERENCE;
/*#if defined(DEBUG) || defined(_DEBUG)
#if defined(DEBUG) || defined(_DEBUG)
Log << "DirectX running in debug mode.\n";
createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif*/
#endif
D3D_FEATURE_LEVEL featureLevelsToTry[] =
@ -103,8 +102,14 @@ bool Core::CreateSwapChain(HWND Window, int NrofBuffers,bool MSAA_Quality,bool
desc.BufferDesc.Scaling = DXGI_MODE_SCALING_CENTERED;
desc.BufferDesc.RefreshRate.Denominator=1;
desc.BufferDesc.RefreshRate.Numerator=60;
desc.BufferDesc.Height = Window::Size.bottom;
desc.BufferDesc.Width = Window::Size.left;
RECT rc;
GetClientRect( Window, &rc );
int screenWidth = rc.right - rc.left;
int screenHeight = rc.bottom - rc.top;
desc.BufferDesc.Height = screenHeight;
desc.BufferDesc.Width = screenWidth;
//Check and Set multiSampling
if(MSAA_Quality)

85
OysterGraphics/Core/Core.h
View File

@ -6,6 +6,7 @@
#include "CoreIncludes.h"
#include <sstream>
#include "Buffer.h"
namespace Oyster
{
class Core
@ -23,6 +24,90 @@ namespace Oyster
static bool Init(bool SingleThreaded,bool Reference,bool ForceDX11);
static bool CreateSwapChain(HWND Window, int NrofBuffers,bool MSAA_Quality,bool Fullscreen);
class ShaderManager
{
public:
struct ShaderEffect
{
struct
{
int Pixel,Vertex,Geometry,Compute,Hull,Domain;
}Shaders;
struct IAStage_
{
ID3D11InputLayout* Layout;
D3D11_PRIMITIVE_TOPOLOGY Topology;
}IAStage;
struct RenderStates_
{
ID3D11DepthStencilState *DepthStencil;
ID3D11RasterizerState *Rasterizer;
ID3D11SamplerState **SampleState;
int SampleCount;
ID3D11BlendState *BlendState;
}RenderStates;
struct
{
std::vector<Oyster::Buffer*> Vertex;
std::vector<Oyster::Buffer*> Geometry;
std::vector<Oyster::Buffer*> Pixel;
}CBuffers;
ShaderEffect()
{
RenderStates.BlendState=NULL;
RenderStates.DepthStencil=NULL;
RenderStates.Rasterizer=NULL;
RenderStates.SampleState=NULL;
RenderStates.SampleCount=0;
Shaders.Compute=-1;
Shaders.Domain=-1;
Shaders.Geometry=-1;
Shaders.Hull=-1;
Shaders.Pixel=-1;
Shaders.Vertex=-1;
}
};
enum ShaderType
{
Vertex,
Hull,
Domain,
Geometry,
Pixel,
Compute
};
static void SetShaderEffect(ShaderEffect);
static void CreateInputLayout(const D3D11_INPUT_ELEMENT_DESC *desc, int ElementCount,int VertexIndex,ID3D11InputLayout *&Layout);
static bool Init(std::wstring filename, ShaderType type, std::wstring name, bool Precompiled = true);
struct Get
{
static int Pixel(std::wstring Name);
static int Vertex(std::wstring Name);
static int Geometry(std::wstring Name);
static int Compute(std::wstring Name);
static int Hull(std::wstring Name);
static int Domain(std::wstring Name);
};
struct Set
{
static void Pixel(int Index);
static void Vertex(int Index);
static void Geometry(int Index);
static void Compute(int Index);
static void Hull(int Index);
static void Domain(int Index);
};
};
};
}

23
OysterGraphics/Core/CoreIncludes.h
View File

@ -4,14 +4,14 @@
#define NOMINMAX // Because I hate Microsoft now. ~Angry Dan.
// http://lolengine.net/blog/2011/3/4/fuck-you-microsoft-near-far-macros
#include <WinSock2.h>
#include <windows.h>
#include <D3D11.h>
#include <D3DX11.h>
#include <D3DX10math.h>
#include <d3dx11effect.h>
#include <d3dCompiler.h>
#pragma comment(lib, "d3d11.lib")
#pragma comment(lib, "d3dcompiler.lib")
#include <string>
#include <vector>
#include <map>
@ -22,19 +22,4 @@
#define SAFE_DELETE_ARRAY(x) if( x ) { delete[](x); (x) = NULL; }
#define PI (3.14159265358979323846f)
#pragma comment(lib, "d3d11.lib")
#pragma comment(lib, "d3dcompiler.lib")
#pragma comment (lib,"dxerr.lib")
#ifdef _DEBUG
#pragma comment(lib, "d3dx11d.lib")
#pragma comment(lib, "Effects11D.lib")
#pragma comment(lib, "d3dx10d.lib")
#else
#pragma comment(lib, "d3dx11.lib")
#pragma comment(lib, "Effects11.lib")
#pragma comment(lib, "d3dx10.lib")
#endif
#endif

351
OysterGraphics/Core/ShaderManager.cpp Normal file
View File

@ -0,0 +1,351 @@
#include "Core.h"
#include <fstream>
const char* ShaderFunction = "ShaderMain";
namespace Oyster
{
bool LoadPrecompiled(std::wstring filename, Core::ShaderManager::ShaderType type, std::wstring name);
bool LoadCompile(std::wstring filename, Core::ShaderManager::ShaderType type, std::wstring name);
namespace
{
struct ShaderData
{
size_t size;
char* data;
};
std::vector<ID3D11PixelShader*> PS;
std::map<std::wstring,int> PSMap;
std::vector<ID3D11GeometryShader*> GS;
std::map<std::wstring,int> GSMap;
std::vector<ID3D11ComputeShader*> CS;
std::map<std::wstring,int> CSMap;
std::vector<ID3D11VertexShader*> VS;
std::vector<ShaderData> VData;
std::map<std::wstring,int> VSMap;
}
#pragma region Init
bool Core::ShaderManager::Init(std::wstring filename, ShaderType type, std::wstring name, bool Precompiled)
{
if(Precompiled)
{
return LoadPrecompiled(filename, type, name);
}
else
{
return LoadCompile(filename, type, name);
}
return true;
}
bool LoadPrecompiled(std::wstring filename, Core::ShaderManager::ShaderType type, std::wstring name)
{
std::ifstream stream;
ShaderData sd;
//Create Vertex shader and Layout
stream.open(filename, std::ifstream::in | std::ifstream::binary);
if(stream.good())
{
stream.seekg(0, std::ios::end);
sd.size = size_t(stream.tellg());
sd.data = new char[sd.size];
stream.seekg(0, std::ios::beg);
stream.read(&sd.data[0], sd.size);
stream.close();
ID3D11VertexShader* vertex;
ID3D11GeometryShader* geometry;
ID3D11PixelShader* pixel;
ID3D11ComputeShader* compute;
switch(type)
{
case Core::ShaderManager::ShaderType::Vertex:
if(VSMap.count(name))
return false;
if(FAILED(Core::Device->CreateVertexShader(sd.data, sd.size, 0, &vertex)))
{
return false;
}
VSMap[name] = VS.size();
VS.push_back(vertex);
VData.push_back(sd);
break;
case Core::ShaderManager::ShaderType::Hull:
case Core::ShaderManager::ShaderType::Domain:
return false;
case Core::ShaderManager::ShaderType::Geometry:
if(GSMap.count(name))
return false;
if(FAILED(Core::Device->CreateGeometryShader(sd.data, sd.size, 0, &geometry)))
{
return false;
}
GSMap[name] = GS.size();
GS.push_back(geometry);
break;
case Core::ShaderManager::ShaderType::Pixel:
if(PSMap.count(name))
return false;
if(FAILED(Core::Device->CreatePixelShader(sd.data, sd.size, 0, &pixel)))
{
return false;
}
PSMap[name] = PS.size();
PS.push_back(pixel);
break;
case Core::ShaderManager::ShaderType::Compute:
if(CSMap.count(name))
return false;
if(FAILED(Core::Device->CreateComputeShader(sd.data, sd.size, 0, &compute)))
{
return false;
}
CSMap[name] = CS.size();
CS.push_back(compute);
break;
}
}
else
{
return false;
}
return true;
}
bool LoadCompile(std::wstring filename, Core::ShaderManager::ShaderType type, std::wstring name)
{
/// \todo error reporting
ID3D10Blob *Shader,*Error;
switch(type)
{
case Core::ShaderManager::ShaderType::Pixel:
ID3D11PixelShader* pixel;
if(FAILED(D3DCompileFromFile(filename.c_str(),NULL,NULL,ShaderFunction,"ps_5_0",0,0,&Shader,&Error)))
{
std::string fel = (char*)Error->GetBufferPointer();
Error->Release();
return false;
}
if(FAILED(Oyster::Core::Device->CreatePixelShader(Shader->GetBufferPointer(),Shader->GetBufferSize(),NULL,&pixel)))
{
Error->Release();
Shader->Release();
return false;
}
Shader->Release();
if(!PSMap.count(name))
{
PSMap[name] = PS.size();
PS.push_back(pixel);
}
else
{
PS[PSMap[name]] = pixel;
}
break;
case Core::ShaderManager::ShaderType::Geometry:
ID3D11GeometryShader* geometry;
if(FAILED(D3DCompileFromFile(filename.c_str(),NULL,NULL,ShaderFunction,"gs_5_0",0,0,&Shader,&Error)))
{
std::string fel = (char*)Error->GetBufferPointer();
Error->Release();
return false;
}
if(FAILED(Oyster::Core::Device->CreateGeometryShader(Shader->GetBufferPointer(),Shader->GetBufferSize(),NULL,&geometry)))
{
Error->Release();
Shader->Release();
return false;
}
Shader->Release();
if(!GSMap.count(name))
{
GSMap[name] = GS.size();
GS.push_back(geometry);
}
else
{
GS[GSMap[name]] = geometry;
}
break;
case Core::ShaderManager::ShaderType::Vertex:
ID3D11VertexShader* vertex;
if(FAILED(D3DCompileFromFile(filename.c_str(),NULL,NULL,ShaderFunction,"vs_5_0",0,0,&Shader,&Error)))
{
std::string fel = (char*)Error->GetBufferPointer();
Error->Release();
return false;
}
if(FAILED(Oyster::Core::Device->CreateVertexShader(Shader->GetBufferPointer(),Shader->GetBufferSize(),NULL,&vertex)))
{
Error->Release();
Shader->Release();
return false;
}
if(!VSMap.count(name))
{
VSMap[name] = VS.size();
VS.push_back(vertex);
ShaderData sd;
sd.size = Shader->GetBufferSize();
sd.data = new char[sd.size];
memcpy(sd.data,Shader->GetBufferPointer(),sd.size);
VData.push_back(sd);
}
else
{
VS[VSMap[name]] = vertex;
delete[] VData[VSMap[name]].data;
VData[VSMap[name]].size = Shader->GetBufferSize();
VData[VSMap[name]].data = new char[VData[VSMap[name]].size];
memcpy(VData[VSMap[name]].data,Shader->GetBufferPointer(),VData[VSMap[name]].size);
}
Shader->Release();
break;
}
return true;
}
#pragma endregion
void Core::ShaderManager::CreateInputLayout(const D3D11_INPUT_ELEMENT_DESC *desc, int ElementCount,int VertexIndex,ID3D11InputLayout *&Layout)
{
if(VertexIndex==-1)
{
Layout=0;
return;
}
Device->CreateInputLayout(desc,ElementCount,VData[VertexIndex].data,VData[VertexIndex].size,&Layout);
}
#pragma region Get
int Core::ShaderManager::Get::Pixel(std::wstring Name)
{
if(PSMap.count(Name))
return PSMap[Name];
return -1;
}
int Core::ShaderManager::Get::Vertex(std::wstring Name)
{
if(VSMap.count(Name))
return VSMap[Name];
return -1;
}
int Core::ShaderManager::Get::Geometry(std::wstring Name)
{
if(GSMap.count(Name))
return GSMap[Name];
return -1;
}
int Core::ShaderManager::Get::Compute(std::wstring Name)
{
if(CSMap.count(Name))
return CSMap[Name];
return -1;
}
int Core::ShaderManager::Get::Hull(std::wstring Name)
{
return -1;
}
int Core::ShaderManager::Get::Domain(std::wstring Name)
{
return -1;
}
#pragma endregion
#pragma region Set
/// \todo smart set
void Core::ShaderManager::Set::Pixel(int Index)
{
if(Index==-1)
DeviceContext->PSSetShader( NULL,NULL,0);
else
DeviceContext->PSSetShader( PS[Index],NULL,0);
}
void Core::ShaderManager::Set::Vertex(int Index)
{
if(Index==-1)
DeviceContext->VSSetShader( NULL,NULL,0);
else
DeviceContext->VSSetShader( VS[Index],NULL,0);
}
void Core::ShaderManager::Set::Geometry(int Index)
{
if(Index==-1)
DeviceContext->GSSetShader( NULL,NULL,0);
else
DeviceContext->GSSetShader( GS[Index],NULL,0);
}
void Core::ShaderManager::Set::Compute(int Index)
{
if(Index==-1)
DeviceContext->CSSetShader( NULL,NULL,0);
else
DeviceContext->CSSetShader( CS[Index],NULL,0);
}
/// \todo set Hull
void Core::ShaderManager::Set::Hull(int Index)
{
return;
}
/// \todo set Domain
void Core::ShaderManager::Set::Domain(int Index)
{
return;
}
#pragma endregion
/// \todo smart Set ie. not resetting the shader
/// \todo research states
/// \todo smart buffer set
void Core::ShaderManager::SetShaderEffect(ShaderEffect se)
{
Set::Pixel(se.Shaders.Pixel);
Set::Vertex(se.Shaders.Vertex);
Set::Geometry(se.Shaders.Geometry);
Set::Compute(se.Shaders.Compute);
Oyster::Core::DeviceContext->IASetInputLayout(se.IAStage.Layout);
Oyster::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);
Oyster::Core::DeviceContext->RSSetState(se.RenderStates.Rasterizer);
Oyster::Core::DeviceContext->PSSetSamplers(0,se.RenderStates.SampleCount,se.RenderStates.SampleState);
float test[4] = {0};
Oyster::Core::DeviceContext->OMSetBlendState(se.RenderStates.BlendState,test,-1);
}
}

72
OysterGraphics/Engine.cpp
View File

@ -15,6 +15,7 @@ public:
DXGI_SAMPLE_DESC sampleDesc;
D3D11_VIEWPORT viewPort;
oysterPrivates():instance(false),swapChained(false),depth(NULL),rtv(NULL), depthTexture(NULL){};
int sizeX, sizeY;
class State
{
public:
@ -55,13 +56,11 @@ bool Oyster::Engine::Init::HasSwapChain()
bool Oyster::Engine::Init::CreateSwapChain(HWND Window,int NrofBuffers,bool MSAA_Quality,bool Fullscreen)
{
if(Window==0)
{
if(Oyster::Window::Handle==0)
return false;
else
Window = Oyster::Window::Handle;
}
RECT rc;
GetClientRect( Window, &rc );
instance.sizeX = rc.right - rc.left;
instance.sizeY = rc.bottom - rc.top;
if(!instance.swapChained)
{
if(Oyster::Core::CreateSwapChain(Window,NrofBuffers,MSAA_Quality,Fullscreen))
@ -71,11 +70,6 @@ bool Oyster::Engine::Init::CreateSwapChain(HWND Window,int NrofBuffers,bool MSAA
return instance.swapChained;
}
bool Oyster::Engine::Init::InitializeWindow(const LPCSTR appName, const LPCSTR className,const HINSTANCE &hInstance, const int &nCmdShow, WNDPROC wProc, bool handleLoop )
{
return Oyster::Window::init(appName,className,hInstance,nCmdShow,wProc,handleLoop);
}
bool Oyster::Engine::Init::FullInit(const Setup& setup)
{
if(!Oyster::Engine::Init::Instance(setup.Common.SingleThreaded,setup.Common.Reference,setup.Common.ForceDX11))
@ -104,7 +98,7 @@ bool Oyster::Engine::Init::FullInit(const Setup& setup)
Oyster::Resources::Buffers::Init();
Oyster::Resources::ShaderEffects::Init();
Oyster::Resources::PipeLineResourses::Init();
Oyster::Resources::PipeLineResourses::Init(instance.sizeX, instance.sizeY);
return true;
}
@ -186,7 +180,7 @@ void Oyster::Engine::Render::Geometry(const Oyster::Render::Model* models,int co
if(cBufferEveryObject)
{
void* data = cBufferEveryObject->Map();
memcpy(data,&(models[i].World->getTranspose()),64);
memcpy(data,&(models[i].World->GetTranspose()),64);
cBufferEveryObject->Unmap();
}
Oyster::Core::DeviceContext->PSSetShaderResources(0,models[i].info->Material.size(),&(models[i].info->Material[0]));
@ -205,23 +199,23 @@ void Oyster::Engine::Render::Geometry(const Oyster::Render::Model* models,int co
void Oyster::Engine::Render::Text(std::string text, Oyster::Math::Float2 size, Oyster::Math::Float3 Pos)
{
Pos.x -= Oyster::Window::Size.left/2;
Pos.x -= instance.sizeX/2;
Pos.x += size.x;
Pos.y -= Oyster::Window::Size.bottom/2;
Pos.y -= instance.sizeY/2;
Pos.y += size.y;
Matrix m;
Math::identityMatrix(m);
float width = (1.0f/(Window::Size.left/2.0f));
float height = (1.0f/(Window::Size.bottom/2.0f));
m = Math::Matrix::identity;
float width = (1.0f/(instance.sizeX/2.0f));
float height = (1.0f/(instance.sizeY/2.0f));
m.m41=Pos.x * width;
m.m42=-Pos.y * height;
m.m43=Pos.z;
m.m11=width*size.x;
m.m22=height*size.y;
void* dest = Resources::Buffers::CBufferGs.Map();
memcpy(dest,&m.getTranspose(),64);
memcpy(dest,&m.GetTranspose(),64);
Resources::Buffers::CBufferGs.Unmap();
Oyster::Render::Textbox::Update(text, size.x);
Oyster::Engine::PrepareForRendering::Begin2DTextRender();
@ -236,11 +230,11 @@ void Oyster::Engine::Render::ScreenQuad(ID3D11ShaderResourceView* srv, float ZPo
Oyster::Core::DeviceContext->PSSetShaderResources(0,1,&srv);
Matrix m;
Math::identityMatrix(m);
m = Math::Matrix::identity;
m.m43=ZPos;
void* dest = Resources::Buffers::CBufferGs.Map();
memcpy(dest,&m.getTranspose(),64);
memcpy(dest,&m.GetTranspose(),64);
Resources::Buffers::CBufferGs.Unmap();
Oyster::Core::DeviceContext->Draw(1,0);
@ -251,16 +245,16 @@ void Oyster::Engine::Render::Sprite(ID3D11ShaderResourceView* srv, Oyster::Math:
Oyster::Core::DeviceContext->PSSetShaderResources(0,1,&srv);
Pos.x -= Oyster::Window::Size.left/2;
Pos.x -= instance.sizeX/2;
Pos.x += size.x/2;
Pos.y -= Oyster::Window::Size.bottom/2;
Pos.y -= instance.sizeY/2;
Pos.y += size.y/2;
Matrix m;
Math::identityMatrix(m);
float width = (1.0f/(Window::Size.left/2.0f));
float height = (1.0f/(Window::Size.bottom/2.0f));
m = Math::Matrix::identity;
float width = (1.0f/(instance.sizeX/2.0f));
float height = (1.0f/(instance.sizeY/2.0f));
m.m41=Pos.x * width;
m.m42=-Pos.y * height;
m.m43=Pos.z;
@ -268,7 +262,7 @@ void Oyster::Engine::Render::Sprite(ID3D11ShaderResourceView* srv, Oyster::Math:
m.m22=height*size.y/2;
void* dest = Resources::Buffers::CBufferGs.Map();
memcpy(dest,&m.getTranspose(),64);
memcpy(dest,&m.GetTranspose(),64);
Resources::Buffers::CBufferGs.Unmap();
Oyster::Core::DeviceContext->Draw(1,0);
@ -286,8 +280,8 @@ bool CreateDepthStencil(bool MSAA_Quality)
desc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
desc.CPUAccessFlags=0;
desc.MiscFlags=0;
desc.Height = Oyster::Window::Size.bottom;
desc.Width = Oyster::Window::Size.left;
desc.Height = instance.sizeY;
desc.Width = instance.sizeX;
//Check and Set multiSampling
@ -355,8 +349,8 @@ void SetViewPort()
{
instance.viewPort.TopLeftX = 0.0f;
instance.viewPort.TopLeftY = 0.0f;
instance.viewPort.Width = (float)Oyster::Window::Size.left;
instance.viewPort.Height = (float)Oyster::Window::Size.bottom;
instance.viewPort.Width = (float)instance.sizeX;
instance.viewPort.Height = (float)instance.sizeY;
instance.viewPort.MinDepth = 0.0f;
instance.viewPort.MaxDepth = 1.0f;
@ -373,7 +367,7 @@ void Blur(int target)
//dispatch blurr horizontal
Oyster::Shader::Set::SetCompute(Oyster::Shader::Get::GetCompute("BlurHorizontal"));
Oyster::Core::DeviceContext->Dispatch(7,Oyster::Window::Size.bottom,1);
Oyster::Core::DeviceContext->Dispatch(7,instance.sizeX,1);
//clean Pipeline
Oyster::Core::DeviceContext->CSSetShaderResources(0,16,&Oyster::Resources::PipeLineResourses::SrvNulls[0]);
@ -385,7 +379,7 @@ void Blur(int target)
//dispatch blurr vertical
Oyster::Shader::Set::SetCompute(Oyster::Shader::Get::GetCompute("BlurVertical"));
Oyster::Core::DeviceContext->Dispatch(Oyster::Window::Size.left,5,1);
Oyster::Core::DeviceContext->Dispatch(instance.sizeY,5,1);
//clean Pipeline
Oyster::Core::DeviceContext->CSSetShaderResources(0,16,&Oyster::Resources::PipeLineResourses::SrvNulls[0]);
@ -419,24 +413,24 @@ void Oyster::Engine::Pipeline::Deffered_Lightning::NewFrame(const Float4& col, c
Matrix V = Oyster::Math::Float4x4(View);
Matrix VP = V*P;
Oyster::Resources::PipeLineResourses::LightData.projectionMatrix = P.getTranspose();
Oyster::Resources::PipeLineResourses::LightData.projectionMatrix = P.GetTranspose();
Oyster::Resources::PipeLineResourses::LightData.viewMatrix = V;
Oyster::Collision::Frustrum( VP ).split(Oyster::Resources::PipeLineResourses::SubFrustrums, Oyster::Resources::PipeLineResourses::FrustrumDimensions.x, Oyster::Resources::PipeLineResourses::FrustrumDimensions.y, Oyster::Resources::PipeLineResourses::FrustrumDimensions.z );
Oyster::Collision3D::Frustrum( VP ).Split(Oyster::Resources::PipeLineResourses::SubFrustrums, Oyster::Resources::PipeLineResourses::FrustrumDimensions.x, Oyster::Resources::PipeLineResourses::FrustrumDimensions.y, Oyster::Resources::PipeLineResourses::FrustrumDimensions.z );
void* dest = Oyster::Resources::ShaderEffects::ModelEffect.CBuffers.Vertex[0]->Map();
memcpy(dest,&VP.getTranspose(),64);
memcpy(dest,&VP.GetTranspose(),64);
Oyster::Resources::ShaderEffects::ModelEffect.CBuffers.Vertex[0]->Unmap();
dest= Oyster::Resources::ShaderEffects::ModelEffect.CBuffers.Vertex[1]->Map();
memcpy(dest,&V.getTranspose(),64);
memcpy(dest,&V.GetTranspose(),64);
Oyster::Resources::ShaderEffects::ModelEffect.CBuffers.Vertex[1]->Unmap();
dest = Oyster::Resources::PipeLineResourses::Resources[0]->Map();
unsigned int bytes=0;
for(int i=0;i<Oyster::Resources::PipeLineResourses::FrustrumSize;++i)
{
Oyster::Resources::PipeLineResourses::SubFrustrums[i].writeToByte( (unsigned char*)dest,bytes);
Oyster::Resources::PipeLineResourses::SubFrustrums[i].WriteToByte( (unsigned char*)dest,bytes);
}
Oyster::Resources::PipeLineResourses::Resources[0]->Unmap();

12
OysterGraphics/EngineIncludes.h
View File

@ -13,22 +13,14 @@
#include "Shader\Shader.h"
// Math
#include "Math\OysterMath.h"
#include "OysterMath.h"
// FileLoader
#include "FileLoader\ObjReader.h"
// Windows
#include "Window\Window.h"
// Input
#include "Input\InputController.h"
// Collision
#include "Collision\Collision.h"
#include "Collision\Frustrum.h"
// Game Definitions
#include "Game\OysterGame.h"
// Resources
#include "Resourses\ShaderEffects.h"

6
OysterGraphics/OysterGraphics.vcxproj
View File

@ -140,16 +140,14 @@
<ItemGroup>
<ClCompile Include="Core\Buffer.cpp" />
<ClCompile Include="Core\Core.cpp" />
<ClCompile Include="Core\ShaderManager.cpp" />
<ClCompile Include="Engine.cpp" />
<ClCompile Include="FileLoader\ObjReader.cpp" />
<ClCompile Include="Render\Camera.cpp" />
<ClCompile Include="Render\Model.cpp" />
<ClCompile Include="Render\TextBox.cpp" />
<ClCompile Include="Resourses\Buffers.cpp" />
<ClCompile Include="Resourses\Manager.cpp" />
<ClCompile Include="Resourses\PipelineResources.cpp" />
<ClCompile Include="Resourses\ShaderEffects.cpp" />
<ClCompile Include="Shader\Shader.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="Core\Buffer.h" />
@ -158,7 +156,6 @@
<ClInclude Include="Engine.h" />
<ClInclude Include="EngineIncludes.h" />
<ClInclude Include="FileLoader\ObjReader.h" />
<ClInclude Include="Render\Camera.h" />
<ClInclude Include="Render\Lights.h" />
<ClInclude Include="Render\Model.h" />
<ClInclude Include="Render\ModelInfo.h" />
@ -168,7 +165,6 @@
<ClInclude Include="Resourses\Manager.h" />
<ClInclude Include="Resourses\PipelineResources.h" />
<ClInclude Include="Resourses\ShaderEffects.h" />
<ClInclude Include="Shader\Shader.h" />
</ItemGroup>
<ItemGroup>
<FxCompile Include="Shader\HLSL\2D.hlsl">

22
OysterGraphics/OysterGraphics.vcxproj.filters
View File

@ -21,12 +21,6 @@
<ClCompile Include="Core\Core.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="FileLoader\ObjReader.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="Render\Camera.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="Render\Model.cpp">
<Filter>Source Files</Filter>
</ClCompile>
@ -45,10 +39,10 @@
<ClCompile Include="Resourses\ShaderEffects.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="Shader\Shader.cpp">
<ClCompile Include="Engine.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="Engine.cpp">
<ClCompile Include="Core\ShaderManager.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
@ -62,12 +56,6 @@
<ClInclude Include="Core\CoreIncludes.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="FileLoader\ObjReader.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="Render\Camera.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="Render\Lights.h">
<Filter>Header Files</Filter>
</ClInclude>
@ -95,15 +83,15 @@
<ClInclude Include="Resourses\ShaderEffects.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="Shader\Shader.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="Engine.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="EngineIncludes.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="FileLoader\ObjReader.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<FxCompile Include="Shader\HLSL\2D.hlsl" />

2
OysterGraphics/Render/Camera.h
View File

@ -1,6 +1,6 @@
#pragma once
#include "..\Math\OysterMath.h"
#include "OysterMath.h"
namespace Oyster
{

6
OysterGraphics/Render/TextBox.cpp
View File

@ -19,12 +19,14 @@ bool Textbox::Init()
return true;
//return true;
}
/// \todo proper reading of texture
bool Textbox::SetTexture(const char* _file)
{
if(FAILED(D3DX11CreateShaderResourceViewFromFileA(Oyster::Core::Device, _file, NULL, NULL, &Texture, NULL)))
return false;
/*if(FAILED(D3DX11CreateShaderResourceViewFromFileA(Oyster::Core::Device, _file, NULL, NULL, &Texture, NULL)))
{
return false;
}
}*/
return true;
}
bool Textbox::UpdateTextField(std::string _str)

66
OysterGraphics/Resourses/Manager.cpp
View File

@ -4,44 +4,44 @@ std::unordered_map< std::string, Oyster::Render::ModelInfo*> Oyster::Resources::
Oyster::Render::Model* Oyster::Resources::Manager::LoadModel(std::string Filename, Matrix Scale)
{
//TODO: Add redundncy sheck, to ensure not recreating model
////TODO: Add redundncy sheck, to ensure not recreating model
//Loop to find filename
////Loop to find filename
//If found Return Model
////If found Return Model
//else Create Model
////else Create Model
Oyster::FileLoaders::ObjReader *reader = Oyster::FileLoaders::ObjReader::LoadFile(Filename, Scale);
Oyster::FileLoaders::ObjReader::Vertex** vertex = new Oyster::FileLoaders::ObjReader::Vertex*[1];
int vcount;
std::map<std::string,ID3D11ShaderResourceView *> textures;
reader->GetVertexData( vertex, vcount, textures );
//Oyster::FileLoaders::ObjReader *reader = Oyster::FileLoaders::ObjReader::LoadFile(Filename, Scale);
//Oyster::FileLoaders::ObjReader::Vertex** vertex = new Oyster::FileLoaders::ObjReader::Vertex*[1];
//int vcount;
//std::map<std::string,ID3D11ShaderResourceView *> textures;
//reader->GetVertexData( vertex, vcount, textures );
Oyster::Buffer::BUFFER_INIT_DESC desc;
desc.ElementSize=sizeof(Oyster::FileLoaders::ObjReader::Vertex);
desc.NumElements = vcount;
desc.InitData = *vertex;
desc.Type = Oyster::Buffer::VERTEX_BUFFER;
desc.Usage = Oyster::Buffer::BUFFER_DEFAULT;
//Oyster::Buffer::BUFFER_INIT_DESC desc;
//desc.ElementSize=sizeof(Oyster::FileLoaders::ObjReader::Vertex);
//desc.NumElements = vcount;
//desc.InitData = *vertex;
//desc.Type = Oyster::Buffer::VERTEX_BUFFER;
//desc.Usage = Oyster::Buffer::BUFFER_DEFAULT;
//
//ID3D11ShaderResourceView *srv = textures["Diffuse"];
ID3D11ShaderResourceView *srv = textures["Diffuse"];
Oyster::Render::ModelInfo* m = new Oyster::Render::ModelInfo();
m->Vertices = *(Oyster::Engine::Init::Buffers::CreateBuffer(desc));
m->VertexCount = vcount;
m->Material.push_back(srv);
srv = textures["Specular"];
m->Material.push_back(srv);
srv = textures["Glow"];
m->Material.push_back(srv);
m->Indexed=false;
Oyster::Render::Model* model = new Oyster::Render::Model();
model->info=m;
model->Visible = true;
model->World = &Oyster::Math::Float4x4(Oyster::Math::Float4x4::identity);
return model;
//Oyster::Render::ModelInfo* m = new Oyster::Render::ModelInfo();
//
//m->Vertices = *(Oyster::Engine::Init::Buffers::CreateBuffer(desc));
//m->VertexCount = vcount;
//m->Material.push_back(srv);
//srv = textures["Specular"];
//m->Material.push_back(srv);
//srv = textures["Glow"];
//m->Material.push_back(srv);
//m->Indexed=false;
//
//Oyster::Render::Model* model = new Oyster::Render::Model();
//model->info=m;
//model->Visible = true;
//model->World = &Oyster::Math::Float4x4(Oyster::Math::Float4x4::identity);
return NULL;
}

34
OysterGraphics/Resourses/PipelineResources.cpp
View File

@ -18,29 +18,29 @@ ID3D11RenderTargetView* PipeLineResourses::RtvNulls[16] = {0};
ID3D11ShaderResourceView* PipeLineResourses::SrvNulls[16] = {0};
ID3D11UnorderedAccessView* PipeLineResourses::uavNULL[16] = {0};
Oyster::Collision::Frustrum* PipeLineResourses::SubFrustrums = 0;
Oyster::Collision3D::Frustrum* PipeLineResourses::SubFrustrums = 0;
int PipeLineResourses::FrustrumSize = 0;
LinearAlgebra::Vector3<unsigned int> PipeLineResourses::FrustrumDimensions = LinearAlgebra::Vector3<unsigned int>();
Oyster::Resources::BufferDefinitions::LightStructureBuffer PipeLineResourses::LightData = Oyster::Resources::BufferDefinitions::LightStructureBuffer();
void PipeLineResourses::Init()
void PipeLineResourses::Init(int sizeX, int sizeY)
{
InitGeometry();
InitGeometry(sizeX, sizeY);
InitSSAOData();
InitSubFrustrums();
InitSubFrustrums(sizeX, sizeY);
InitPointLights();
InitLightData();
InitLighting();
InitLighting(sizeX, sizeY);
}
void PipeLineResourses::InitGeometry()
void PipeLineResourses::InitGeometry(int sizeX, int sizeY)
{
D3D11_TEXTURE2D_DESC Tdesc;
Tdesc.Width = Oyster::Window::Size.left;
Tdesc.Height = Oyster::Window::Size.bottom;
Tdesc.Width = sizeX;
Tdesc.Height = sizeY;
Tdesc.MipLevels = Tdesc.ArraySize = 1;
Tdesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
Tdesc.SampleDesc.Count = 1;
@ -86,7 +86,7 @@ void PipeLineResourses::InitSSAOData()
(float)rand() / (RAND_MAX + 1) * (1 - -1) + -1,
(float)rand() / (RAND_MAX + 1) * (1 - 0) + 0);
}
kernel[i].normalize();
kernel[i].Normalize();
float scale = float(i) / float(NrOfSamples);
scale = (0.1f*(1 - scale * scale) + 1.0f *( scale * scale));
@ -102,7 +102,7 @@ void PipeLineResourses::InitSSAOData()
(float)rand() / (RAND_MAX + 1) * (1 - -1)+ -1,
0.0f);
}
random[i].normalize();
random[i].Normalize();
}
}
@ -137,15 +137,15 @@ void PipeLineResourses::InitSSAOData()
delete[] random;
}
void PipeLineResourses::InitSubFrustrums()
void PipeLineResourses::InitSubFrustrums(int sizeX, int sizeY)
{
FrustrumDimensions.x = (::Oyster::Window::Size.left + 15U) / 16U;
FrustrumDimensions.y = (::Oyster::Window::Size.bottom + 15U) / 16U;
FrustrumDimensions.x = (sizeX + 15U) / 16U;
FrustrumDimensions.y = (sizeY + 15U) / 16U;
FrustrumDimensions.z = 1;
FrustrumSize = FrustrumDimensions.x * FrustrumDimensions.y * FrustrumDimensions.z;
if(SubFrustrums!=0)
delete[] SubFrustrums;
SubFrustrums = new Frustrum[ FrustrumSize ];
SubFrustrums = new Collision3D::Frustrum[ FrustrumSize ];
Oyster::Buffer::BUFFER_INIT_DESC desc;
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
@ -197,11 +197,11 @@ void PipeLineResourses::InitLightData()
LightData.numDispatches = FrustrumDimensions;
}
void PipeLineResourses::InitLighting()
void PipeLineResourses::InitLighting(int sizeX, int sizeY)
{
D3D11_TEXTURE2D_DESC Tdesc;
Tdesc.Width = Oyster::Window::Size.left;
Tdesc.Height = Oyster::Window::Size.bottom;
Tdesc.Width = sizeX;
Tdesc.Height = sizeY;
Tdesc.MipLevels = Tdesc.ArraySize = 1;
Tdesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
Tdesc.SampleDesc.Count = 1;

10
OysterGraphics/Resourses/PipelineResources.h
View File

@ -43,22 +43,22 @@ namespace Oyster
static ID3D11ShaderResourceView* SrvNulls[16];
static ID3D11UnorderedAccessView* uavNULL[16];
static Oyster::Collision::Frustrum* SubFrustrums;
static Oyster::Collision3D::Frustrum* SubFrustrums;
static int FrustrumSize;
static LinearAlgebra::Vector3<unsigned int> FrustrumDimensions;
static Oyster::Resources::BufferDefinitions::LightStructureBuffer LightData;
static void Init();
static void Init(int sizeX, int sizeY);
static void InitGeometry();
static void InitGeometry(int sizeX, int sizeY);
static void InitSSAOData();
static void InitSubFrustrums();
static void InitSubFrustrums(int sizeX, int sizeY);
static void InitPointLights();
static void InitLightData();
static void InitLighting();
static void InitLighting(int sizeX, int sizeY);
};
}
}