void Graphics::SetInstanceAttrPointers(Program* program)
{
if (!HasInstancedArrays())
return;
CHECK_ASSERT(program->GetMaterial()->IsBatched());
CHECK_GL_STATUS();
SetVertexBuffer(program->GetMaterial()->GetInstanceBuffer().get());
GLuint modelMatrixLoc = program->GetAttModelMatrixLoc();
if (modelMatrixLoc != -1)
{
for (int i = 0; i < 3; i++)
{
glEnableVertexAttribArray(modelMatrixLoc + i);
glVertexAttribPointer(modelMatrixLoc + i,
4,
GL_FLOAT,
GL_FALSE,
sizeof(InstanceData),
reinterpret_cast<void*>(offsetof(InstanceData, modelMatrixRow0_) + sizeof(float) * 4 * i));
glVertexAttribDivisor(modelMatrixLoc + i, 1);
}
}
else
{
glDisableVertexAttribArray((int)AttributesLoc::MODEL_MATRIX_ROW0);
glDisableVertexAttribArray((int)AttributesLoc::MODEL_MATRIX_ROW1);
glDisableVertexAttribArray((int)AttributesLoc::MODEL_MATRIX_ROW2);
}
GLuint normalMatrixLoc = program->GetAttNormalMatrixLoc();
if (normalMatrixLoc != -1)
{
for (int i = 0; i < 3; i++)
{
glEnableVertexAttribArray(normalMatrixLoc + i);
glVertexAttribPointer(normalMatrixLoc + i,
3,
GL_FLOAT,
GL_FALSE,
sizeof(InstanceData),
reinterpret_cast<void*>(offsetof(InstanceData, normalMatrixCol0_) + sizeof(float) * 3 * i));
glVertexAttribDivisor(normalMatrixLoc + i, 1);
}
}
else
{
glDisableVertexAttribArray((int)AttributesLoc::NORMAL_MATRIX_COL0);
glDisableVertexAttribArray((int)AttributesLoc::NORMAL_MATRIX_COL1);
glDisableVertexAttribArray((int)AttributesLoc::NORMAL_MATRIX_COL2);
}
CHECK_GL_STATUS();
}
void Mesh::DrawGeometry()
{
auto device = Device::GetInstance();
auto meshShader = ShaderStock::GetInstance()->GetMeshShader();
if (this->vertices.size() > 0 && this->triangles.size() > 0)
{
//TODO : add support for more vertex and material formats
if (this->changed)
{
std::vector<VertexFormatItem> vfitems;
vfitems.push_back(VertexFormatItem(0, DataType::FLOAT3, "POSITION", 0, 0));
vfitems.push_back(VertexFormatItem(sizeof(float) * 3, DataType::FLOAT3, "NORMAL", 0, 0));
vfitems.push_back(VertexFormatItem(sizeof(float) * 6, DataType::FLOAT2, "TEXCOORD", 0, 0));
this->vertexFormat = device->CreateVertexFormat(vfitems, meshShader, "Mesh", 0);
std::vector<MeshVertex> data(this->vertices.size());
for (size_t i = 0; i < this->vertices.size(); i++)
{
data[i].x = this->vertices[i].x;
data[i].y = this->vertices[i].y;
data[i].z = this->vertices[i].z;
data[i].nx = this->normals[i].x;
data[i].ny = this->normals[i].y;
data[i].nz = this->normals[i].z;
data[i].u = this->uv[0][i].x;
data[i].v = this->uv[0][i].y;
}
if (this->isDynamic == false)
{
this->vertexBuffer = device->CreateStaticVertexBuffer(sizeof(MeshVertex) * data.size(), &data[0]).Get();
this->indexBuffer = device->CreateStaticIndexBuffer(sizeof(uint32_t) * triangles.size(), &triangles[0]).Get();
}
this->changed = false;
}
device->SetVertexFormat(this->vertexFormat);
device->SetVertexBuffer(this->vertexBuffer, sizeof(MeshVertex), 0);
device->SetIndexBuffer(this->indexBuffer);
if (this->material.texture)
{
meshShader->SetTexture("g_texture", this->material.texture);
meshShader->SetBoolean("g_hasTexture", true);
}
else
{
meshShader->SetBoolean("g_hasTexture", false);
}
meshShader->SetValue("g_material", &this->material, sizeof(Material) - sizeof(Texture*));
meshShader->CommitChanges();
device->DrawIndexed(PrimitiveType::TRIANGLE_LIST, this->triangles.size(), 0, 0);
}
for (size_t i = 0; i < this->subMeshes.size(); i++)
this->subMeshes[i]->DrawGeometry();
}
void CSimpleMeshSceneObject::Load(CRenderPass * RenderPass)
{
if (! Mesh)
{
return;
}
IndexBuffer = Mesh->CreateIndexBuffer();
SetVertexBuffer(0, Mesh->CreateVertexBuffer());
CSimpleSceneObject::Load(RenderPass);
}
void FixedFunctions::Reset()
{
ResetRenderStates();
SetColor();
ResetTransformStates();
ResetTextureStageStates();
ResetMaterialStates();
ResetLights();
SetClipPlaneEnabled();
SetClipPlane();
SetVertexBuffer();
}
void RendererD3D::DrawSprites(Texture* texture, int numSprites, VertexBuffer* vb)
{
// Bind the sprite profile & material
Matrix4x4 ltw;
VertexProfile* currentProfile = SetVertexProfile(mSpriteProfile);
Material* currentMaterial = SetMaterial(mSpriteMaterial, ltw);
VertexBuffer* currentVB = SetVertexBuffer(0, vb);
IndexBuffer* currentIB = SetIndexBuffer(0);
// Bind the texture
TextureD3D9* d3d9Tex = (TextureD3D9*)texture;
mDevice->SetTexture(0, d3d9Tex->GetTexture());
// Draw the sprites
Draw(numSprites * 6, numSprites * 2, ePT_Triangles);
// Restore the old profile and material
SetVertexBuffer(0, currentVB);
SetIndexBuffer(currentIB);
SetVertexProfile(currentProfile);
SetMaterial(currentMaterial, ltw);
}
void Graphics::ResetCachedState()
{
Program::Clear();
viewport_ = Recti(0);
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &systemFbo_); // On IOS default FBO is not zero
// Set up texture data read/write alignment
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
VertexArrayObj::Clear();
lastMesh_ = nullptr;
lastProgram_ = nullptr;
activeMesh_ = nullptr;
activeWindow_ = nullptr;
CHECK_GL_STATUS();
SetClearColor(Color(0, 0, 0, 1));
SetClearDepth(1);
SetClearStencil(0);
SetFrameBuffer(nullptr);
SetStencilTest(DEFAULT_STENCIL_ENABLE, DEFAULT_STENCIL_WRITEMASK, DEFAULT_STENCIL_SFAIL,
DEFAULT_STENCIL_DPFAIL, DEFAULT_STENCIL_DPPASS, DEFAULT_STENCIL_FUNC, DEFAULT_STENCIL_REF, DEFAULT_STENCIL_COMPAREMASK);
SetScissorTest();
CHECK_GL_STATUS();
SetColorMask(DEFAULT_COLOR_MASK);
SetDepthMask(DEFAULT_DEPTH_MASK);
SetDepthFunc(DepthFunc::LESS);
SetStencilMask(DEFAULT_STENCIL_MASK);
SetBlendModeTest(DEFAULT_BLEND_MODE);
EnableDepthTest(DEFAULT_DEPTH_TEST_ENABLE);
EnableCullFace(DEFAULT_CULL_FACE_ENABLE);
SetCullFace(CullFaceMode::DEFAULT);
SetFrontFace(FrontFaceMode::DEFAULT);
CHECK_GL_STATUS();
UnboundTextures();
SetVertexArrayObj(nullptr);
SetVertexBuffer(nullptr);
SetIndexBuffer(nullptr);
SetProgram(nullptr);
SetSlopeScaledBias(0);
CHECK_GL_STATUS();
}
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);
}
//=============================================================================
// update
//=============================================================================
void Application::Update(void)
{
auto graphic_device = system_->GetGraphicDevice();
float4x4 projection_matrix;
float4x4 view_matrix;
float4x4 world_matrix;
view_matrix = utility::math::Identity();
projection_matrix = utility::math::Identity();
projection_matrix = utility::math::OrthoLH(800.0f,600.0f,0.0f,1.0f);
//vertex_shader_->SetValue("_view_matrix",&view_matrix,sizeof(view_matrix));
//vertex_shader_->SetValue("_projection_matrix",&projection_matrix,sizeof(projection_matrix));
//vertex_shader_->SetValue("_world_matrix",&world_matrix,sizeof(world_matrix));
// begin draw
if(graphic_device->BeginDraw())
{
// set render target
// set depth buffer
// clear buffer
graphic_device->Clear();
// set shader
//shader_->Set();
// set vertex declaration
DEBUG_ASSERT(graphic_device->SetVertexDeclaration(vertex_declaration_));
// set vertex buffer
DEBUG_ASSERT(graphic_device->SetVertexBuffer(vertex_buffer_,0,sizeof(float3)));
// draw
//DEBUG_ASSERT(graphic_device->Draw(graphic::GraphicDevice::PRIMITIVE_TYPE::TRIANGLESTRIP,0,2));
graphic_device->Draw();
// end draw
graphic_device->EndDraw();
}
}
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 Graphics::SetBuffers(bool solid, bool allowInstancing)
{
VertexBuffer* vBuffer = activeMesh_->GetVertexBuffer();
if (has_vertex_array_object_ext_ && !vBuffer->IsDynamic())
{
auto vao = VertexArrayObj::GetOrCreate(VAOKey{allowInstancing, activeProgram_, activeMesh_, solid});
vao->Use();
}
else
{
SetVertexBuffer(vBuffer);
SetAttributes(nullptr);
if (allowInstancing && activeProgram_->GetMaterial()->IsBatched() && !vBuffer->IsDynamic())
SetInstanceAttrPointers(activeProgram_);
SetIndexBuffer(activeMesh_->GetIndexBuffer(solid));
}
}
void Terrain::DrawGeometry()
{
auto device = Device::GetInstance();
if (this->changed)
{
GenerateBuffers();
this->changed = false;
}
device->SetVertexFormat(this->vertexFormat);
device->SetVertexBuffer(this->vb.Get(), sizeof(TerrainVertex), 0);
device->SetIndexBuffer(this->ib.Get());
device->GetRenderState()->GetCurrentShader()->CommitChanges();
device->DrawIndexed(PrimitiveType::TRIANGLE_LIST,
(this->xResolution - 1) * (this->yResolution - 1) * 6,
0, 0);
}
void ScreenAlignedTexture::Initialise()
{
D3DXMatrixIdentity( &m_world );
D3DXMatrixIdentity( &m_view );
// create orthographic projection
int bb_width = Graphics::GetInstance()->BackBufferWidth();
int bb_height = Graphics::GetInstance()->BackBufferHeight();
D3DXMatrixOrthoLH(&m_projection, bb_width, bb_height, 0.1f, 100000.0f);
D3DXVECTOR2 tex1 = D3DXVECTOR2(0,1);
D3DXVECTOR2 tex2 = D3DXVECTOR2(1,1);
D3DXVECTOR2 tex3 = D3DXVECTOR2(1,0);
D3DXVECTOR2 tex4 = D3DXVECTOR2(0,0);
VertexPositionTextureNormal vertices[]=
{
{ D3DXVECTOR3( -m_dimensions.X/2, -m_dimensions.Y/2, 1 ), tex1, D3DXVECTOR3(0,1,0)}, // 0
{ D3DXVECTOR3( m_dimensions.X/2, -m_dimensions.Y/2, 1 ), tex2, D3DXVECTOR3(0,1,0)}, // 1
{ D3DXVECTOR3( m_dimensions.X/2, m_dimensions.Y/2, 1), tex3, D3DXVECTOR3(0,1,0)},// 2
{ D3DXVECTOR3( -m_dimensions.X/2, m_dimensions.Y/2, 1 ), tex4, D3DXVECTOR3(0,1,0)},// 3
};
for(int i = 0; i < 4; i++)
{
m_vertices[i] = vertices[i];
}
DWORD indices[] =
{
2,1,3,0
};
for(int i = 0; i < 4; i++)
{
m_indices[i] = indices[i];
}
ID3D10Device * device = Graphics::GetInstance()->Device();
SetVertexBuffer(device, sizeof(m_vertices[0]) * 4, m_vertices);
SetIndexBuffer(device, sizeof(m_indices[0]) * 4, m_indices);
}
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 Renderer::render_mesh(const Mesh * mesh, const Camera &cam)
{
//TODO_MURAT00 : seperate camera from renderer
Camera *old_camera = camera_;
camera_ = (Camera*)&cam;
set_mesh_primitive_topology(mesh);
set_frame_constant_values();
set_mesh_constant_values(mesh);
mesh->get_material()->set_textures();
//set buffers
SetVertexBuffer(mesh->get_vertex_buffer(), sizeof(Mesh::Vertex));
SetIndexBuffer(mesh->get_index_buffer());
RenderIndexed(mesh->get_index_count());
camera_ = old_camera;
}
void RendererGL::DrawTriangleList( HardwareBuffer* VB, HardwareBuffer* IB, u32 VCount, u32 ICount, VertexType eVType /*= EVT_V3TN */ )
{
SetVertexDec( m_ppVertexDecs[eVType] );
SetVertexBuffer(VB, 0);
if (ICount > 0)
{
SetIndexBuffer(IB);
glDrawElements(GL_TRIANGLES, ICount, m_iIndexBufferType, 0);
m_iTriCount += ICount / 3 * m_iBatchCount;
}
else
{
glDrawArrays(GL_TRIANGLES, 0, VCount);
m_iTriCount += VCount / 3 * m_iBatchCount;
}
m_iDrawCount++;
} // DrawTriangleList
void FUE1Model::BuildVertexBuffer( FModelRenderer *renderer )
{
if (GetVertexBuffer(renderer))
return;
if ( !mDataLoaded )
LoadGeometry();
int vsize = 0;
for ( int i=0; i<numGroups; i++ )
vsize += groups[i].numPolys*3;
vsize *= numFrames;
auto vbuf = renderer->CreateVertexBuffer(false,numFrames==1);
SetVertexBuffer(renderer, vbuf);
FModelVertex *vptr = vbuf->LockVertexBuffer(vsize);
int vidx = 0;
for ( int i=0; i<numFrames; i++ )
{
for ( int j=0; j<numGroups; j++ )
{
for ( int k=0; k<groups[j].numPolys; k++ )
{
for ( int l=0; l<3; l++ )
{
UE1Vertex V = verts[polys[groups[j].P[k]].V[l]+i*numVerts];
FVector2 C = polys[groups[j].P[k]].C[l];
FModelVertex *vert = &vptr[vidx++];
vert->Set(V.Pos.X,V.Pos.Y,V.Pos.Z,C.X,C.Y);
if ( groups[j].type&PT_Curvy ) // use facet normal
{
vert->SetNormal(polys[groups[j].P[k]].Normals[i].X,
polys[groups[j].P[k]].Normals[i].Y,
polys[groups[j].P[k]].Normals[i].Z);
}
else vert->SetNormal(V.Normal.X,V.Normal.Y,V.Normal.Z);
}
}
}
}
vbuf->UnlockVertexBuffer();
}
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();
}
}
int main(){
auto pLogger = CB::Log::CLogger::GetInstance();
pLogger->AddStream(CB::IO::File::Open(L"main.log", CB::IO::File::AccessType::WriteOnly, CB::IO::File::OpenAction::AlwaysCreate).Cast<CB::IO::IStream>());
pLogger->AddStream(CB::IO::Console::Create().Cast<CB::IO::IStream>(), CB::Log::CTextFormatter::Create(CB::String::Encoding::ANSI).Cast<CB::Log::IEntryFormatter>());
pLogger->SetDebugMode(true);
try{
auto pWinDriver = CB::Window::LoadDriver(L"MSWindowDriver");
auto pGraphicDriver = CB::Graphic::LoadDriver(L"OGLGraphicDriver");
{
auto pWinManager = pWinDriver->CreateManager();
auto pGraphicManager = pGraphicDriver->CreateManager(pWinManager);
CB::Math::CSize outSize(640, 480);
auto pWindow = pWinManager->CreateWindow(L"GraphicTest", CB::Window::Style::Single, outSize);
auto pGraphicAdapter = pGraphicManager->GetDefaultAdapter();
CB::Graphic::CDisplayMode dispMode(pWindow->GetSize(), 0, CB::Graphic::BufferFormat::B8G8R8X8);
CB::Graphic::CDeviceDesc devDesc(pWindow, dispMode, CB::Graphic::BufferFormat::D24S8, false);
CB::Collection::CList<CB::Graphic::FeatureLevel> featureLevels;
featureLevels.Add(CB::Graphic::FeatureLevel::Level_1);
auto pGraphicDevice = pGraphicAdapter->CreateDevice(pWindow, devDesc, featureLevels);
pWindow->OnClose += CB::Signals::CFunc<const bool, CB::CRefPtr<CB::Window::IWindow>>(CloseEvent);
pWindow->SetVisible(true);
CB::Graphic::CDepthStencilStateDesc depthDesc;
depthDesc.bDepthTestEnabled = true;
depthDesc.uDepthFunction = CB::Graphic::CompareFunc::LessEqual;
auto pDepthState = pGraphicDevice->CreateState(depthDesc);
pGraphicDevice->SetState(pDepthState.Cast<CB::Graphic::IDeviceState>());
CB::Graphic::CRasterizerStateDesc rastDesc;
rastDesc.uCullMode = CB::Graphic::CullMode::None;
auto pRastState = pGraphicDevice->CreateState(rastDesc);
pGraphicDevice->SetState(pRastState.Cast<CB::Graphic::IDeviceState>());
CB::Graphic::CBlendStateDesc blendDesc;
blendDesc.ColorBlend.uDestOperand = CB::Graphic::BlendOption::OneMinusSourceAlpha;
blendDesc.ColorBlend.uSourceOperand = CB::Graphic::BlendOption::SourceAlpha;
blendDesc.ColorBlend.uOperation = CB::Graphic::BlendOperation::Add;
blendDesc.AlphaBlend.uDestOperand = CB::Graphic::BlendOption::OneMinusSourceAlpha;
blendDesc.AlphaBlend.uSourceOperand = CB::Graphic::BlendOption::SourceAlpha;
blendDesc.AlphaBlend.uOperation = CB::Graphic::BlendOperation::Add;
blendDesc.bEnabled[0] = true;
auto pBlendState = pGraphicDevice->CreateState(blendDesc);
pGraphicDevice->SetState(pBlendState.Cast<CB::Graphic::IDeviceState>());
auto pFontManager = CB::Font::CManager::Create();
auto pFontStream = CB::IO::File::Open(L"Assets/font.ttf").Cast<CB::IO::IStream>();
auto pFont = pFontManager->Load(pFontStream);
pFont->SelectFace(0);
pFont->SetSize(24);
CB::Collection::CList<CB::Tools::CFontCharDesc> charDescs;
CB::Tools::CFontTextureGenerator fontGen(pGraphicDevice);
fontGen.MaxTextureSize.Set(512, 512);
auto pTexture = fontGen.Generate(pFont, charDescs);
CB::Tools::CTextMeshGenerator textGen(charDescs);
CB::Tools::CMeshRawIVT textMesh;
textGen.Generate(L"Marek M³ynarski!", textMesh);
CB::Collection::CList<CB::Graphic::CVertexElement> vEls;
vEls.Add(CB::Graphic::CVertexElement(0, L"vinput.vPosition", CB::Graphic::VertexType::Float, 3, 0));
vEls.Add(CB::Graphic::CVertexElement(1, L"vinput.vTexCoord", CB::Graphic::VertexType::Float, 2, 0));
GraphicTest::CShaderLoader shaders(pGraphicDevice, L"Shaders/TextureShader.cg");
auto pTextDecl = pGraphicDevice->CreateVertexDeclaration(shaders.pVertexShader, vEls);
auto pTextVertexBuffer = pGraphicDevice->CreateBuffer(CB::Graphic::BufferType::Vertex, CB::Graphic::BufferUsage::Dynamic, CB::Graphic::BufferAccess::Write, textMesh.Vertices);
auto pTextTCoordBuffer = pGraphicDevice->CreateBuffer(CB::Graphic::BufferType::Vertex, CB::Graphic::BufferUsage::Dynamic, CB::Graphic::BufferAccess::Write, textMesh.TexCoords);
auto pTextIndexBuffer = pGraphicDevice->CreateBuffer(CB::Graphic::BufferType::Index, CB::Graphic::BufferUsage::Dynamic, CB::Graphic::BufferAccess::Write, textMesh.Indices);
float32 fAspect = (float32)outSize.Width / (float32)outSize.Height;
CB::Math::CMatrix mProj = CB::Math::CMatrix::GetPerspective(fAspect, 60.0f, 1.0f, 100.0f);
CB::Math::CMatrix mView = CB::Math::CMatrix::GetTranslation(-4.0f, 0.0f, -3.4f);
CB::Math::CMatrix mModel = CB::Math::CMatrix::GetIdentity();
shaders.pFragmentShader->SetSampler(L"texDiffuse", pTexture.Cast<CB::Graphic::IBaseTexture>());
pTexture->SetFilters(CB::Graphic::TextureFilter::Linear, CB::Graphic::TextureFilter::Linear, CB::Graphic::TextureFilter::Linear);
pTexture->SetAnisotropy(8);
//g_pTexture = texture.pTexture;
while(g_bRun){
pGraphicDevice->Clear(1.0f, 1);
pGraphicDevice->Clear(CB::Math::CColor(1.0f, 0.5f, 0.0f, 1.0f));
pGraphicDevice->BeginRender();
pGraphicDevice->SetShader(shaders.pVertexShader);
pGraphicDevice->SetShader(shaders.pFragmentShader);
static float32 fV = 0.0f;
fV += 20 * g_Timer.GetTimeDelta();
mModel = CB::Math::CMatrix::GetRotation(CB::Math::AxisOrientation::AxisX, fV);
shaders.pVertexShader->SetUniform(L"vinput.mProj", mProj);
shaders.pVertexShader->SetUniform(L"vinput.mView", mView);
shaders.pVertexShader->SetUniform(L"vinput.mModel", mModel);
pGraphicDevice->SetVertexDeclaration(pTextDecl);
pGraphicDevice->SetVertexBuffer(0, pTextVertexBuffer);
pGraphicDevice->SetVertexBuffer(1, pTextTCoordBuffer);
pGraphicDevice->SetIndexBuffer(pTextIndexBuffer);
pGraphicDevice->RenderIndexed(textMesh.uNumberOfPolygons);
pGraphicDevice->EndRender();
g_Timer.Update();
pWinManager->ProcessEvents();
float fFPS = 1.0f / (g_Timer.GetTimeDelta() == 0.0f ? 1.0f : g_Timer.GetTimeDelta());
uint32 uFPS = (uint32)fFPS;
textMesh.Clear();
textGen.Generate(L"FPS: " + CB::String::ToString(uFPS), textMesh);
pTextVertexBuffer->LoadData(textMesh.Vertices);
pTextTCoordBuffer->LoadData(textMesh.TexCoords);
pTextIndexBuffer->LoadData(textMesh.Indices);
pGraphicDevice->Swap();
}
g_pTexture.Release();
}
}
catch(CB::Exception::CException& Exception){
CB::Log::Write(Exception, CB::Log::LogLevel::Fatal);
CB::Message::Show(Exception, CB::Message::Icon::Error);
}
return 0;
}
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);
}
}
// this is the function that creates the shape to render
void FRenderD3D11::InitGraphics()
{
SetConstantBuffer();
SetVertexBuffer();
SetIndexBuffer();
}
void RenderingCommandExecutor::Execute(
Graphics* graphics,
Effekseer::Manager* effectManager,
EffekseerRenderer::Renderer* effectRenderer,
SpriteRenderer3D* spriteRenerer3D,
std::vector<RenderingCommand*>& commands)
{
auto commands_ptr = commands.data();
auto commands_size = commands.size();
auto g = (Graphics_Imp*) graphics;
for (int32_t i = 0; i < commands_size; i++)
{
auto& command = commands_ptr[i];
if (command->GetType() == RenderingCommandType::Clear)
{
auto c = (RenderingCommand_Clear*) command;
g->Clear(c->IsColorTarget, c->IsDepthTarget, c->Color_);
}
else if (command->GetType() == RenderingCommandType::Draw)
{
auto c = (RenderingCommand_Draw*) command;
c->Shader->SetConstantValues(c->ConstantValues, c->ConstantValueCount);
g->SetVertexBuffer(c->VB);
g->SetIndexBuffer(c->IB);
g->SetShader(c->Shader);
g->SetRenderState(c->RS);
if (c->PolyOffset == 0)
{
g->DrawPolygon(c->PolyCount);
}
else
{
g->DrawPolygon(c->PolyOffset, c->PolyCount);
}
}
else if (command->GetType() == RenderingCommandType::DrawInstanced)
{
auto c = (RenderingCommand_DrawInstanced*) command;
c->Shader->SetConstantValues(c->ConstantValues, c->ConstantValueCount);
g->SetVertexBuffer(c->VB);
g->SetIndexBuffer(c->IB);
g->SetShader(c->Shader);
g->SetRenderState(c->RS);
g->DrawPolygonInstanced(c->PolyCount, c->InstanceCount);
}
else if (command->GetType() == RenderingCommandType::SetRenderTarget)
{
auto c = (RenderingCommand_SetRenderTarget*) command;
if (c->RenderTextures[1] == nullptr && c->RenderTextures[2] == nullptr && c->RenderTextures[2] == nullptr)
{
g->SetRenderTarget(
(RenderTexture2D_Imp*)c->RenderTextures[0],
c->Depth);
}
else
{
g->SetRenderTarget(
(RenderTexture2D_Imp*) c->RenderTextures[0],
(RenderTexture2D_Imp*) c->RenderTextures[1],
(RenderTexture2D_Imp*) c->RenderTextures[2],
(RenderTexture2D_Imp*) c->RenderTextures[3],
c->Depth);
}
}
else if (command->GetType() == RenderingCommandType::DrawEffect)
{
auto c = (RenderingCommand_DrawEffect*) command;
// 行列を転置して設定
Effekseer::Matrix44 cameraMat, projMat;
for (auto c_ = 0; c_ < 4; c_++)
{
for (auto r = 0; r < 4; r++)
{
cameraMat.Values[c_][r] = c->CameraMat.Values[r][c_];
projMat.Values[c_][r] = c->ProjMat.Values[r][c_];
}
}
effectRenderer->SetCameraMatrix(cameraMat);
effectRenderer->SetProjectionMatrix(projMat);
effectRenderer->BeginRendering();
effectManager->Draw();
effectRenderer->EndRendering();
// レンダー設定リセット
g->CommitRenderState(true);
}
else if (command->GetType() == RenderingCommandType::DrawSprite)
{
auto c = (RenderingCommand_DrawSprite*) command;
spriteRenerer3D->SetMatrixes(c->CameraMat, c->ProjMat);
spriteRenerer3D->DrawCache();
}
}
}
void CubeObject::Cook(float width, float height, float depth)
{
std::vector<Vertex<VertexType>> vb(8);
std::vector<unsigned> ib(36);
vb[0].m_position.Set(-1.0f, -1.0f, -1.0f, 1.0f);
vb[0].m_normal.Set( -0.577349f, -0.577349f, -0.577349f, 0);
vb[0].m_texture0.Set(0, 0, 0, 0);
vb[1].m_position.Set(-1.0f, 1.0f, -1.0f, 1);
vb[1].m_normal.Set(-0.577349f, 0.577349f, -0.577349f, 0);
vb[1].m_texture0.Set(1, 0, 0, 0);
vb[2].m_position.Set(1.0f, 1.0f, -1.0f, 1);
vb[2].m_normal.Set( 0.577349f, 0.577349f, -0.577349f, 0);
vb[2].m_texture0.Set(1, 1, 0, 0);
vb[3].m_position.Set(1.0f, -1.0f, -1.0f, 1);
vb[3].m_normal.Set(0.577349f, -0.577349f, -0.577349f, 0);
vb[3].m_texture0.Set(0, 1, 0, 0);
vb[4].m_position.Set(-1.0f, -1.0f, 1.0f, 1.0f);
vb[4].m_normal.Set(-0.577349f, -0.577349f, 0.577349f, 0);
vb[4].m_texture0.Set(0, 0, 0, 0);
vb[5].m_position.Set(-1.0f, 1.0f, 1.0f, 1);
vb[5].m_normal.Set(-0.577349f, 0.577349f, 0.577349f, 0);
vb[5].m_texture0.Set(1, 0, 0, 0);
vb[6].m_position.Set(1.0f, 1.0f, 1.0f, 1);
vb[6].m_normal.Set( 0.577349f, 0.577349f, 0.577349f, 0);
vb[6].m_texture0.Set(1, 1, 0, 0);
vb[7].m_position.Set(1.0f, -1.0f, 1.0f, 1);
vb[7].m_normal.Set(0.577349f, -0.577349f, 0.577349f, 0);
vb[7].m_texture0.Set(0, 1, 0, 0);
ib[0] = 4;
ib[1] = 5;
ib[2] = 1;
ib[3] = 5;
ib[4] = 6;
ib[5] = 2;
ib[6] = 6;
ib[7] = 7;
ib[8] = 3;
ib[9] = 7;
ib[10] = 4;
ib[11] = 0;
ib[12] = 0;
ib[13] = 1;
ib[14] = 2;
ib[15] = 7;
ib[16] = 6;
ib[17] = 5;
ib[18] = 0;
ib[19] = 4;
ib[20] = 1;
ib[21] = 1;
ib[22] = 5;
ib[23] = 2;
ib[24] = 2;
ib[25] = 6;
ib[26] = 3;
ib[27] = 3;
ib[28] = 7;
ib[29] = 0;
ib[30] = 3;
ib[31] = 0;
ib[32] = 2;
ib[33] = 4;
ib[34] = 7;
ib[35] = 5;
SetVertexBuffer(vb);
SetIndexBuffer(ib);
VertexArrayObject2<PrimitiveType, VertexType>::Cook();
}
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);
}
