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 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); }
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 VertexManager::CreateDeviceObjects() { m_vertex_draw_offset = 0; m_index_draw_offset = 0; m_vertex_stream_buffer = std::make_unique<D3DStreamBuffer>(MAXVBUFFERSIZE * 2, MAX_VBUFFER_SIZE, &m_vertex_stream_buffer_reallocated); m_index_stream_buffer = std::make_unique<D3DStreamBuffer>(MAXIBUFFERSIZE * sizeof(u16) * 2, MAXIBUFFERSIZE * sizeof(u16) * 16, &m_index_stream_buffer_reallocated); SetIndexBuffer(); // Use CPU-only memory if the GPU won't be reading from the buffers, // since reading upload heaps on the CPU is slow.. m_vertex_cpu_buffer.resize(MAXVBUFFERSIZE); m_index_cpu_buffer.resize(MAXIBUFFERSIZE); }
void VertexManager::CreateDeviceObjects() { m_vertexDrawOffset = 0; m_indexDrawOffset = 0; CheckHR( D3D::device12->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(MAX_VBUFFER_SIZE), D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&m_vertexBuffer) ) ); D3D::SetDebugObjectName12(m_vertexBuffer, "Vertex Buffer of VertexManager"); CheckHR(m_vertexBuffer->Map(0, nullptr, &m_vertexBufferData)); CheckHR( D3D::device12->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(MAX_IBUFFER_SIZE), D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&m_indexBuffer) ) ); D3D::SetDebugObjectName12(m_indexBuffer, "Index Buffer of VertexManager"); CheckHR(m_indexBuffer->Map(0, nullptr, &m_indexBufferData)); SetIndexBuffer(); // Use CPU-only memory if the GPU won't be reading from the buffers, // since reading upload heaps on the CPU is slow.. vertexCpuBuffer = new u8[MAXVBUFFERSIZE]; indexCpuBuffer = new u8[MAXIBUFFERSIZE]; }
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; }
//+------------------------------------------------------------------+ //| Custom indicator initialization function | //+------------------------------------------------------------------+ int init() { IndicatorBuffers(7); //---- drawing settings SetIndexStyle(0,DRAW_SECTION); //---- indicator buffers mapping SetIndexBuffer(0,MasterIndicator); SetIndexBuffer(1,SNN_Indicator); SetIndexBuffer(2,ZigzagBuffer); SetIndexBuffer(3,HighMapBuffer); SetIndexBuffer(4,LowMapBuffer); SetIndexBuffer(5,CompraE_S1); SetIndexBuffer(6,VentaE_S1); SetIndexEmptyValue(0,0.0); SetIndexEmptyValue(1,0.0); SetIndexEmptyValue(2,0.0); SetIndexEmptyValue(5,0.0); SetIndexEmptyValue(6,0.0); //---- indicator short name IndicatorShortName("H5PHET - Master Trainer 2 ("+pipsTPSL+","+maxDias+","+numDias+")"); //---- initialization done PrimeraVez=0; // Para que se ejecute solo una vez después de la inicialización. // agregado por H // new label object ObjectDelete("label_object2"); if(!ObjectCreate("label_object2", OBJ_LABEL, 0, 0, 0)) { Print("error: cant create label_object! code #",GetLastError()); return(0); } ObjectSet("label_object2", OBJPROP_XDISTANCE, 250); ObjectSet("label_object2", OBJPROP_YDISTANCE, 0); ObjectSetText("label_object2", "H5PHET - Master Trainer 2", 10, "Times New Roman", Green); caso1=0; caso2=0; caso3_1=0; caso3_2=0; maxMinutos=maxDias*1440; return(0); }
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 VertexManager::ResetBuffer(u32 stride) { if (m_cull_all) { m_cur_buffer_pointer = m_vertex_cpu_buffer.data(); m_base_buffer_pointer = m_vertex_cpu_buffer.data(); m_end_buffer_pointer = m_vertex_cpu_buffer.data() + MAXVBUFFERSIZE; IndexGenerator::Start(reinterpret_cast<u16*>(m_index_cpu_buffer.data())); return; } m_vertex_stream_buffer->AllocateSpaceInBuffer(MAXVBUFFERSIZE, stride); if (m_vertex_stream_buffer_reallocated) { D3D::command_list_mgr->SetCommandListDirtyState(COMMAND_LIST_STATE_VERTEX_BUFFER, true); m_vertex_stream_buffer_reallocated = false; } m_base_buffer_pointer = static_cast<u8*>(m_vertex_stream_buffer->GetBaseCPUAddress()); m_end_buffer_pointer = m_base_buffer_pointer + m_vertex_stream_buffer->GetSize(); m_cur_buffer_pointer = static_cast<u8*>(m_vertex_stream_buffer->GetCPUAddressOfCurrentAllocation()); m_vertex_draw_offset = static_cast<u32>(m_vertex_stream_buffer->GetOffsetOfCurrentAllocation()); m_index_stream_buffer->AllocateSpaceInBuffer(MAXIBUFFERSIZE * sizeof(u16), sizeof(u16)); if (m_index_stream_buffer_reallocated) { SetIndexBuffer(); m_index_stream_buffer_reallocated = false; } m_index_draw_offset = static_cast<u32>(m_index_stream_buffer->GetOffsetOfCurrentAllocation()); IndexGenerator::Start( static_cast<u16*>(m_index_stream_buffer->GetCPUAddressOfCurrentAllocation())); }
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 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 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 init() { // E Farrell 2013 IndicatorDigits(10); IndicatorShortName("LEVY PHASE (F. Farrell)"); // Show or Hide a particular line? // // Use "DRAW_NONE" to hide a line // Use "DRAW_LINE" to display a line // Line 0: // Stochastic Volatility Line SetIndexBuffer (0, vols); SetIndexLabel (0, "Volatility"); SetIndexDrawBegin (0, Lookback); SetIndexStyle (0, DRAW_NONE); //SetIndexStyle (0, DRAW_LINE); // Line 1: // Levy Index of closing price (signal) SetIndexBuffer (1, levy_signal); SetIndexLabel (1, "levy_signal"); SetIndexDrawBegin (1, Lookback*2); SetIndexStyle (1, DRAW_NONE); //SetIndexStyle (1, DRAW_LINE); // Line 2: // Levy Index of Volatility SetIndexBuffer (2, levy_vol); SetIndexLabel (2, "levy_vol"); SetIndexDrawBegin (2, Lookback*2); SetIndexStyle (2, DRAW_NONE); //SetIndexStyle (2, DRAW_LINE); // Line 3: // Wrapped Phase Line SetIndexBuffer (3, phase_wrapped); SetIndexLabel (3, "Phase (wrapped)"); SetIndexDrawBegin (3, Lookback*2); //SetIndexStyle (3, DRAW_NONE); SetIndexStyle (3, DRAW_LINE); // Line 4: // Unwrapped Phase Line SetIndexBuffer (4, phase_unwrapped); SetIndexLabel (4, "Phase (Unwrapped)"); SetIndexDrawBegin (4, Lookback*2); //SetIndexStyle (4, DRAW_NONE); SetIndexStyle (4, DRAW_LINE); // Line 5: // Linear approximation of unwrapped phase SetIndexBuffer (5, least_squares_line); SetIndexLabel (5, "Regression Line"); SetIndexDrawBegin (5, Lookback*2); //SetIndexStyle (5, DRAW_NONE); SetIndexStyle (5, DRAW_LINE); // Line 6: // Final Adjusted Phase Line SetIndexBuffer (6, phase_adjusted); SetIndexLabel (6, "Phase (Adjusted)"); SetIndexDrawBegin (6, Lookback*2); SetIndexStyle (6, DRAW_LINE); if (DEBUG == 1) { // Create Debug File to show array values. // It is CSV style, with ";" as field seperators. // // Name: 'Debug File HH-MM.txt' // Location: 'c:\<<alpari directory>>\experts\files\' // file_name = "DebugFile "; file_name = StringConcatenate (file_name, DoubleToStr(Hour()-2,0), "-"); file_name = StringConcatenate (file_name, DoubleToStr(Minute(),0), ".txt"); file_handle = FileOpen (file_name, FILE_CSV|FILE_WRITE, ";"); Print (file_name, " was opened."); if(file_handle == -1) { // File Error occurred Alert ("An error while opening the file. Last Error: ", GetLastError()); } } return(0); }
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 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 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 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); }