void Renderer::set_mesh_primitive_topology(const Mesh * mesh)
{
switch (mesh->get_mesh_type())
{
case Mesh::MeshType::triangle_mesh:
SetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
break;
case Mesh::MeshType::line_mesh:
SetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINELIST);
break;
}
}
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 DRender::DrawMesh( DSimpleMesh * simpleMesh ) {
assert( simpleMesh );
assert( m_context );
UpdateMatrices();
DMaterialController::DMaterial *material = nullptr;
simpleMesh->GetMaterial( &material );
assert( material );
SetMaterial( material );
auto vertexViewPtr = simpleMesh->GetVertices();
assert( vertexViewPtr );
auto indexViewPtr = simpleMesh->GetIndices();
assert( indexViewPtr );
SetVertexBufferView( vertexViewPtr.Get() );
SetIndexBufferView( indexViewPtr.Get() );
SetPrimitiveTopology( D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
m_context->DrawIndexed(
simpleMesh->GetIndexCount(),
simpleMesh->GetStartIndexLocation(),
simpleMesh->GetStartVertexLocation()
);
}
void RenderToVolumeTexture(const Ptr<Texture> & volumeTexture)
{
auto rc = Global::GetRenderEngine()->GetRenderContext();
auto & quadVBs = GetQuadVBs();
auto & quadIB = GetQuadIB();
RenderViewport vp;
vp.topLeftX = 0.0f;
vp.topLeftY = 0.0f;
vp.width = static_cast<float>(volumeTexture->GetDesc().width);
vp.height = static_cast<float>(volumeTexture->GetDesc().height);
vp.minDepth = 0.0f;
vp.maxDepth = 1.0f;
rc->SetViewport(vp);
float2 uvMap[4];
uvMap[0] = float2(0.0f, 0.0f);
uvMap[1] = float2(1.0f, 0.0f);
uvMap[2] = float2(0.0f, 1.0f);
uvMap[3] = float2(1.0f, 1.0f);
auto uvBufMappedData = quadVBs[1]->Map(MAP_WRITE_DISCARD);
memcpy(uvBufMappedData.pData, uvMap, sizeof(float2) * 4);
quadVBs[1]->UnMap();
// Set vbs, ib
rc->SetVertexBuffer(quadVBs);
rc->SetIndexBuffer(quadIB);
rc->SetPrimitiveTopology(PRIMITIVE_TOPOLOGY_TRIANGLELIST);
// Set rtv
rc->SetRenderTargets({ volumeTexture->GetRenderTargetView(0, 0, volumeTexture->GetDesc().depth) });
// Set dsv
rc->SetDepthStencilState(DepthStencilStateTemplate<false>::Get());
// Bind shader
auto vs = Shader::FindOrCreate<RenderToVolumeTextureVS>();
auto gs = Shader::FindOrCreate<RenderToVolumeTextureGS>();
vs->Flush();
gs->Flush();
// Draw
rc->DrawIndexedInstanced(quadIB->GetDesc().numElements, volumeTexture->GetDesc().depth, 0, 0, 0);
rc->SetDepthStencilState(nullptr);
rc->ResetShader(SHADER_GS);
}
void Renderer::forward_rendering_pipeline()
{
//set states
{
SetViewPortToDefault();
if (use_postfx)
{
SetRenderViews(screen_texture->get_rt(), GetDefaultDepthStencilView(), 0);
}
else
{
SetRenderViews(GetDefaultRenderTargetView(), GetDefaultDepthStencilView(), 0);
}
clearScreen(D3DXVECTOR4(0, 0, 0, 0));
SetDepthState(depth_state_enable_test_enable_write);
default_render_shader->set_shaders();
SetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
}
const vector<Mesh*> &meshes_to_render = scene_to_render->get_meshes();
for (int i = 0; i < meshes_to_render.size(); i++)
{
Mesh *mesh_to_render = meshes_to_render[i];
mesh_to_render->get_material()->set_textures();
set_mesh_constant_values(mesh_to_render);
//set buffers
SetVertexBuffer(mesh_to_render->get_vertex_buffer(), sizeof(Mesh::Vertex));
SetIndexBuffer(mesh_to_render->get_index_buffer());
SetSamplerState();
if (mesh_to_render->is_wireframe())
{
SetRasterState(raster_state_wireframe_mode);
}
else
{
SetRasterState(raster_state_fill_mode);
}
//render
int tri_to_render = mesh_to_render->get_index_count();
RenderIndexed(tri_to_render);
}
}
void TextureFilter(
const Ptr<ShaderResourceView> & src,
const Ptr<RenderTargetView> & dst,
const std::vector<float2> & uvOffsets,
const std::vector<float> & weights,
const Ptr<class Sampler> & sampler)
{
ToyGE_ASSERT(uvOffsets.size() == weights.size());
ToyGE_ASSERT(src);
ToyGE_ASSERT(dst);
int32_t numSamples = (int32_t)uvOffsets.size();
if (numSamples <= 0)
return;
auto rc = Global::GetRenderEngine()->GetRenderContext();
rc->SetViewport(GetTextureQuadViewport(dst->GetResource()->Cast<Texture>()));
auto filterVS = Shader::FindOrCreate<FilterVS>({ { "NUM_SAMPLES", std::to_string(numSamples) } });
auto filterPS = Shader::FindOrCreate<FilterPS>({ { "NUM_SAMPLES", std::to_string(numSamples) } });
filterVS->SetScalar("samplesOffsets", &uvOffsets[0], (int32_t)(sizeof(uvOffsets[0]) * uvOffsets.size()));
filterVS->Flush();
filterPS->SetScalar("samplesWeights", &weights[0], (int32_t)(sizeof(weights[0]) * weights.size()));
filterPS->SetSRV("filterTex", src);
filterPS->SetSampler("filterSampler", sampler ? sampler : SamplerTemplate<>::Get());
filterPS->Flush();
rc->SetRenderTargets({ dst });
rc->SetDepthStencil(nullptr);
rc->SetDepthStencilState(DepthStencilStateTemplate<false>::Get());
rc->SetVertexBuffer({ GetQuadVBs()[0] });
rc->SetIndexBuffer(GetQuadIB());
rc->SetPrimitiveTopology(PRIMITIVE_TOPOLOGY_TRIANGLELIST);
rc->DrawIndexed(0, 0);
}
void SkyBox::Render(const Ptr<RenderTargetView> & target, const Ptr<DepthStencilView> & dsv, const Ptr<RenderView> & view)
{
if (!_tex)
return;
auto rc = Global::GetRenderEngine()->GetRenderContext();
auto translationMat = translation(view->GetCamera()->GetPos());
auto transformMat = mul(translationMat, view->GetCamera()->GetViewProjMatrix());
auto vs = Shader::FindOrCreate<SkyBoxVS>();
auto ps = Shader::FindOrCreate<SkyBoxPS>();
vs->SetScalar("transform", transformMat);
ps->SetSRV("skyBoxTex", _tex->GetShaderResourceView(0, 0, 0, 0, true));
ps->SetSampler("linearSampler", SamplerTemplate<>::Get());
vs->Flush();
ps->Flush();
rc->SetViewport(GetTextureQuadViewport(target->GetResource()->Cast<Texture>()));
rc->SetRenderTargets({ target });
rc->SetDepthStencil(dsv);
rc->SetRasterizerState(RasterizerStateTemplate<FILL_SOLID, CULL_NONE>::Get());
rc->SetDepthStencilState(DepthStencilStateTemplate<true, DEPTH_WRITE_ZERO, COMPARISON_LESS_EQUAL>::Get());
rc->SetVertexBuffer(_sphereMesh->GetRenderData()->GetMeshElements()[0]->GetVertexBuffer());
rc->SetIndexBuffer(_sphereMesh->GetRenderData()->GetMeshElements()[0]->GetIndexBuffer());
rc->SetPrimitiveTopology(PRIMITIVE_TOPOLOGY_TRIANGLELIST);
rc->DrawIndexed(0, 0);
rc->SetRasterizerState(nullptr);
rc->SetDepthStencilState(nullptr);
}
void Renderer::gbuffer_render()
{
invalidate_srv(shaderType::shader_type_pixel);
gbuffer_albedo_texture->set_as_render_target(0);
gbuffer_normal_texture->set_as_render_target(1);
gbuffer_specular_texture->set_as_render_target(2);
clearScreen(D3DXVECTOR4(0, 0, 0, 0));
ClearRenderView(D3DXVECTOR4(0, 0, 0, 0), 1);
ClearRenderView(D3DXVECTOR4(0, 0, 0, 0),2);
SetDepthState(depth_state_enable_test_enable_write);
SetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
const vector<Mesh*> &meshes_to_render = scene_to_render->get_meshes();
for (int i = 0; i < meshes_to_render.size(); i++)
{
Mesh *mesh_to_render = meshes_to_render[i];
if (mesh_to_render->get_material())
{
mesh_to_render->get_material()->set_textures();
}
set_mesh_constant_values(mesh_to_render);
Shader *shader_to_set = mesh_to_render->get_material() ? mesh_to_render->get_material()->get_enforced_gbuffer_shader() : nullptr;
if (shader_to_set == nullptr)
{
shader_to_set = gbuffer_shader;
}
shader_to_set->set_shaders();
//set buffers
SetVertexBuffer(mesh_to_render->get_vertex_buffer(), sizeof(Mesh::Vertex));
SetIndexBuffer(mesh_to_render->get_index_buffer());
set_mesh_primitive_topology(mesh_to_render);
if (mesh_to_render->is_wireframe())
{
SetRasterState(raster_state_wireframe_mode);
}
else
{
SetRasterState(raster_state_fill_mode);
}
SetSamplerState();
//render
int tri_to_render = mesh_to_render->get_index_count();
RenderIndexed(tri_to_render);
}
SetRenderTargetView(nullptr, 0);
SetRenderTargetView(nullptr, 1);
SetRenderTargetView(nullptr, 2);
for (int i = 0; i < render_components.size(); i++)
{
render_components[i]->post_gbuffer_render();
}
}
void DrawQuad(
const std::vector< Ptr<class RenderTargetView> > & rtvs,
float topLeftX,
float topLeftY,
float width,
float height,
float topLeftU,
float topLeftV,
float uvWidth,
float uvHeight,
const Ptr<class DepthStencilView> & dsv)
{
/*if (rtvs.size() == 0)
return;*/
auto & quadVBs = GetQuadVBs();
auto & quadIB = GetQuadIB();
auto rc = Global::GetRenderEngine()->GetRenderContext();
// Viewport
if (width == 0.0f)
{
if (rtvs.size() > 0)
{
auto tex = rtvs[0]->GetResource()->Cast<Texture>();
auto & mipSize = tex->GetMipSize(rtvs[0]->Cast<TextureRenderTargetView>()->mipLevel);
width = (float)mipSize.x();
}
else if (dsv)
{
auto tex = dsv->GetResource()->Cast<Texture>();
auto & mipSize = tex->GetMipSize(dsv->Cast<TextureDepthStencilView>()->mipLevel);
width = (float)mipSize.x();
}
}
if (height == 0.0f)
{
if (rtvs.size() > 0)
{
auto tex = rtvs[0]->GetResource()->Cast<Texture>();
auto & mipSize = tex->GetMipSize(rtvs[0]->Cast<TextureRenderTargetView>()->mipLevel);
height = (float)mipSize.y();
}
else if (dsv)
{
auto tex = dsv->GetResource()->Cast<Texture>();
auto & mipSize = tex->GetMipSize(dsv->Cast<TextureDepthStencilView>()->mipLevel);
height = (float)mipSize.y();
}
}
RenderViewport vp;
vp.topLeftX = static_cast<float>(topLeftX);
vp.topLeftY = static_cast<float>(topLeftY);
vp.width = static_cast<float>(width);
vp.height = static_cast<float>(height);
vp.minDepth = 0.0f;
vp.maxDepth = 1.0f;
rc->SetViewport(vp);
// Update uvs
float2 uvMap[4];
uvMap[0] = float2(topLeftU, topLeftV);
uvMap[1] = float2(topLeftU + uvWidth, topLeftV);
uvMap[2] = float2(topLeftU, topLeftV + uvHeight);
uvMap[3] = float2(topLeftU + uvWidth, topLeftV + uvHeight);
auto uvBufMappedData = quadVBs[1]->Map(MAP_WRITE_DISCARD);
memcpy(uvBufMappedData.pData, uvMap, sizeof(float2) * 4);
quadVBs[1]->UnMap();
// Set vbs, ib
rc->SetVertexBuffer(quadVBs);
rc->SetIndexBuffer(quadIB);
rc->SetPrimitiveTopology(PRIMITIVE_TOPOLOGY_TRIANGLELIST);
// Set rtv
rc->SetRenderTargets(rtvs);
// Set dsv
rc->SetDepthStencil(dsv);
if (!dsv)
rc->SetDepthStencilState(DepthStencilStateTemplate<false>::Get());
// Bind shader
auto drawQuadVS = Shader::FindOrCreate<DrawQuadVS>();
drawQuadVS->Flush();
// Draw
rc->DrawIndexed(0, 0);
if (!dsv)
rc->SetDepthStencilState(nullptr);
}
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);
}
}
