Renderer::Renderer()
{
scene_to_render = nullptr;
default_render_shader = new Shader("default_vertex", "default_pixel");
gbuffer_normal_texture = new Texture (D3DXVECTOR3( g_screenWidth, g_screenHeight,1), nullptr, DXGI_FORMAT_R8G8B8A8_UNORM , 0);
gbuffer_specular_texture = new Texture(D3DXVECTOR3( g_screenWidth, g_screenHeight,1), nullptr, DXGI_FORMAT_R8G8B8A8_UNORM , 0);
gbuffer_albedo_texture = new Texture (D3DXVECTOR3( g_screenWidth, g_screenHeight,1), nullptr, DXGI_FORMAT_R8G8B8A8_UNORM , 0);
screen_texture = new Texture(D3DXVECTOR3(g_screenWidth, g_screenHeight, 1), nullptr, DXGI_FORMAT_R8G8B8A8_UNORM, 0);
gbuffer_shader = new Shader("default_vertex", "gbuffer_pixel");
full_deferred_diffuse_lighting_shader = new Shader("direct_vertex_position", "full_deferred_diffuse_lighting");
use_postfx = false;
camera_ = nullptr;
lighting_constants_buffer_gpu = CreateConstantBuffer(sizeof(LightingConstantsBuffer));
mesh_constants_buffer_gpu = CreateConstantBuffer(sizeof(MeshConstantsBuffer));
frame_constans_buffer_gpu = CreateConstantBuffer(sizeof(FrameConstantsBuffer));
SetConstantBufferToSlot(0, frame_constans_buffer_gpu);
SetConstantBufferToSlot(1, mesh_constants_buffer_gpu);
SetConstantBufferToSlot(2, lighting_constants_buffer_gpu);
}
void RenderingContext::Create()
{
Microsoft::WRL::ComPtr<ID3DBlob> VertexShaderBlob;
Microsoft::WRL::ComPtr<ID3DBlob> PixelShaderBlob;
GraphicsContext::LoadAndCompileShader(VertexShaderBlob, PixelShaderBlob, IDR_SHADER11, "5_0");
CreateShaders(VertexShaderBlob, PixelShaderBlob);
CreateInputLayout(VertexShaderBlob);
CreateConstantBuffer(CameraConstantBuffer, sizeof(CameraConstantBufferType));
CreateConstantBuffer(ObjectConstantBuffer, sizeof(ObjectConstantBufferType));
}
bool CEffectVertexShader::Load()
{
CreateShaderMacro();
ID3DBlob *l_VSBlob = NULL;
bool l_Loaded = LoadShader(m_Filename, m_EntryPoint, m_ShaderModel,
&l_VSBlob);
if (!l_Loaded)
return false;
/*CRenderManager &l_RenderManager = UABEngine.GetRenderManager();
ID3D11Device *l_Device = l_RenderManager.GetDevice();*/
CRenderManager* l_RenderManager = UABEngine.GetRenderManager();
ID3D11Device *l_Device = l_RenderManager->GetDevice();
HRESULT l_HR = l_Device->CreateVertexShader(l_VSBlob->GetBufferPointer(),
l_VSBlob->GetBufferSize(), NULL, &m_VertexShader);
if (FAILED(l_HR))
{
l_VSBlob->Release();
return false;
}
if (m_VertexType == "MV_POSITION_NORMAL_TEXTURE_VERTEX")
l_Loaded = MV_POSITION_NORMAL_TEXTURE_VERTEX::CreateInputLayout(l_RenderManager, l_VSBlob, &m_VertexLayout);
else
//Info("Vertex type '%s' not recognized on CEffectVertexShader::Load", m_VertexType.c_str());
printf("Vertex type '%s' not recognized on CEffectVertexShader::Load", m_VertexType.c_str());
l_VSBlob->Release();
if (!l_Loaded)
return false;
return CreateConstantBuffer();
}
LineRenderer::LineRenderer(ID3D11Device* device)
{
// create vertex buffer.
uint32_t vertCount = 1000;
m_vbPC = CreateVertexBuffer(device, VertexFormat::VF_PC, NULL, vertCount, D3D11_USAGE_DYNAMIC);
assert(m_vbPC);
// compile shaders
ID3DBlob* vsBlob = CompileShaderFromResource(L"LineShader.hlsl", "VS","vs_4_0", NULL);
ID3DBlob* psBlob = CompileShaderFromResource(L"LineShader.hlsl", "PS","ps_4_0", NULL);
assert(vsBlob);
assert(psBlob);
m_vsShader = CreateVertexShader(device, vsBlob);
m_psShader = CreatePixelShader(device, psBlob);
assert(m_vsShader);
assert(m_psShader);
m_vertexLayoutPC = CreateInputLayout(device, vsBlob, VertexFormat::VF_PC);
// create constant buffer.
m_perframeCB = CreateConstantBuffer(device,sizeof(Matrix));
vsBlob->Release();
psBlob->Release();
}
void D3D11Renderer::InitRendererResources()
{
static int passes = 0;
assert(passes++ == 0);
if (!m_transformBuffer)
CreateConstantBuffer(&m_transformBuffer, sizeof(XMFLOAT4X4), false, 0);
}
bool CEffectPixelShader::Load()
{
ID3DBlob *l_PSBlob = NULL;
bool l_Loaded = LoadShader(m_Filename.c_str(), m_EntryPoint.c_str(), m_ShaderModel.c_str(), &l_PSBlob);
if (!l_Loaded)
return false;
ID3D11Device *l_Device = CEngine::GetSingleton().GetRenderManager()->GetDevice();
HRESULT l_HR = l_Device->CreatePixelShader(l_PSBlob->GetBufferPointer(), l_PSBlob->GetBufferSize(), NULL, &m_PixelShader);
l_PSBlob->Release();
return CreateConstantBuffer();
}
bool CEffectShader::CreateConstantBuffer()
{
CreateConstantBuffer(SCENE_CONSTANT_BUFFER_ID, sizeof(CSceneEffectParameters));
CreateConstantBuffer(LIGHT_CONSTANT_BUFFER_ID, sizeof(CLightEffectParameters));
CreateConstantBuffer(ANIMATED_CONSTANT_BUFFER_ID, sizeof(CAnimatedModelEffectParameters));
/*CreateConstantBuffer( SCENE_CONSTANT_BUFFER_ID, 60*sizeof(float));
CreateConstantBuffer( LIGHT_CONSTANT_BUFFER_ID, 80*sizeof(float));
CreateConstantBuffer( ANIMATED_CONSTANT_BUFFER_ID, 640*sizeof(float));*/
/*CRenderManager* l_RenderManager=UABEngine.GetRenderManager();
ID3D11Device *l_Device=l_RenderManager->GetDevice();
D3D11_BUFFER_DESC l_BufferDescription;
ZeroMemory(&l_BufferDescription, sizeof(l_BufferDescription));
l_BufferDescription.Usage=D3D11_USAGE_DEFAULT;
l_BufferDescription.ByteWidth=sizeof(CEffectParameters);
l_BufferDescription.BindFlags=D3D11_BIND_CONSTANT_BUFFER;
l_BufferDescription.CPUAccessFlags=0;
if( FAILED(l_Device->CreateBuffer(&l_BufferDescription, NULL,&m_ConstantBuffer)))
return false;*/
return true;
}
bool CEffectPixelShader::Load()
{
CreateShaderMacro();
ID3DBlob *l_PSBlob = NULL;
bool l_Loaded = LoadShader(m_Filename.c_str(), m_EntryPoint.c_str(),
m_ShaderModel.c_str(), &l_PSBlob);
if (!l_Loaded)
return false;
/*CRenderManager &l_RenderManager = UABEngine.GetRenderManager();
ID3D11Device *l_Device = l_RenderManager.GetDevice();*/
CRenderManager* l_RenderManager = UABEngine.GetRenderManager();
ID3D11Device *l_Device = l_RenderManager->GetDevice();
HRESULT l_HR = l_Device->CreatePixelShader(l_PSBlob->GetBufferPointer(),
l_PSBlob->GetBufferSize(), NULL, &m_PixelShader);
l_PSBlob->Release();
return CreateConstantBuffer();
}
void CubeObject::OnCreate() {
CreateBuffers();
m_Scale = Vec3(1.0f, 1.0f, 1.0f);
m_Qt.identity();
m_Pos = Vec3(0, 0, 0.0);
///ルートシグネチャ作成
CreateRootSignature();
///デスクプリタヒープ作成
CreateDescriptorHeap();
///コンスタントバッファ作成
CreateConstantBuffer();
///パイプラインステート作成
CreatePipelineState();
///コマンドリスト作成
CreateCommandList();
//コンスタントバッファの更新
UpdateConstantBuffer();
}
TiledSpriteGroup::TiledSpriteGroup()
{
InitDrawable();
CountOfSprites=0;
SpriteBase=0;
mTiledTextureRegion=0;
vertices=0;
AbsTextureCoordinate(0.0f,0.0f,1.0f,1.0f);
HalfTexSize(0,0);
VB_Stride = sizeof( Tuxis::Vertex::SpriteGroupVertex );
VB_Offset = 0;
mShader = DefaultShaderBase::Instance()->mShaderTiledSpriteGroup;
CreateConstantBuffer(sizeof(XMMATRIX),D3D11_USAGE_DEFAULT);
}
//--------------------------------------------------------------------------------------
//
// OnCreateDevice
//
// Called when the device is created to create resources for hair rendering
//
//--------------------------------------------------------------------------------------
HRESULT TressFXRenderer::OnCreateDevice(ID3D11Device* pd3dDevice, int winWidth, int winHeight, bool bShortCutOn)
{
HRESULT hr;
AMD_V_RETURN(CreateShaderAndLayout(pd3dDevice));
AMD_V_RETURN(CreateTextureAndViews(pd3dDevice));
AMD_V_RETURN(CreateConstantBuffer(pd3dDevice));
AMD_V_RETURN(CreateVertexBuffers(pd3dDevice));
AMD_V_RETURN(CreateRenderStateObjects(pd3dDevice));
if (bShortCutOn)
{
m_ShortCut.OnCreateDevice(pd3dDevice, winWidth, winHeight);
}
else
{
AMD_V_RETURN(CreatePPLL(pd3dDevice, winWidth, winHeight, false));
}
return S_OK;
}
bool BaseApp::Init( HWND hWnd )
{
DeviceDx11& refDevice = DeviceDx11::GetInstance();
if( !refDevice.InitDevice( hWnd ) )
{
return false;
}
if( !SetUpDxResource( &refDevice ) )
{
return false;
}
if( !BuildShader( &refDevice ) )
{
return false;
}
m_pObject = new Object();
m_pObject->Init();
if( !CreateVertexBuffer() )
{
return false;
}
if( !CreateIndexBuffer() )
{
return false;
}
if( !CreateConstantBuffer() )
{
return false;
}
return true;
}
void Text::Initialize()
{
mShader = DefaultShaderBase::Instance()->mShaderText;
CreateConstantBuffer(sizeof(XMMATRIX),D3D11_USAGE_DEFAULT);
SavedStrings.clear();
}
void Sandbox::FluidSimulator::CreateDeviceResources( _No_args_ )
{
Sehnsucht::IO::BasicLoader loader( m_d3dDevice, m_wicFactory ); auto loaderPtr = &loader;
{ // Create shaders
loaderPtr->LoadShader( L"DiffusionJacobiCs2.cso", m_diffusionJacobiCs.GetAddressOf( ) );
loaderPtr->LoadShader( L"PressureJacobiCs2.cso", m_pressureJacobiCs.GetAddressOf( ) );
loaderPtr->LoadShader( L"ProjectionCs1.cso", m_fluidProjectionCs.GetAddressOf( ) );
loaderPtr->LoadShader( L"DivergenceCs0.cso", m_fluidDivergenceCs.GetAddressOf( ) );
loaderPtr->LoadShader( L"AdvectionCs1.cso", m_fluidAdvectionCs.GetAddressOf( ) );
loaderPtr->LoadShader( L"GaussianSplatCs0.cso", m_gaussianSplatCs.GetAddressOf( ) );
loaderPtr->LoadShader( L"ZeroTextureCs0.cso", m_zeroCs.GetAddressOf( ) );
loaderPtr->LoadShader( L"CopyTextureCs0.cso", m_copyCs.GetAddressOf( ) );
}
{ // Create constant buffers
loaderPtr->CreateConstantBuffer( m_problemParams.GetAddressOf( ), &m_problemParamsData );
loaderPtr->CreateConstantBuffer( m_forcePerFrame.GetAddressOf( ), &m_forcePerFrameData );
m_cbuffers[ 0 ] = m_problemParams.Get( );
m_cbuffers[ 1 ] = m_forcePerFrame.Get( );
}
{ // Create textures
Rendering::Texture2Description problemTextureDesc; ZeroValue( &problemTextureDesc );
problemTextureDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS;
problemTextureDesc.Height = _To_uint GetProblemParameters( )->ProblemFactors.y;
problemTextureDesc.Width = _To_uint GetProblemParameters( )->ProblemFactors.x;
problemTextureDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
problemTextureDesc.Usage = D3D11_USAGE_DEFAULT;
problemTextureDesc.SampleDesc.Quality = 0;
problemTextureDesc.SampleDesc.Count = 1;
problemTextureDesc.MipLevels = 1;
problemTextureDesc.ArraySize = 1;
m_d3dDevice->CreateTexture2D( &problemTextureDesc, nullptr, m_velocityPingPong0.GetAddressOf( ) );
m_d3dDevice->CreateTexture2D( &problemTextureDesc, nullptr, m_velocityPingPong1.GetAddressOf( ) );
m_d3dDevice->CreateTexture2D( &problemTextureDesc, nullptr, m_pressurePingPong0.GetAddressOf( ) );
m_d3dDevice->CreateTexture2D( &problemTextureDesc, nullptr, m_pressurePingPong1.GetAddressOf( ) );
m_d3dDevice->CreateTexture2D( &problemTextureDesc, nullptr, m_divergence.GetAddressOf( ) );
Rendering::ShaderResourceViewDescription problemTextureSrvDesc; ZeroValue( &problemTextureSrvDesc );
problemTextureSrvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
problemTextureSrvDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
problemTextureSrvDesc.Texture2D.MostDetailedMip = 0;
problemTextureSrvDesc.Texture2D.MipLevels = 1;
m_d3dDevice->CreateShaderResourceView( m_velocityPingPong0.Get( ), &problemTextureSrvDesc, m_velocityPingPong0Srv.GetAddressOf( ) );
m_d3dDevice->CreateShaderResourceView( m_velocityPingPong1.Get( ), &problemTextureSrvDesc, m_velocityPingPong1Srv.GetAddressOf( ) );
m_d3dDevice->CreateShaderResourceView( m_pressurePingPong0.Get( ), &problemTextureSrvDesc, m_pressurePingPong0Srv.GetAddressOf( ) );
m_d3dDevice->CreateShaderResourceView( m_pressurePingPong1.Get( ), &problemTextureSrvDesc, m_pressurePingPong1Srv.GetAddressOf( ) );
m_d3dDevice->CreateShaderResourceView( m_divergence.Get( ), &problemTextureSrvDesc, m_divergenceSrv.GetAddressOf( ) );
Rendering::UnorderedAccessViewDescription problemTextureUavDesc; ZeroValue( &problemTextureUavDesc );
problemTextureUavDesc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2D;
problemTextureUavDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
problemTextureUavDesc.Texture2D.MipSlice = 0;
m_d3dDevice->CreateUnorderedAccessView( m_velocityPingPong0.Get( ), &problemTextureUavDesc, m_velocityPingPong0Uav.GetAddressOf( ) );
m_d3dDevice->CreateUnorderedAccessView( m_velocityPingPong1.Get( ), &problemTextureUavDesc, m_velocityPingPong1Uav.GetAddressOf( ) );
m_d3dDevice->CreateUnorderedAccessView( m_pressurePingPong0.Get( ), &problemTextureUavDesc, m_pressurePingPong0Uav.GetAddressOf( ) );
m_d3dDevice->CreateUnorderedAccessView( m_pressurePingPong1.Get( ), &problemTextureUavDesc, m_pressurePingPong1Uav.GetAddressOf( ) );
m_d3dDevice->CreateUnorderedAccessView( m_divergence.Get( ), &problemTextureUavDesc, m_divergenceUav.GetAddressOf( ) );
m_d3dContext->CSSetShader( m_zeroCs.Get( ), nullptr, 0u );
m_d3dContext->CSSetUnorderedAccessViews( 0, 1, m_velocityPingPong0Uav.GetAddressOf( ), m_zeroUavInitCounts );
m_d3dContext->Dispatch( problemTextureDesc.Width, problemTextureDesc.Height, 1 );
m_d3dContext->CSSetUnorderedAccessViews( 0, 1, m_velocityPingPong1Uav.GetAddressOf( ), m_zeroUavInitCounts );
m_d3dContext->Dispatch( problemTextureDesc.Width, problemTextureDesc.Height, 1 );
m_d3dContext->CSSetUnorderedAccessViews( 0, 1, m_pressurePingPong0Uav.GetAddressOf( ), m_zeroUavInitCounts );
m_d3dContext->Dispatch( problemTextureDesc.Width, problemTextureDesc.Height, 1 );
m_d3dContext->CSSetUnorderedAccessViews( 0, 1, m_pressurePingPong1Uav.GetAddressOf( ), m_zeroUavInitCounts );
m_d3dContext->Dispatch( problemTextureDesc.Width, problemTextureDesc.Height, 1 );
m_d3dContext->CSSetUnorderedAccessViews( 0, 1, m_divergenceUav.GetAddressOf( ), m_zeroUavInitCounts );
m_d3dContext->Dispatch( problemTextureDesc.Width, problemTextureDesc.Height, 1 );
m_d3dContext->CSSetUnorderedAccessViews( 0, 1, m_nullUavs, m_zeroUavInitCounts );
m_d3dContext->CSSetShader( nullptr, nullptr, 0u );
}
{ // Create sampler states
D3D11_SAMPLER_DESC samplerDesc;
ZeroValue( &samplerDesc );
// Create a texture sampler state description.
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
samplerDesc.MaxAnisotropy = 1;
m_d3dDevice->CreateSamplerState( &samplerDesc, m_linearSampler.GetAddressOf( ) );
}
}
bool CEffectVertexShader::Load()
{
CreateShaderMacro();
ID3DBlob *l_VSBlob = NULL;
bool l_Loaded = LoadShader(m_Filename, m_EntryPoint, m_ShaderModel,
&l_VSBlob);
DEBUG_ASSERT(l_Loaded);
if (!l_Loaded)
{
return false;
}
CContextManager &l_context = *CEngine::GetSingleton().getContextManager();
ID3D11Device *l_Device = l_context.GetDevice();
HRESULT l_HR = l_Device->CreateVertexShader(l_VSBlob->GetBufferPointer(),
l_VSBlob->GetBufferSize(), NULL,
&m_VertexShader);
DEBUG_ASSERT(!FAILED(l_HR));
if (FAILED(l_HR))
{
l_VSBlob->Release();
return false;
}
if (m_VertexType == "MV_POSITION_TEXTURE_VERTEX")
{
l_Loaded = MV_POSITION_TEXTURE_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout);
}
else if (m_VertexType == "MV_POSITION_NORMAL_TEXTURE_VERTEX")
{
l_Loaded = MV_POSITION_NORMAL_TEXTURE_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout);
}
else if (m_VertexType == "MV_POSITION4_COLOR_TEXTURE_VERTEX")
{
l_Loaded = MV_POSITION4_COLOR_TEXTURE_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout);
}
else if (m_VertexType == "MV_POSITION_NORMAL_TEXTURE_TEXTURE2_VERTEX")
{
l_Loaded = MV_POSITION_NORMAL_TEXTURE_TEXTURE2_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout);
}
else if (m_VertexType == "MV_POSITION_NORMAL_TANGENT_BINORMAL_TEXTURE_VERTEX")
{
l_Loaded = MV_POSITION_NORMAL_TANGENT_BINORMAL_TEXTURE_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout);
}
else if (m_VertexType == "MV_POSITION_NORMAL_TANGENT_BINORMAL_TEXTURE_TEXTURE2_VERTEX")
{
l_Loaded = MV_POSITION_NORMAL_TEXTURE_TEXTURE2_TANGENT_BINORMAL_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout);
}
else if (m_VertexType == "MV_POSITION_NORMAL_TEXTURE_WEIGHT_INDICES_VERTEX")
{
l_Loaded = MV_POSITION_WEIGHT_INDICES_NORMAL_TEXTURE_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout);
}
else if (m_VertexType == "MV_POSITION_NORMAL_TANGENT_BINORMAL_TEXTURE_WEIGHT_INDICES_VERTEX")
{
l_Loaded = MV_POSITION_WEIGHT_INDICES_NORMAL_TANGENT_BINORMAL_TEXTURE_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout);
}
else if (m_VertexType == "MV_POSITION_NORMAL_TANGENT_BINORMAL_TEXTURE_TEXTURE2_WEIGHT_INDICES_VERTEX")
{
l_Loaded = MV_POSITION_WEIGHT_INDICES_NORMAL_TANGENT_BINORMAL_TEXTURE_TEXTURE2_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout);
}
else if (m_VertexType == "MV_POSITION_NORMAL_TEXTURE_TEXTURE2_TANGENT_BINORMAL_VERTEX")
{
l_Loaded = MV_POSITION_NORMAL_TEXTURE_TEXTURE2_TANGENT_BINORMAL_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout);
}
else if (m_VertexType == "MV_POSITION_COLOR_VERTEX")
{
l_Loaded = MV_POSITION_COLOR_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout);
}
else if (m_VertexType == "MV_POSITION_NORMAL_TANGENT_BINORMAL_TEXTURE_WEIGHT_INDICES_VERTEX")
{
l_Loaded = MV_POSITION_WEIGHT_INDICES_NORMAL_TANGENT_BINORMAL_TEXTURE_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout);
}
else if (m_VertexType == "MV_POSITION_NORMAL_TANGENT_BINORMAL_TEXTURE_TEXTURE2_WEIGHT_INDICES_VERTEX")
{
l_Loaded = MV_POSITION_WEIGHT_INDICES_NORMAL_TANGENT_BINORMAL_TEXTURE_TEXTURE2_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout);
}
else if (m_VertexType == "PARTICLE_VERTEX")
{
l_Loaded = PARTICLE_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout);
}
else if (m_VertexType == "GUI_VERTEX")
{
l_Loaded = GUI_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout);
}
else if (m_VertexType == "GUI_TEXT_VERTEX")
{
l_Loaded = GUI_TEXT_VERTEX::CreateInputLayout(l_Device, l_VSBlob, &m_VertexLayout);
}
else
{
DEBUG_ASSERT(!"Vertex type '%s' not recognized on CEffectVertexShader::Load");
}
l_VSBlob->Release();
DEBUG_ASSERT(l_Loaded);
if (!l_Loaded)
return false;
return CreateConstantBuffer();
}
// --------------------------------------------------------------------------------------------------------------------
bool DynamicStreamingD3D11UpdateSubresource::Init(size_t _maxVertexCount)
{
D3D11_INPUT_ELEMENT_DESC elements[] =
{
{ "ATTR", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
if (!CompileProgram(L"streaming_vb_d3d11_vs.hlsl", &mVertexShader,
L"streaming_vb_d3d11_ps.hlsl", &mPixelShader,
ArraySize(elements), elements, &mInputLayout)) {
return false;
}
// Constant Buffer
HRESULT hr = CreateConstantBuffer(sizeof(Constants), nullptr, &mConstantBuffer);
if (FAILED(hr)) {
return false;
}
// Render States
{
D3D11_RASTERIZER_DESC desc;
desc.FillMode = D3D11_FILL_SOLID;
desc.CullMode = D3D11_CULL_NONE;
desc.FrontCounterClockwise = FALSE;
desc.DepthBias = 0;
desc.SlopeScaledDepthBias = 0.0f;
desc.DepthBiasClamp = 0.0f;
desc.DepthClipEnable = FALSE;
desc.ScissorEnable = FALSE;
desc.MultisampleEnable = FALSE;
desc.AntialiasedLineEnable = FALSE;
hr = g_d3d_device->CreateRasterizerState(&desc, &mRasterizerState);
if (FAILED(hr)) {
return false;
}
}
{
D3D11_BLEND_DESC desc;
desc.AlphaToCoverageEnable = FALSE;
desc.IndependentBlendEnable = FALSE;
D3D11_RENDER_TARGET_BLEND_DESC& rtDesc = desc.RenderTarget[0];
rtDesc.BlendEnable = TRUE;
rtDesc.SrcBlend = D3D11_BLEND_SRC_ALPHA;
rtDesc.DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
rtDesc.BlendOp = D3D11_BLEND_OP_ADD;
rtDesc.SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA;
rtDesc.DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
rtDesc.BlendOpAlpha = D3D11_BLEND_OP_ADD;
rtDesc.RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
hr = g_d3d_device->CreateBlendState(&desc, &mBlendState);
if (FAILED(hr)) {
return false;
}
}
{
D3D11_DEPTH_STENCIL_DESC desc;
desc.DepthEnable = FALSE;
desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
desc.DepthFunc = D3D11_COMPARISON_LESS;
desc.StencilEnable = FALSE;
desc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
desc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;
desc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
desc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
desc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
desc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
desc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP;
desc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_KEEP;
desc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
desc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
hr = g_d3d_device->CreateDepthStencilState(&desc, &mDepthStencilState);
if (FAILED(hr)) {
return false;
}
}
{
D3D11_SAMPLER_DESC desc;
desc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
desc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
desc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
desc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
desc.MipLODBias = 0.0f;
desc.MaxAnisotropy = 0;
desc.ComparisonFunc = D3D11_COMPARISON_NEVER;
desc.BorderColor[0] = 0.0f;
desc.BorderColor[1] = 0.0f;
desc.BorderColor[2] = 0.0f;
desc.BorderColor[3] = 0.0f;
desc.MinLOD = 0;
desc.MaxLOD = D3D11_FLOAT32_MAX;
hr = g_d3d_device->CreateSamplerState(&desc, &mSamplerState);
if (FAILED(hr)) {
return false;
}
}
// Dynamic vertex buffer
mParticleBufferSize = kTripleBuffer * sizeof(Vec2) * _maxVertexCount;
hr = CreateDynamicVertexBuffer(mParticleBufferSize, nullptr, D3D11_USAGE_DEFAULT, 0, &mDynamicVertexBuffer);
if (FAILED(hr)) {
return false;
}
return true;
}
void D3D::Create()
{
// CAMERA
XMStoreFloat4x4(view, XMMatrixTranspose(XMMatrixLookAtLH(XMVectorSet(0.0f, 2.0f, -2.0f, 1.0f), XMVectorSet(0.0f, -1.0f, -1.0f, 0.0f), XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f))));
XMStoreFloat4x4(projection, XMMatrixTranspose(XMMatrixPerspectiveFovLH(XM_PI * 0.45f, 640.0f / 480.0f, 1.0f, 1000.0f)));
projection->_11 = projection->_22 / (windowWidth / windowHeight);
viewMatrix = CreateConstantBuffer(sizeof(XMFLOAT4X4), view);
projectionMatrix = CreateConstantBuffer(sizeof(XMFLOAT4X4), projection);
// Load bin file
std::ifstream infile;
infile.open("C:/New folder/pCube1.bin", std::ifstream::binary);
if (infile.is_open() == true)
{
// Main header
MainHeader mainHeader;
infile.read((char*)&mainHeader, sizeof(MainHeader));
// Mesh header
vector<SubMesh> submesh;
infile.read((char*)&mesh.header, sizeof(MeshHeader));
// Mesh data
mesh.geometry.points.resize(mesh.header.numberPoints);
mesh.geometry.normals.resize(mesh.header.numberNormals);
mesh.geometry.texCoords.resize(mesh.header.numberCoords);
infile.read((char*)mesh.Name.data(), mesh.header.nameLength);
infile.read((char*)mesh.geometry.points.data(), mesh.header.numberPoints * sizeof(Point));
infile.read((char*)mesh.geometry.normals.data(), mesh.header.numberNormals * sizeof(Normal));
infile.read((char*)mesh.geometry.texCoords.data(), mesh.header.numberCoords * sizeof(TexCoord));
submesh.resize(mainHeader.meshCount);
mesh.geometry.faces.resize(mesh.header.numberFaces);
for (size_t i = 0; i < mesh.header.numberFaces; i++) {
for (size_t j = 0; j < 3; j++) {
infile.read((char*)&mesh.geometry.faces[i].verts[j].pointID, 4);
infile.read((char*)&mesh.geometry.faces[i].verts[j].normalID, 4);
infile.read((char*)&mesh.geometry.faces[i].verts[j].texCoordID, 4);
}
}
for (size_t i = 0; i < mainHeader.meshCount; i++) {
// Mesh header
infile.read((char*)&submesh[i].header, sizeof(MeshHeader));
// Mesh data
mesh.subMeshes[i].geometry.points.resize(submesh[i].header.numberPoints);
mesh.subMeshes[i].geometry.normals.resize(submesh[i].header.numberNormals);
mesh.subMeshes[i].geometry.texCoords.resize(submesh[i].header.numberCoords);
infile.read((char*)mesh.subMeshes[i].Name.data(), submesh[i].header.nameLength);
infile.read((char*)mesh.subMeshes[i].geometry.points.data(), submesh[i].header.numberPoints * sizeof(Point));
infile.read((char*)mesh.subMeshes[i].geometry.normals.data(), submesh[i].header.numberNormals * sizeof(Normal));
infile.read((char*)mesh.subMeshes[i].geometry.texCoords.data(), submesh[i].header.numberCoords * sizeof(TexCoord));
mesh.geometry.faces.resize(submesh[i].header.numberFaces);
for (size_t j = 0; j < submesh[i].header.numberFaces; j++) {
for (size_t k = 0; k < 3; k++) {
infile.read((char*)&submesh[i].geometry.faces[j].verts[k].pointID, 4);
infile.read((char*)&submesh[i].geometry.faces[j].verts[k].normalID, 4);
infile.read((char*)&submesh[i].geometry.faces[j].verts[k].texCoordID, 4);
}
}
}
MatHeader matHeader;
infile.read((char*)&matHeader, sizeof(MatHeader));
infile.read((char*)&mesh.material.diffColor, 16);
infile.read((char*)mesh.material.diffuseTexture.data(), matHeader.diffuseNameLength); // Crash here on reading of string.
infile.read((char*)&mesh.material.specColor, 16);
infile.read((char*)mesh.material.specularTexture.data(), matHeader.specularNameLength);
// TEST TO PUT THE OBJERCT TOGHETER
meshes.push_back(MeshData());
meshes.back().pos.resize(mesh.header.numberFaces * 3);
meshes.back().normal.resize(mesh.header.numberFaces * 3);
meshes.back().uv.resize(mesh.header.numberFaces * 3);
size_t index = 0;
for (size_t i = 0; i < mesh.header.numberFaces; i++) {
for (size_t j = 0; j < 3; j++) {
meshes.back().pos[index].x = mesh.geometry.points[mesh.geometry.faces[i].verts[j].pointID].x;
meshes.back().pos[index].y = mesh.geometry.points[mesh.geometry.faces[i].verts[j].pointID].y;
meshes.back().pos[index].z = mesh.geometry.points[mesh.geometry.faces[i].verts[j].pointID].z;
meshes.back().normal[index] = mesh.geometry.normals[mesh.geometry.faces[i].verts[j].normalID];
meshes.back().uv[index] = mesh.geometry.texCoords[mesh.geometry.faces[i].verts[j].texCoordID];
index++;
}
}
// Vertices
meshes.back().meshesBuffer[0] = CreateMesh(sizeof(XMFLOAT3) * meshes.back().pos.size(), meshes.back().pos.data(), meshes.back().pos.size());
meshes.back().meshesBuffer[1] = CreateMesh(sizeof(XMFLOAT3) * meshes.back().normal.size(), meshes.back().normal.data(), meshes.back().normal.size());
meshes.back().meshesBuffer[2] = CreateMesh(sizeof(XMFLOAT2) * meshes.back().uv.size(), meshes.back().uv.data(), meshes.back().uv.size());
// Transform
DirectX::XMStoreFloat4x4(&meshes.back().transform, XMMatrixIdentity());
meshes.back().transformBuffer = CreateConstantBuffer(sizeof(XMFLOAT4X4), &meshes.back().transform);
// Texture
CreateTexture(0);
}
infile.close();
}
//--------------------------------------------------------------------------------------
// Create any D3D11 resources that aren't dependant on the back buffer
//--------------------------------------------------------------------------------------
HRESULT CALLBACK OnD3D11CreateDevice( ID3D11Device* pd3dDevice, const DXGI_SURFACE_DESC* pBackBufferSurfaceDesc,
void* pUserContext )
{
DXUT_SetDebugName( pd3dDevice, "Main Device" );
HRESULT hr;
ID3D11DeviceContext* pd3dImmediateContext = DXUTGetD3D11DeviceContext();
V_RETURN( g_DialogResourceManager.OnD3D11CreateDevice( pd3dDevice, pd3dImmediateContext ) );
V_RETURN( g_SettingsDlg.OnD3D11CreateDevice( pd3dDevice ) );
g_pTxtHelper = new CDXUTTextHelper( pd3dDevice, pd3dImmediateContext, &g_DialogResourceManager, 15 );
IDXGIDevice* pDXGIDevice;
hr = pd3dDevice->QueryInterface( __uuidof(IDXGIDevice), (VOID**)&pDXGIDevice );
if( SUCCEEDED(hr) )
{
IDXGIAdapter* pAdapter;
hr = pDXGIDevice->GetAdapter( &pAdapter );
if( SUCCEEDED(hr) )
{
DXGI_ADAPTER_DESC AdapterDesc;
pAdapter->GetDesc( &AdapterDesc );
SetAdapterInfoForShaderCompilation( AdapterDesc.Description );
SAFE_RELEASE( pAdapter );
}
SAFE_RELEASE( pDXGIDevice );
}
ID3D10Blob* pVSBlob = NULL;
g_pVSTransform = CompileVertexShader( pd3dDevice, L"SceneRender.hlsl", "VSTransform", &pVSBlob );
g_pPSSceneRender = CompilePixelShader( pd3dDevice, L"SceneRender.hlsl", "PSSceneRender" );
g_pPSSceneRenderArray = CompilePixelShader( pd3dDevice, L"SceneRender.hlsl", "PSSceneRenderArray" );
g_pPSSceneRenderQuilt = CompilePixelShader( pd3dDevice, L"SceneRender.hlsl", "PSSceneRenderQuilt" );
// Create a layout for the object data
const D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
V_RETURN( pd3dDevice->CreateInputLayout( layout, ARRAYSIZE( layout ), pVSBlob->GetBufferPointer(),
pVSBlob->GetBufferSize(), &g_pDefaultInputLayout ) );
// No longer need the shader blobs
SAFE_RELEASE( pVSBlob );
// Create state objects
D3D11_SAMPLER_DESC samDesc;
ZeroMemory( &samDesc, sizeof(samDesc) );
samDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samDesc.AddressU = samDesc.AddressV = samDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samDesc.MaxAnisotropy = 1;
samDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samDesc.MaxLOD = D3D11_FLOAT32_MAX;
V_RETURN( pd3dDevice->CreateSamplerState( &samDesc, &g_pSamLinear ) );
DXUT_SetDebugName( g_pSamLinear, "Linear" );
D3D11_BLEND_DESC BlendDesc;
ZeroMemory( &BlendDesc, sizeof( D3D11_BLEND_DESC ) );
BlendDesc.RenderTarget[0].BlendEnable = FALSE;
BlendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
BlendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
BlendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
BlendDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA;
BlendDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
BlendDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
BlendDesc.RenderTarget[0].RenderTargetWriteMask = D3D10_COLOR_WRITE_ENABLE_ALL;
hr = pd3dDevice->CreateBlendState( &BlendDesc, &g_pBlendState );
ASSERT( SUCCEEDED(hr) );
D3D11_DEPTH_STENCIL_DESC DSDesc;
ZeroMemory( &DSDesc, sizeof(D3D11_DEPTH_STENCIL_DESC) );
DSDesc.DepthEnable = FALSE;
DSDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
DSDesc.DepthFunc = D3D11_COMPARISON_LESS;
DSDesc.StencilEnable = FALSE;
DSDesc.StencilReadMask = D3D11_DEFAULT_STENCIL_READ_MASK;
DSDesc.StencilWriteMask = D3D11_DEFAULT_STENCIL_WRITE_MASK;
hr = pd3dDevice->CreateDepthStencilState( &DSDesc, &g_pDepthStencilState );
ASSERT( SUCCEEDED(hr) );
D3D11_RASTERIZER_DESC RSDesc;
ZeroMemory( &RSDesc, sizeof(RSDesc) );
RSDesc.AntialiasedLineEnable = FALSE;
RSDesc.CullMode = D3D11_CULL_BACK;
RSDesc.DepthBias = 0;
RSDesc.DepthBiasClamp = 0.0f;
RSDesc.DepthClipEnable = TRUE;
RSDesc.FillMode = D3D11_FILL_SOLID;
RSDesc.FrontCounterClockwise = FALSE;
RSDesc.MultisampleEnable = TRUE;
RSDesc.ScissorEnable = FALSE;
RSDesc.SlopeScaledDepthBias = 0.0f;
hr = pd3dDevice->CreateRasterizerState( &RSDesc, &g_pRasterizerState );
ASSERT( SUCCEEDED(hr) );
g_pcbVSPerObject11 = CreateConstantBuffer( pd3dDevice, sizeof(CB_VS_PER_OBJECT) );
DXUT_SetDebugName( g_pcbVSPerObject11, "CB_VS_PER_OBJECT" );
// Create other render resources here
D3D11_TILED_EMULATION_PARAMETERS EmulationParams;
EmulationParams.DefaultPhysicalTileFormat = DXGI_FORMAT_R8G8B8A8_UNORM;
EmulationParams.MaxPhysicalTileCount = 1000;
D3D11CreateTiledResourceDevice( pd3dDevice, pd3dImmediateContext, &EmulationParams, &g_pd3dDeviceEx );
g_pd3dDeviceEx->CreateTilePool( &g_pTilePool );
g_pTitleResidencyManager = new TitleResidencyManager( pd3dDevice, pd3dImmediateContext, 1, EmulationParams.MaxPhysicalTileCount, g_pTilePool );
ResidencySampleRender::Initialize( pd3dDevice );
g_PageDebugRender.Initialize( pd3dDevice );
CreateSceneGeometry( pd3dDevice );
// Setup the camera's view parameters
XMMATRIX matProjection = XMMatrixPerspectiveFovLH( XM_PIDIV4, (FLOAT)pBackBufferSurfaceDesc->Width / (FLOAT)pBackBufferSurfaceDesc->Height, 0.001f, 100.0f );
XMStoreFloat4x4A( &g_matProjection, matProjection );
UpdateViewMatrix();
g_pTitleResidencyManager->StartThreads();
return S_OK;
}
