void CKRSView::ReloadDataView() { m_ptmData = pgtmData; m_pcurGlub = pgcurGlub; ClearAllParamsBuffers(&m_MapParam, m_ptmData, m_pcurGlub); DeleteView(); InitViews(&m_wndDialogBar, &m_MapParam); CheckRegim(); m_wndDialogBar.m_PanelKnopki.Init(RT_NUM_LISTS, CSize(20,20), this); m_wndDialogBar.m_PanelKnopki.PushBtn(m_parOfView->GetNumActiveList()); CheckGrf(); }
/** * Renders the view family. */ void FDeferredShadingSceneRenderer::Render() { if(!ViewFamily.EngineShowFlags.Rendering) { return; } SCOPED_DRAW_EVENT(Scene,DEC_SCENE_ITEMS); // Initialize global system textures (pass-through if already initialized). GSystemTextures.InitializeTextures(); // Allocate the maximum scene render target space for the current view family. GSceneRenderTargets.Allocate(ViewFamily); // Find the visible primitives. InitViews(); const bool bIsWireframe = ViewFamily.EngineShowFlags.Wireframe; static const auto ClearMethodCVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.ClearSceneMethod")); bool bRequiresRHIClear = true; bool bRequiresFarZQuadClear = false; if (ClearMethodCVar) { switch (ClearMethodCVar->GetValueOnRenderThread()) { case 0: // No clear { bRequiresRHIClear = false; bRequiresFarZQuadClear = false; break; } case 1: // RHIClear { bRequiresRHIClear = true; bRequiresFarZQuadClear = false; break; } case 2: // Clear using far-z quad { bRequiresFarZQuadClear = true; bRequiresRHIClear = false; break; } } } // Always perform a full buffer clear for wireframe, shader complexity view mode, and stationary light overlap viewmode. if (bIsWireframe || ViewFamily.EngineShowFlags.ShaderComplexity || ViewFamily.EngineShowFlags.StationaryLightOverlap) { bRequiresRHIClear = true; } // force using occ queries for wireframe if rendering is parented or frozen in the first view check(Views.Num()); #if (UE_BUILD_SHIPPING || UE_BUILD_TEST) const bool bIsViewFrozen = false; const bool bHasViewParent = false; #else const bool bIsViewFrozen = Views[0].State && ((FSceneViewState*)Views[0].State)->bIsFrozen; const bool bHasViewParent = Views[0].State && ((FSceneViewState*)Views[0].State)->HasViewParent(); #endif const bool bIsOcclusionTesting = DoOcclusionQueries() && (!bIsWireframe || bIsViewFrozen || bHasViewParent); // Dynamic vertex and index buffers need to be committed before rendering. FGlobalDynamicVertexBuffer::Get().Commit(); FGlobalDynamicIndexBuffer::Get().Commit(); // Notify the FX system that the scene is about to be rendered. if (Scene->FXSystem) { Scene->FXSystem->PreRender(); } // Draw the scene pre-pass / early z pass, populating the scene depth buffer and HiZ RenderPrePass(); // Clear scene color buffer if necessary. if ( bRequiresRHIClear ) { ClearView(); // Only clear once. bRequiresRHIClear = false; } // Clear LPVs for all views if ( IsFeatureLevelSupported(GRHIShaderPlatform, ERHIFeatureLevel::SM5) ) { ClearLPVs(); } // only temporarily available after early z pass and until base pass check(!GSceneRenderTargets.DBufferA); check(!GSceneRenderTargets.DBufferB); check(!GSceneRenderTargets.DBufferC); if(IsDBufferEnabled()) { GSceneRenderTargets.ResolveSceneDepthTexture(); // Resolve the scene depth to an auxiliary texture when SM3/SM4 is in use. This needs to happen so the auxiliary texture can be bound as a shader parameter // while the primary scene depth texture can be bound as the target. Simultaneously binding a single DepthStencil resource as a parameter and target // is unsupported in d3d feature level 10. if(!(GRHIFeatureLevel >= ERHIFeatureLevel::SM5) && GRHIFeatureLevel >= ERHIFeatureLevel::SM4) { GSceneRenderTargets.ResolveSceneDepthToAuxiliaryTexture(); } // e.g. ambient cubemaps, ambient occlusion, deferred decals for(int32 ViewIndex = 0;ViewIndex < Views.Num();ViewIndex++) { SCOPED_CONDITIONAL_DRAW_EVENTF(EventView,Views.Num() > 1, DEC_SCENE_ITEMS, TEXT("View%d"), ViewIndex); GCompositionLighting.ProcessBeforeBasePass(Views[ViewIndex]); } } if(bIsWireframe && FDeferredShadingSceneRenderer::ShouldCompositeEditorPrimitives(Views[0])) { // In Editor we want wire frame view modes to be MSAA for better quality. Resolve will be done with EditorPrimitives RHISetRenderTarget(GSceneRenderTargets.GetEditorPrimitivesColor(), GSceneRenderTargets.GetEditorPrimitivesDepth()); RHIClear(true, FLinearColor(0, 0, 0, 0), true, 0.0f, false, 0, FIntRect()); } else { // Begin rendering to scene color GSceneRenderTargets.BeginRenderingSceneColor(true); } RenderBasePass(); if(ViewFamily.EngineShowFlags.VisualizeLightCulling) { // clear out emissive and baked lighting (not too efficient but simple and only needed for this debug view) GSceneRenderTargets.BeginRenderingSceneColor(false); RHIClear(true, FLinearColor(0, 0, 0, 0), false, 0, false, 0, FIntRect()); } GSceneRenderTargets.DBufferA.SafeRelease(); GSceneRenderTargets.DBufferB.SafeRelease(); GSceneRenderTargets.DBufferC.SafeRelease(); // only temporarily available after early z pass and until base pass check(!GSceneRenderTargets.DBufferA); check(!GSceneRenderTargets.DBufferB); check(!GSceneRenderTargets.DBufferC); if (bRequiresFarZQuadClear) { // Clears view by drawing quad at maximum Z // TODO: if all the platforms have fast color clears, we can replace this with an RHIClear. ClearGBufferAtMaxZ(); bRequiresFarZQuadClear = false; } GSceneRenderTargets.ResolveSceneColor(FResolveRect(0, 0, ViewFamily.FamilySizeX, ViewFamily.FamilySizeY)); GSceneRenderTargets.ResolveSceneDepthTexture(); // Resolve the scene depth to an auxiliary texture when SM3/SM4 is in use. This needs to happen so the auxiliary texture can be bound as a shader parameter // while the primary scene depth texture can be bound as the target. Simultaneously binding a single DepthStencil resource as a parameter and target // is unsupported in d3d feature level 10. if(!GSupportsDepthFetchDuringDepthTest) { GSceneRenderTargets.ResolveSceneDepthToAuxiliaryTexture(); } RenderCustomDepthPass(); // Notify the FX system that opaque primitives have been rendered and we now have a valid depth buffer. if (Scene->FXSystem && Views.IsValidIndex(0)) { Scene->FXSystem->PostRenderOpaque( Views.GetTypedData(), GSceneRenderTargets.GetSceneDepthTexture(), GSceneRenderTargets.GetGBufferATexture() ); } // Update the quarter-sized depth buffer with the current contents of the scene depth texture. // This needs to happen before occlusion tests, which makes use of the small depth buffer. UpdateDownsampledDepthSurface(); // Issue occlusion queries // This is done after the downsampled depth buffer is created so that it can be used for issuing queries if ( bIsOcclusionTesting ) { BeginOcclusionTests(); } // Render lighting. if (ViewFamily.EngineShowFlags.Lighting && GRHIFeatureLevel >= ERHIFeatureLevel::SM4 && ViewFamily.EngineShowFlags.DeferredLighting ) { // Pre-lighting composition lighting stage // e.g. deferred decals, blurred GBuffer for(int32 ViewIndex = 0;ViewIndex < Views.Num();ViewIndex++) { SCOPED_CONDITIONAL_DRAW_EVENTF(EventView,Views.Num() > 1, DEC_SCENE_ITEMS, TEXT("View%d"), ViewIndex); GCompositionLighting.ProcessAfterBasePass(Views[ViewIndex]); } // Clear the translucent lighting volumes before we accumulate ClearTranslucentVolumeLighting(); RenderLights(); InjectAmbientCubemapTranslucentVolumeLighting(); CompositeIndirectTranslucentVolumeLighting(); // Filter the translucency lighting volume now that it is complete FilterTranslucentVolumeLighting(); // Clear LPVs for all views if ( IsFeatureLevelSupported(GRHIShaderPlatform, ERHIFeatureLevel::SM5) ) { PropagateLPVs(); } // Render reflections that only operate on opaque pixels RenderDeferredReflections(); // Post-lighting composition lighting stage // e.g. ambient cubemaps, ambient occlusion, LPV indirect for(int32 ViewIndex = 0; ViewIndex < Views.Num(); ++ViewIndex) { SCOPED_CONDITIONAL_DRAW_EVENTF(EventView,Views.Num() > 1, DEC_SCENE_ITEMS, TEXT("View%d"), ViewIndex); GCompositionLighting.ProcessLighting(Views[ViewIndex]); } } if( ViewFamily.EngineShowFlags.StationaryLightOverlap && GRHIFeatureLevel >= ERHIFeatureLevel::SM4) { RenderStationaryLightOverlap(); } FLightShaftsOutput LightShaftOutput; // Draw Lightshafts if (ViewFamily.EngineShowFlags.LightShafts) { LightShaftOutput = RenderLightShaftOcclusion(); } // Draw atmosphere if(ShouldRenderAtmosphere(ViewFamily)) { if (Scene->AtmosphericFog) { // Update RenderFlag based on LightShaftTexture is valid or not if (LightShaftOutput.bRendered) { Scene->AtmosphericFog->RenderFlag &= EAtmosphereRenderFlag::E_LightShaftMask; } else { Scene->AtmosphericFog->RenderFlag |= EAtmosphereRenderFlag::E_DisableLightShaft; } #if WITH_EDITOR if (Scene->bIsEditorScene) { // Precompute Atmospheric Textures Scene->AtmosphericFog->PrecomputeTextures(Views.GetTypedData(), &ViewFamily); } #endif RenderAtmosphere(LightShaftOutput); } } // Draw fog. if(ShouldRenderFog(ViewFamily)) { RenderFog(LightShaftOutput); } // No longer needed, release LightShaftOutput.LightShaftOcclusion = NULL; // Draw translucency. if(ViewFamily.EngineShowFlags.Translucency) { SCOPE_CYCLE_COUNTER(STAT_TranslucencyDrawTime); if(ViewFamily.EngineShowFlags.Refraction) { // to apply refraction effect by distorting the scene color RenderDistortion(); } RenderTranslucency(); } if (ViewFamily.EngineShowFlags.LightShafts) { RenderLightShaftBloom(); } // Resolve the scene color for post processing. GSceneRenderTargets.ResolveSceneColor(FResolveRect(0, 0, ViewFamily.FamilySizeX, ViewFamily.FamilySizeY)); #if !(UE_BUILD_SHIPPING || UE_BUILD_TEST) if(CVarTestUIBlur.GetValueOnRenderThread() > 0) { Views[0].UIBlurOverrideRectangles.Add(FIntRect(20, 20, 400, 400)); } #endif // Finish rendering for each view. if(ViewFamily.bResolveScene) { SCOPED_DRAW_EVENT(FinishRendering, DEC_SCENE_ITEMS); SCOPE_CYCLE_COUNTER(STAT_FinishRenderViewTargetTime); for(int32 ViewIndex = 0;ViewIndex < Views.Num();ViewIndex++) { SCOPED_CONDITIONAL_DRAW_EVENTF(EventView, Views.Num() > 1, DEC_SCENE_ITEMS, TEXT("View%d"), ViewIndex); FinishRenderViewTarget(&Views[ViewIndex], ViewIndex == (Views.Num() - 1)); } } RenderFinish(); }
/** * Renders the view family. */ void FForwardShadingSceneRenderer::Render(FRHICommandListImmediate& RHICmdList) { if(!ViewFamily.EngineShowFlags.Rendering) { return; } auto FeatureLevel = ViewFamily.GetFeatureLevel(); // Initialize global system textures (pass-through if already initialized). GSystemTextures.InitializeTextures(RHICmdList, FeatureLevel); // Allocate the maximum scene render target space for the current view family. GSceneRenderTargets.Allocate(ViewFamily); // Find the visible primitives. InitViews(RHICmdList); RenderShadowDepthMaps(RHICmdList); // Notify the FX system that the scene is about to be rendered. if (Scene->FXSystem) { Scene->FXSystem->PreRender(RHICmdList); } GRenderTargetPool.VisualizeTexture.OnStartFrame(Views[0]); // Dynamic vertex and index buffers need to be committed before rendering. FGlobalDynamicVertexBuffer::Get().Commit(); FGlobalDynamicIndexBuffer::Get().Commit(); // This might eventually be a problem with multiple views. // Using only view 0 to check to do on-chip transform of alpha. FViewInfo& View = Views[0]; const bool bGammaSpace = !IsMobileHDR(); const bool bRequiresUpscale = ((uint32)ViewFamily.RenderTarget->GetSizeXY().X > ViewFamily.FamilySizeX || (uint32)ViewFamily.RenderTarget->GetSizeXY().Y > ViewFamily.FamilySizeY); const bool bRenderToScene = bRequiresUpscale || FSceneRenderer::ShouldCompositeEditorPrimitives(View); if (bGammaSpace && !bRenderToScene) { SetRenderTarget(RHICmdList, ViewFamily.RenderTarget->GetRenderTargetTexture(), GSceneRenderTargets.GetSceneDepthTexture(), ESimpleRenderTargetMode::EClearToDefault); } else { // Begin rendering to scene color GSceneRenderTargets.BeginRenderingSceneColor(RHICmdList, ESimpleRenderTargetMode::EClearToDefault); } if (GIsEditor) { RHICmdList.Clear(true, Views[0].BackgroundColor, false, 0, false, 0, FIntRect()); } RenderForwardShadingBasePass(RHICmdList); // Make a copy of the scene depth if the current hardware doesn't support reading and writing to the same depth buffer GSceneRenderTargets.ResolveSceneDepthToAuxiliaryTexture(RHICmdList); // Notify the FX system that opaque primitives have been rendered. if (Scene->FXSystem) { Scene->FXSystem->PostRenderOpaque(RHICmdList); } // Draw translucency. if (ViewFamily.EngineShowFlags.Translucency) { SCOPE_CYCLE_COUNTER(STAT_TranslucencyDrawTime); // Note: Forward pass has no SeparateTranslucency, so refraction effect order with Transluency is different. // Having the distortion applied between two different translucency passes would make it consistent with the deferred pass. // This is not done yet. if (ViewFamily.EngineShowFlags.Refraction) { // to apply refraction effect by distorting the scene color RenderDistortion(RHICmdList); } RenderTranslucency(RHICmdList); } static const auto CVarMobileMSAA = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.MobileMSAA")); bool bOnChipSunMask = GSupportsRenderTargetFormat_PF_FloatRGBA && GSupportsShaderFramebufferFetch && ViewFamily.EngineShowFlags.PostProcessing && ((View.bLightShaftUse) || (View.FinalPostProcessSettings.DepthOfFieldScale > 0.0) || ((ViewFamily.GetShaderPlatform() == SP_METAL) && (CVarMobileMSAA ? CVarMobileMSAA->GetValueOnAnyThread() > 1 : false)) ); if (!bGammaSpace && bOnChipSunMask) { // Convert alpha from depth to circle of confusion with sunshaft intensity. // This is done before resolve on hardware with framebuffer fetch. // This will break when PrePostSourceViewportSize is not full size. FIntPoint PrePostSourceViewportSize = GSceneRenderTargets.GetBufferSizeXY(); FMemMark Mark(FMemStack::Get()); FRenderingCompositePassContext CompositeContext(RHICmdList, View); FRenderingCompositePass* PostProcessSunMask = CompositeContext.Graph.RegisterPass(new(FMemStack::Get()) FRCPassPostProcessSunMaskES2(PrePostSourceViewportSize, true)); CompositeContext.Root->AddDependency(FRenderingCompositeOutputRef(PostProcessSunMask)); CompositeContext.Process(TEXT("OnChipAlphaTransform")); } if (!bGammaSpace || bRenderToScene) { // Resolve the scene color for post processing. GSceneRenderTargets.ResolveSceneColor(RHICmdList, FResolveRect(0, 0, ViewFamily.FamilySizeX, ViewFamily.FamilySizeY)); // Drop depth and stencil before post processing to avoid export. RHICmdList.DiscardRenderTargets(true, true, 0); } if (!bGammaSpace) { // Finish rendering for each view, or the full stereo buffer if enabled if (ViewFamily.bResolveScene) { if (ViewFamily.EngineShowFlags.StereoRendering) { check(Views.Num() > 1); //@todo ES2 stereo post: until we get proper stereo postprocessing for ES2, process the stereo buffer as one view FIntPoint OriginalMax0 = Views[0].ViewRect.Max; Views[0].ViewRect.Max = Views[1].ViewRect.Max; GPostProcessing.ProcessES2(RHICmdList, Views[0], bOnChipSunMask); Views[0].ViewRect.Max = OriginalMax0; } else { SCOPED_DRAW_EVENT(RHICmdList, PostProcessing); SCOPE_CYCLE_COUNTER(STAT_FinishRenderViewTargetTime); for(int32 ViewIndex = 0;ViewIndex < Views.Num();ViewIndex++) { SCOPED_CONDITIONAL_DRAW_EVENTF(RHICmdList, EventView, Views.Num() > 1, TEXT("View%d"), ViewIndex); GPostProcessing.ProcessES2(RHICmdList, Views[ViewIndex], bOnChipSunMask); } } } } else if (bRenderToScene) { BasicPostProcess(RHICmdList, View, bRequiresUpscale, FSceneRenderer::ShouldCompositeEditorPrimitives(View)); } RenderFinish(RHICmdList); }
LRESULT CMainFrame::OnCreate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/) { // Check if Common Controls 6.0 are used. If yes, use 32-bit (alpha) images // for the toolbar and command bar. If not, use the old, 4-bit images. UINT uResID = IDR_MAINFRAME_OLD; DWORD dwMajor = 0; DWORD dwMinor = 0; HRESULT hRet = AtlGetCommCtrlVersion(&dwMajor, &dwMinor); if(SUCCEEDED(hRet) && dwMajor >= 6) uResID = IDR_MAINFRAME; // Set values to be displayed in the view window m_view.m_dwCommCtrlMajor = dwMajor; m_view.m_dwCommCtrlMinor = dwMinor; m_view.m_bAlpha = (uResID == IDR_MAINFRAME); // create command bar window HWND hWndCmdBar = m_CmdBar.Create(m_hWnd, rcDefault, NULL, ATL_SIMPLE_CMDBAR_PANE_STYLE); // attach menu m_CmdBar.AttachMenu(GetMenu()); // load command bar images m_CmdBar.LoadImages(uResID); // remove old menu SetMenu(NULL); HWND hWndToolBar = CreateSimpleToolBarCtrl(m_hWnd, uResID, FALSE, ATL_SIMPLE_TOOLBAR_PANE_STYLE); CreateSimpleReBar(ATL_SIMPLE_REBAR_NOBORDER_STYLE); AddSimpleReBarBand(hWndCmdBar); AddSimpleReBarBand(hWndToolBar, NULL, TRUE); CreateSimpleStatusBar(); // //m_hWndClient = m_view.Create(m_hWnd, rcDefault, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN, WS_EX_CLIENTEDGE); { m_hWndClient = m_wndSplitter.Create(m_hWnd, rcDefault, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN); HWND hWndFolderTree = m_wndFolderTree.Create(m_wndSplitter, _T("Folders"), WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN); RECT rc = { 50, 0, 300, 100 }; m_wndCombo.Create(hWndFolderTree, rc, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | CBS_DROPDOWN | CBS_AUTOHSCROLL); m_wndTreeView.Create(m_wndFolderTree, rcDefault, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | TVS_HASLINES | TVS_LINESATROOT | TVS_HASBUTTONS | TVS_SHOWSELALWAYS, WS_EX_CLIENTEDGE); m_wndFolderTree.SetClient(m_wndTreeView); m_wndListView.Create(m_wndSplitter, rcDefault, NULL, WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | LVS_REPORT | LVS_AUTOARRANGE | LVS_SHOWSELALWAYS | LVS_SHAREIMAGELISTS, WS_EX_CLIENTEDGE); m_wndListView.SetExtendedListViewStyle(LVS_EX_TRACKSELECT | LVS_EX_ONECLICKACTIVATE | LVS_EX_UNDERLINEHOT); InitViews(); UpdateLayout(); m_wndSplitter.SetSplitterPanes(m_wndFolderTree, m_wndListView); RECT rect; GetClientRect(&rect); m_wndSplitter.SetSplitterPos((rect.right - rect.left) / 4); } UIAddToolBar(hWndToolBar); UISetCheck(ID_VIEW_TOOLBAR, 1); UISetCheck(ID_VIEW_STATUS_BAR, 1); // register object for message filtering and idle updates CMessageLoop* pLoop = _Module.GetMessageLoop(); ATLASSERT(pLoop != NULL); pLoop->AddMessageFilter(this); pLoop->AddIdleHandler(this); UIEnable(ID_EDIT_PASTE, FALSE); // _canvas = NULL; //_canvas = new Canvas(m_hWndClient); //_canvas = new Canvas(m_hWndClient); // return 0; }