void Renderer::full_deferred_rendering_pipeline()
{
SetViewPortToDefault();
SetBlendState(blend_state_enable_color_write);
if (use_postfx)
{
SetRenderViews(screen_texture->get_rt(), GetDefaultDepthStencilView(), 0);
}
else
{
SetRenderViews(GetDefaultRenderTargetView(), GetDefaultDepthStencilView(), 0);
}
clearScreen();
set_lighting_constant_values();
SetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
//set gbuffer textures
gbuffer_albedo_texture->set_srv_to_shader(shader_type_pixel, 0);
gbuffer_normal_texture->set_srv_to_shader(shader_type_pixel, 1);
gbuffer_specular_texture->set_srv_to_shader(shader_type_pixel, 2);
//render for diffuse lighting
{
full_deferred_diffuse_lighting_shader->set_shaders();
RenderFullScreenQuad();
}
SetBlendState(blend_state_enable_color_write);
}
void RenderingDevice::SetMaterial(const Material &material) {
SetRasterizerState(material.GetRasterizerState());
SetBlendState(material.GetBlendState());
SetDepthStencilState(material.GetDepthStencilState());
for (size_t i = 0; i < material.GetSamplers().size(); ++i) {
auto& sampler = material.GetSamplers()[i];
if (sampler.GetTexture()) {
D3DLOG(mDevice->SetTexture(i, sampler.GetTexture()->GetDeviceTexture()));
} else {
D3DLOG(mDevice->SetTexture(i, nullptr));
}
SetSamplerState(i, sampler.GetState());
}
// Free up the texture bindings of the samplers currently being used
for (size_t i = material.GetSamplers().size(); i < mUsedSamplers; ++i) {
D3DLOG(mDevice->SetTexture(i, nullptr));
}
mUsedSamplers = material.GetSamplers().size();
material.GetVertexShader()->Bind();
material.GetPixelShader()->Bind();
}
void OpenGLEngine::Draw (int x, int y, glm::vec4 const& color, std::string const& message)
{
if (message.length () > 0)
{
int vx, vy, vw, vh;
GetViewport (vx, vy, vw, vh);
m_ActiveFont->SetStringData (vw, vh, x, y, color, message);
Update (m_ActiveFont->GetTextEffect () ->GetTranslate ());
Update (m_ActiveFont->GetTextEffect () ->GetColor ());
Update (m_ActiveFont->GetVertexBuffer ());
std::shared_ptr<BlendState> blendState = GetBlendState ();
std::shared_ptr<DepthStencilState> depthState = GetDepthStencilState ();
std::shared_ptr<RasterizerState> rasterizerState = GetRasterizerState ();
SetDefaultBlendState ();
SetDefaultDepthStencilState ();
SetDefaultRasterizerState ();
Draw (m_ActiveFont->GetVertexBuffer (), m_ActiveFont->GetIndexBuffer (), m_ActiveFont->GetTextEffect ());
SetBlendState (blendState);
SetDepthStencilState (depthState);
SetRasterizerState (rasterizerState);
}
}
ErrorMessage DirectXEngine::Initialize(Jamgine::Data_Send p_data)
{
ErrorMessage l_errorMessage = J_OK;
m_hInstance = p_data.hInstance;
m_clientWidth = p_data.clientWidth;
m_clientHeight = p_data.clientHeight;
// Register window
l_errorMessage = RegisterWindow(p_data);
if(l_errorMessage != J_OK)
return J_FAIL;
// Init swapchain and device
l_errorMessage = InitializeSwapChain();
if(l_errorMessage != J_OK)
return J_FAIL;
// Create texturemanger
l_errorMessage = Texture2DManager::CreateTexture2DManager(&m_texture2DManager);
m_texture2DManager->Initialize(m_device);
if(l_errorMessage != J_OK)
return J_FAIL;
CreateDepthBuffer();
InitializeRenderTarget();
LoadShaders();
CreateBuffer();
SetViewport();
CreateRasterizers();
SetBlendState();
return l_errorMessage;
}
//--------------------------------------------------------------------------------------
/// メッセージを表示するスプライト
//--------------------------------------------------------------------------------------
MessageSprite::MessageSprite(const shared_ptr<Stage>& StagePtr,
const wstring& TextureResName,
const Vec2& StartScale,
float StartRot,
const Vec2& StartPos,
UINT XWrap, UINT YWrap) :
SpriteBase(StagePtr, TextureResName, StartScale, StartRot, StartPos, XWrap, YWrap),
m_TotalTime(0)
{
SetBlendState(BlendState::Trace);
}
_Use_decl_annotations_
DirectionalLightPass::DirectionalLightPass(const std::shared_ptr<GraphicsSystem>& graphics, const ComPtr<ID3D11DeviceContext>& context,
const std::shared_ptr<Texture>& light, const std::shared_ptr<Texture>& diffuse,
const std::shared_ptr<Texture>& normals, const std::shared_ptr<Texture>& depth) :
RenderPass(graphics, context)
{
UNREFERENCED_PARAMETER(depth);
LoadShaders(L"vsPassthroughViewRay.cso", VertexFormat::Position2DProj, L"psDirectionalLight.cso");
SetShaderResource(0, diffuse);
SetShaderResource(1, normals);
SetRenderTarget(0, light);
SetBlendState(graphics->GetAdditiveBlendState());
CreateVSConstantBuffer(0, sizeof(vsPerFrame));
CreatePSConstantBuffer(0, sizeof(psPerDraw));
}
void D3D11GraphicsDeviceStateManager::EnableAdditiveBlending()
{
if( locked )
return;
SetBlendState( additive_blend_state );
}
void D3D11GraphicsDeviceStateManager::EnableAlphaBlending()
{
if( locked )
return;
SetBlendState( transparency_blend_state );
}
void ImageBasedLensFlare::LensBlur(const Ptr<Texture> & setupTex, const Ptr<Texture> & target)
{
int32_t tileSize = 9;
//Extract Sprite Points
int32_t extractWidth = (setupTex->GetDesc().width + tileSize - 1) / tileSize;
int32_t extractHeight = (setupTex->GetDesc().height + tileSize - 1) / tileSize;
RenderBufferDesc spPointsBufDesc;
spPointsBufDesc.bindFlag = BUFFER_BIND_SHADER_RESOURCE | BUFFER_BIND_UNORDERED_ACCESS;
spPointsBufDesc.elementSize = sizeof(float2) + sizeof(float3);
spPointsBufDesc.numElements = extractWidth * extractHeight;
spPointsBufDesc.cpuAccess = 0;
spPointsBufDesc.bStructured = true;
auto spPointsBufRef = BufferPool::Instance().FindFree(spPointsBufDesc);
auto spPointsBuf = spPointsBufRef->Get()->Cast<RenderBuffer>();
{
auto ps = Shader::FindOrCreate<ExtractSpritePointsPS>();
ps->SetScalar("spriteThreshold", _spriteThreshold);
ps->SetSRV("setupTex", setupTex->GetShaderResourceView());
ps->SetUAV("spPointsBuf", spPointsBuf->GetUnorderedAccessView(0, 0, RENDER_FORMAT_UNKNOWN, BUFFER_UAV_APPEND));
ps->Flush();
DrawQuad({}, 0.0f, 0.0f, (float)extractWidth, (float)extractHeight);
}
//Render Sprites
if (!_indirectAgsBuf)
{
RenderBufferDesc indirectArgsBufDesc;
indirectArgsBufDesc.bindFlag = BUFFER_BIND_INDIRECT_ARGS;
indirectArgsBufDesc.elementSize = 16;
indirectArgsBufDesc.numElements = 1;
indirectArgsBufDesc.cpuAccess = 0;
indirectArgsBufDesc.bStructured = false;
uint32_t initData[] = { 0, 1, 0, 0 };
_indirectAgsBuf = Global::GetRenderEngine()->GetRenderFactory()->CreateBuffer();
_indirectAgsBuf->SetDesc(indirectArgsBufDesc);
_indirectAgsBuf->Init(initData);
}
spPointsBuf->CopyStructureCountTo(_indirectAgsBuf, 0, 0, spPointsBuf->GetDesc().numElements, RENDER_FORMAT_UNKNOWN, BUFFER_UAV_APPEND);
{
auto vs = Shader::FindOrCreate<LensBlurVS>();
auto gs = Shader::FindOrCreate<LensBlurGS>();
auto ps = Shader::FindOrCreate<LensBlurPS>();
vs->SetScalar("texSize", target->GetTexSize());
gs->SetScalar("texSize", target->GetTexSize());
gs->SetScalar("flareIntensity", _flareIntensity);
vs->SetSRV("spPointsRenderBuf", spPointsBuf->GetShaderResourceView(0, 0, RENDER_FORMAT_UNKNOWN));
auto lensTexAsset = Asset::Find<TextureAsset>("Textures/Bokeh_Circle.dds");
if (!lensTexAsset->IsInit())
lensTexAsset->Init();
auto lensTex = lensTexAsset->GetTexture();
ps->SetSRV("lensTex", lensTex->GetShaderResourceView());
ps->SetSampler("linearSampler", SamplerTemplate<>::Get());
vs->Flush();
gs->Flush();
ps->Flush();
auto rc = Global::GetRenderEngine()->GetRenderContext();
rc->SetVertexBuffer({});
rc->SetIndexBuffer(nullptr);
rc->SetPrimitiveTopology(PRIMITIVE_TOPOLOGY_POINTLIST);
rc->SetViewport(GetTextureQuadViewport(target));
rc->SetRenderTargets({ target->GetRenderTargetView(0, 0, 1) });
rc->SetDepthStencil(nullptr);
rc->SetDepthStencilState(DepthStencilStateTemplate<false>::Get());
rc->SetBlendState(BlendStateTemplate<false, false, true, BLEND_PARAM_SRC_ALPHA, BLEND_PARAM_ONE, BLEND_OP_ADD>::Get());
rc->DrawInstancedIndirect(_indirectAgsBuf, 0);
rc->ResetShader(SHADER_GS);
rc->SetBlendState(nullptr);
}
}
void SSR::Render(const Ptr<RenderView> & view)
{
auto sceneTex = view->GetViewRenderContext()->GetSharedTexture("RenderResult");
auto sceneClipDepth = view->GetViewRenderContext()->GetSharedTexture("SceneClipDepth");
auto gbuffer0 = view->GetViewRenderContext()->GetSharedTexture("GBuffer0");
auto gbuffer1 = view->GetViewRenderContext()->GetSharedTexture("GBuffer1");
TextureDesc ssrDesc = sceneTex->GetDesc();
ssrDesc.format = RENDER_FORMAT_R16G16B16A16_FLOAT;
auto ssrResultTexRef = TexturePool::Instance().FindFree({ TEXTURE_2D, ssrDesc });
auto ssrResult = ssrResultTexRef->Get()->Cast<Texture>();
auto tmpDepthTexRef = TexturePool::Instance().FindFree({ TEXTURE_2D, sceneClipDepth->GetDesc() });
auto tmpDepthTex = tmpDepthTexRef->Get()->Cast<Texture>();
sceneClipDepth->CopyTo(tmpDepthTex, 0, 0, 0, 0, 0, 0, 0);
auto ps = Shader::FindOrCreate<ScreenSpaceReflectionPS>();
view->BindShaderParams(ps);
ps->SetScalar("frameCount", Global::GetInfo()->frameCount);
ps->SetScalar("ssrMaxRoughness", _ssrMaxRoughness);
ps->SetScalar("ssrIntensity", _ssrIntensity);
ps->SetSRV("sceneTex", sceneTex->GetShaderResourceView());
ps->SetSRV("depthTex", tmpDepthTex->GetShaderResourceView(0, 0, 0, 0, false, RENDER_FORMAT_R24_UNORM_X8_TYPELESS));
ps->SetSRV("gbuffer0", gbuffer0->GetShaderResourceView());
ps->SetSRV("gbuffer1", gbuffer1->GetShaderResourceView());
ps->SetSampler("pointClampSampler", SamplerTemplate<FILTER_MIN_MAG_MIP_POINT>::Get());
ps->SetSampler("linearSampler", SamplerTemplate<>::Get());
ps->Flush();
auto rc = Global::GetRenderEngine()->GetRenderContext();
rc->SetDepthStencilState(
DepthStencilStateTemplate<
false,
DEPTH_WRITE_ZERO,
COMPARISON_LESS,
true, 0xff, 0xff,
STENCIL_OP_KEEP,
STENCIL_OP_KEEP,
STENCIL_OP_KEEP,
COMPARISON_NOT_EQUAL>::Get(), 0);
DrawQuad(
{ ssrResult->GetRenderTargetView(0, 0, 1) },
0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 1.0f,
sceneClipDepth->GetDepthStencilView(0, 0, 1, RENDER_FORMAT_D24_UNORM_S8_UINT));
auto ssrSharedRef = SSRNeighborShare(view, ssrResult, gbuffer1, tmpDepthTex, sceneClipDepth);
auto ssrShared = ssrSharedRef->Get()->Cast<Texture>();
// Temporal AA for SSR
auto ssrAAedResultTexRef = TexturePool::Instance().FindFree({ TEXTURE_2D, sceneTex->GetDesc() });
auto ssrAAedResultTex = ssrAAedResultTexRef->Get()->Cast<Texture>();
{
auto adaptedExposureScale = view->GetViewRenderContext()->GetSharedTexture("AdaptedExposureScale");
float2 offsets[5] =
{
float2(0.0f, 0.0f),
float2(-1.0f, 0.0f),
float2(1.0f, 0.0f),
float2(0.0f, -1.0f),
float2(0.0f, 1.0f),
};
float filterWeights[5];
float weightsSum = 0.0f;
for (int i = 0; i < 5; ++i)
{
float2 offset = offsets[i] - float2(0.5f, -0.5f) * view->temporalAAJitter;
//filterWeights[i] = CatmullRom(offset.x()) * CatmullRom(offset.y());
offset.x() *= 1.0f + 0.0f * 0.5f;
offset.y() *= 1.0f + 0.0f * 0.5f;
filterWeights[i] = exp(-2.29f * (offset.x() * offset.x() + offset.y() * offset.y()));
weightsSum += filterWeights[i];
}
for (auto & i : filterWeights)
i /= weightsSum;
std::map<String, String> macros;
macros["TAA_DYNAMIC"] = "0";
macros["TAA_HISTORY_BICUBIC"] = "0";
auto ps = Shader::FindOrCreate<TemporalAAPS>(macros);
view->BindShaderParams(ps);
ps->SetScalar("texSize", ssrResult->GetTexSize());
ps->SetScalar("neighborFilterWeights", filterWeights, (int)sizeof(float) * 5);
ps->SetScalar("frameCount", (uint32_t)Global::GetInfo()->frameCount);
ps->SetScalar("lerpFactor", 0.125f);
//ps->SetSRV("linearDepth", sceneLinearClipDepth->GetShaderResourceView());
ps->SetSRV("sceneDepth", sceneClipDepth->GetShaderResourceView(0, 0, 0, 0, false, RENDER_FORMAT_R24_UNORM_X8_TYPELESS));
ps->SetSRV("sceneTex", ssrShared->GetShaderResourceView());
//ps->SetSRV("velocityTex", velocityTex->GetShaderResourceView());
//ps->SetSRV("adaptedExposureScale", adaptedExposureScale->GetShaderResourceView());
if (_preSSRResultRef)
ps->SetSRV("historyTex", _preSSRResultRef->Get()->Cast<Texture>()->GetShaderResourceView());
else
ps->SetSRV("historyTex", nullptr);
ps->SetSampler("pointSampler", SamplerTemplate<FILTER_MIN_MAG_MIP_POINT>::Get());
ps->SetSampler("linearSampler", SamplerTemplate<>::Get());
ps->Flush();
DrawQuad(
{ ssrAAedResultTex->GetRenderTargetView(0, 0, 1) },
0.0f, 0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 1.0f,
sceneClipDepth->GetDepthStencilView(0, 0, 1, RENDER_FORMAT_D24_UNORM_S8_UINT));
_preSSRResultRef = ssrResultTexRef;
}
/*rc->SetBlendState(
BlendStateTemplate<false, false, true, BLEND_PARAM_ONE, BLEND_PARAM_ONE, BLEND_OP_ADD>::Get());
rc->SetDepthStencil(sceneClipDepth->GetDepthStencilView(0, 0, 1, RENDER_FORMAT_D24_UNORM_S8_UINT));
Transform(
ssrAAedResultTex->GetShaderResourceView(),
sceneTex->GetRenderTargetView(0, 0, 1),
{ COLOR_WRITE_R, COLOR_WRITE_G ,COLOR_WRITE_B ,COLOR_WRITE_A }, 0.0f, 0.0f, nullptr,
sceneClipDepth->GetDepthStencilView(0, 0, 1, RENDER_FORMAT_D24_UNORM_S8_UINT));*/
rc->SetBlendState(nullptr);
rc->SetDepthStencilState(nullptr);
view->GetViewRenderContext()->SetSharedResource("SSR", ssrAAedResultTexRef);
}
//----------------------------------------------------------------------------------------
bool Renderer::Init( uint32 wndWidth, uint32 wndHeight, HWND hwnd )
{
m_wndWidth = wndWidth;
m_wndHeight = wndHeight;
#if USE_OPENGL
m_pRenderSys = new GLRenderSystem;
_AST(((GLRenderSystem*)m_pRenderSys)->Init(wndWidth, wndHeight, hwnd));
#else
m_pRenderSys = new D3D11RenderSystem;
_AST(((D3D11RenderSystem*)m_pRenderSys)->Init(wndWidth, wndHeight, hwnd));
#endif
// Init rasterize state
SStateRaster rasterState;
rasterState.Desc.AntialiasedLineEnable = false;
rasterState.Desc.CullMode = eCull_BACK;
rasterState.Desc.DepthBias = 0;
rasterState.Desc.DepthBiasClamp = 0.0f;
rasterState.Desc.DepthClipEnable = true;
rasterState.Desc.FillMode = eFill_Solid;
rasterState.Desc.FrontCounterClockwise = false;
rasterState.Desc.MultisampleEnable = false;
rasterState.Desc.ScissorEnable = false;
rasterState.Desc.SlopeScaledDepthBias = 0.0f;
SetRasterState(&rasterState);
// Init depth stencil state
SStateDepth depthState;
depthState.Desc.DepthFunc = eCompareFunc_LESS_EQUAL;
SetDepthState(&depthState);
// Init blend state
SStateBlend blendState;
blendState.Desc.AlphaToCoverageEnable = false;
blendState.Desc.IndependentBlendEnable = false;
blendState.Desc.RenderTarget[0].BlendEnable = false;
blendState.Desc.RenderTarget[0].SrcBlend = eBlend_ONE;
blendState.Desc.RenderTarget[0].DestBlend = eBlend_ZERO;
blendState.Desc.RenderTarget[0].BlendOp = eBlendOp_ADD;
blendState.Desc.RenderTarget[0].SrcBlendAlpha = eBlend_ONE;
blendState.Desc.RenderTarget[0].DestBlendAlpha = eBlend_ZERO;
blendState.Desc.RenderTarget[0].BlendOpAlpha = eBlendOp_ADD;
blendState.Desc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
SetBlendState(&blendState);
// Setup the viewport
m_viewport.Width = (float)wndWidth;
m_viewport.Height = (float)wndHeight;
m_viewport.MinDepth = 0.0f;
m_viewport.MaxDepth = 1.0f;
m_viewport.TopLeftX = 0;
m_viewport.TopLeftY = 0;
SetViewport(&m_viewport);
// Create constant buffers
m_pGlobalCBuf = m_pRenderSys->CreateConstantBuffer(sizeof(cBufferGlobal), 1);
m_pMaterialCB = m_pRenderSys->CreateConstantBuffer(sizeof(cBufferMaterial), 2);
m_pSkinCB = m_pRenderSys->CreateConstantBuffer(sizeof(cBufferSkin), 3);
m_pFont = new Font;
return true;
}
