virtual FIntPoint GetAtlasSize() const override { return FIntPoint(TextureSize, TextureSize); }
FIntPoint UGameUserSettings::GetDefaultWindowPosition() { return FIntPoint(-1,-1); }
FIntPoint UGameUserSettings::GetWindowPosition() { return FIntPoint(WindowPosX, WindowPosY); }
FIntPoint UGameUserSettings::GetScreenResolution() const { return FIntPoint(ResolutionSizeX, ResolutionSizeY); }
FIntPoint UGameUserSettings::GetLastConfirmedScreenResolution() const { return FIntPoint(LastUserConfirmedResolutionSizeX, LastUserConfirmedResolutionSizeY); }
FSlateShaderResourceProxy* FSlateRHIResourceManager::GenerateTextureResource( const FNewTextureInfo& Info ) { FSlateShaderResourceProxy* NewProxy = NULL; const uint32 Width = Info.TextureData->GetWidth(); const uint32 Height = Info.TextureData->GetHeight(); if( Info.bShouldAtlas ) { // 4 bytes per pixel const uint32 AtlasStride = GPixelFormats[PF_R8G8B8A8].BlockBytes; const uint8 Padding = 1; const FAtlasedTextureSlot* NewSlot = NULL; FSlateTextureAtlasRHI* Atlas = NULL; // See if any atlases can hold the texture for( int32 AtlasIndex = 0; AtlasIndex < TextureAtlases.Num() && !NewSlot; ++AtlasIndex ) { Atlas = TextureAtlases[AtlasIndex]; NewSlot = Atlas->AddTexture( Width, Height, Info.TextureData->GetRawBytes() ); } if( !NewSlot ) { INC_DWORD_STAT_BY(STAT_SlateNumTextureAtlases, 1); Atlas = new FSlateTextureAtlasRHI( AtlasSize, AtlasSize, AtlasStride, Padding ); TextureAtlases.Add( Atlas ); NewSlot = TextureAtlases.Last()->AddTexture( Width, Height, Info.TextureData->GetRawBytes() ); } check( Atlas && NewSlot ); // Create a proxy to the atlased texture. The texure being used is the atlas itself with sub uvs to access the correct texture NewProxy = new FSlateShaderResourceProxy; NewProxy->Resource = Atlas->GetAtlasTexture(); NewProxy->StartUV = FVector2D( (float)(NewSlot->X+Padding) / Atlas->GetWidth(), (float)(NewSlot->Y+Padding) / Atlas->GetHeight() ); NewProxy->SizeUV = FVector2D( (float)(NewSlot->Width-Padding*2) / Atlas->GetWidth(), (float)(NewSlot->Height-Padding*2) / Atlas->GetHeight() ); NewProxy->ActualSize = FIntPoint( Width, Height ); } else { NewProxy = new FSlateShaderResourceProxy; // Create a new standalone texture because we cant atlas this one FSlateTexture2DRHIRef* Texture = new FSlateTexture2DRHIRef( Width, Height, PF_B8G8R8A8, Info.TextureData, Info.bSrgb ? TexCreate_SRGB : TexCreate_None ); // Add it to the list of non atlased textures that we must clean up later NonAtlasedTextures.Add( Texture ); INC_DWORD_STAT_BY( STAT_SlateNumNonAtlasedTextures, 1 ); BeginInitResource( Texture ); // The texture proxy only contains a single texture NewProxy->Resource = Texture; NewProxy->StartUV = FVector2D(0.0f,0.0f); NewProxy->SizeUV = FVector2D(1.0f, 1.0f); NewProxy->ActualSize = FIntPoint( Width, Height ); } return NewProxy; }
void FRCPassPostProcessDOFSetup::Process(FRenderingCompositePassContext& Context) { SCOPED_DRAW_EVENT(Context.RHICmdList, DOFSetup); const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0); if(!InputDesc) { // input is not hooked up correctly return; } uint32 NumRenderTargets = bNearBlurEnabled ? 2 : 1; const FSceneView& View = Context.View; const FSceneViewFamily& ViewFamily = *(View.Family); const auto FeatureLevel = Context.GetFeatureLevel(); auto ShaderMap = Context.GetShaderMap(); FIntPoint SrcSize = InputDesc->Extent; FIntPoint DestSize = PassOutputs[0].RenderTargetDesc.Extent; // e.g. 4 means the input texture is 4x smaller than the buffer size uint32 ScaleFactor = FSceneRenderTargets::Get(Context.RHICmdList).GetBufferSizeXY().X / SrcSize.X; FIntRect SrcRect = View.ViewRect / ScaleFactor; FIntRect DestRect = SrcRect / 2; const FSceneRenderTargetItem& DestRenderTarget0 = PassOutputs[0].RequestSurface(Context); const FSceneRenderTargetItem& DestRenderTarget1 = bNearBlurEnabled ? PassOutputs[1].RequestSurface(Context) : FSceneRenderTargetItem(); // Set the view family's render target/viewport. FTextureRHIParamRef RenderTargets[2] = { DestRenderTarget0.TargetableTexture, DestRenderTarget1.TargetableTexture }; SetRenderTargets(Context.RHICmdList, NumRenderTargets, RenderTargets, FTextureRHIParamRef(), 0, NULL); FLinearColor ClearColors[2] = { FLinearColor(0, 0, 0, 0), FLinearColor(0, 0, 0, 0) }; // is optimized away if possible (RT size=view size, ) Context.RHICmdList.ClearMRT(true, NumRenderTargets, ClearColors, false, 1.0f, false, 0, DestRect); Context.SetViewportAndCallRHI(DestRect.Min.X, DestRect.Min.Y, 0.0f, DestRect.Max.X + 1, DestRect.Max.Y + 1, 1.0f ); // set the state Context.RHICmdList.SetBlendState(TStaticBlendState<>::GetRHI()); Context.RHICmdList.SetRasterizerState(TStaticRasterizerState<>::GetRHI()); Context.RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false, CF_Always>::GetRHI()); TShaderMapRef<FPostProcessVS> VertexShader(ShaderMap); if (bNearBlurEnabled) { const float DOFVignetteSize = FMath::Max(0.0f, View.FinalPostProcessSettings.DepthOfFieldVignetteSize); // todo: test is conservative, with bad content we would waste a bit of performance const bool bDOFVignette = DOFVignetteSize < 200.0f; if(bDOFVignette) { static FGlobalBoundShaderState BoundShaderState; TShaderMapRef< FPostProcessDOFSetupPS<2> > PixelShader(ShaderMap); SetGlobalBoundShaderState(Context.RHICmdList, FeatureLevel, BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader); PixelShader->SetParameters(Context); } else { static FGlobalBoundShaderState BoundShaderState; TShaderMapRef< FPostProcessDOFSetupPS<1> > PixelShader(ShaderMap); SetGlobalBoundShaderState(Context.RHICmdList, FeatureLevel, BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader); PixelShader->SetParameters(Context); } } else { static FGlobalBoundShaderState BoundShaderState; TShaderMapRef< FPostProcessDOFSetupPS<0> > PixelShader(ShaderMap); SetGlobalBoundShaderState(Context.RHICmdList, FeatureLevel, BoundShaderState, GFilterVertexDeclaration.VertexDeclarationRHI, *VertexShader, *PixelShader); PixelShader->SetParameters(Context); } VertexShader->SetParameters(Context); DrawPostProcessPass( Context.RHICmdList, 0, 0, DestRect.Width() + 1, DestRect.Height() + 1, SrcRect.Min.X, SrcRect.Min.Y, SrcRect.Width() + 1, SrcRect.Height() + 1, DestRect.Size() + FIntPoint(1, 1), SrcSize, *VertexShader, View.StereoPass, Context.HasHmdMesh(), EDRF_UseTriangleOptimization); Context.RHICmdList.CopyToResolveTarget(DestRenderTarget0.TargetableTexture, DestRenderTarget0.ShaderResourceTexture, false, FResolveParams()); Context.RHICmdList.CopyToResolveTarget(DestRenderTarget1.TargetableTexture, DestRenderTarget1.ShaderResourceTexture, false, FResolveParams()); }
void FSingleTileEditorViewportClient::SetTileIndex(int32 InTileIndex) { const int32 OldTileIndex = TileBeingEditedIndex; const bool bNewIndexValid = (InTileIndex >= 0) && (InTileIndex < TileSet->GetTileCount()); TileBeingEditedIndex = bNewIndexValid ? InTileIndex : INDEX_NONE; FSpriteGeometryEditMode* GeometryEditMode = ModeTools->GetActiveModeTyped<FSpriteGeometryEditMode>(FSpriteGeometryEditMode::EM_SpriteGeometry); check(GeometryEditMode); FSpriteGeometryCollection* GeomToEdit = nullptr; if (TileBeingEditedIndex != INDEX_NONE) { if (FPaperTileMetadata* Metadata = TileSet->GetMutableTileMetadata(InTileIndex)) { GeomToEdit = &(Metadata->CollisionData); } } // Tell the geometry editor about the new tile (if it exists) GeometryEditMode->SetGeometryBeingEdited(GeomToEdit, /*bAllowCircles=*/ true, /*bAllowSubtractivePolygons=*/ false); // Update the visual representation UPaperSprite* DummySprite = nullptr; if (TileBeingEditedIndex != INDEX_NONE) { DummySprite = NewObject<UPaperSprite>(); DummySprite->SpriteCollisionDomain = ESpriteCollisionMode::None; DummySprite->PivotMode = ESpritePivotMode::Center_Center; DummySprite->CollisionGeometry.GeometryType = ESpritePolygonMode::SourceBoundingBox; DummySprite->RenderGeometry.GeometryType = ESpritePolygonMode::SourceBoundingBox; FSpriteAssetInitParameters SpriteReinitParams; SpriteReinitParams.Texture = TileSet->GetTileSheetTexture(); //@TODO: Should analyze the texture (*at a higher level, not per tile click!*) to pick the correct material FVector2D UV; TileSet->GetTileUV(TileBeingEditedIndex, /*out*/ UV); SpriteReinitParams.Offset = FIntPoint((int32)UV.X, (int32)(UV.Y)); SpriteReinitParams.Dimension = TileSet->GetTileSize(); SpriteReinitParams.SetPixelsPerUnrealUnit(1.0f); DummySprite->InitializeSprite(SpriteReinitParams); } PreviewTileSpriteComponent->SetSprite(DummySprite); // Update the default geometry bounds const FVector2D HalfTileSize(TileSet->GetTileSize().X * 0.5f, TileSet->GetTileSize().Y * 0.5f); FBox2D DesiredBounds(ForceInitToZero); DesiredBounds.Min = -HalfTileSize; DesiredBounds.Max = HalfTileSize; GeometryEditMode->SetNewGeometryPreferredBounds(DesiredBounds); // Zoom to fit when we start editing a tile and weren't before, but leave it alone if we just changed tiles, in case they zoomed in or out further if ((TileBeingEditedIndex != INDEX_NONE) && (OldTileIndex == INDEX_NONE)) { RequestFocusOnSelection(/*bInstant=*/ true); } // Trigger a details panel customization rebuild OnSingleTileIndexChanged.Broadcast(TileBeingEditedIndex, OldTileIndex); // Redraw the viewport Invalidate(); }
FSlateShaderResourceProxy* FSlateD3DTextureManager::GenerateTextureResource( const FNewTextureInfo& Info ) { FSlateShaderResourceProxy* NewProxy = NULL; const uint32 Width = Info.TextureData->GetWidth(); const uint32 Height = Info.TextureData->GetHeight(); if( Info.bShouldAtlas ) { const uint32 AtlasSize = 1024; // 4 bytes per pixel const uint32 AtlasStride = sizeof(uint8)*4; const uint8 Padding = 1; const FAtlasedTextureSlot* NewSlot = NULL; FSlateTextureAtlasD3D* Atlas = NULL; // Get the last atlas and find a slot for the texture for( int32 AtlasIndex = 0; AtlasIndex < TextureAtlases.Num(); ++AtlasIndex ) { Atlas = TextureAtlases[AtlasIndex]; NewSlot = Atlas->AddTexture( Width, Height, Info.TextureData->GetRawBytes() ); if( NewSlot ) { break; } } // No new slot was found in any atlas so we have to make another one if( !NewSlot ) { // A new slot in the atlas could not be found, make a new atlas and add the texture to it Atlas = new FSlateTextureAtlasD3D( AtlasSize, AtlasSize, AtlasStride, Padding ); TextureAtlases.Add( Atlas ); NewSlot = TextureAtlases.Last()->AddTexture( Width, Height, Info.TextureData->GetRawBytes() ); } check( Atlas && NewSlot ); // Create a proxy representing this texture in the atlas NewProxy = new FSlateShaderResourceProxy; NewProxy->Resource = Atlas->GetAtlasTexture(); // Compute the sub-uvs for the location of this texture in the atlas, accounting for padding NewProxy->StartUV = FVector2D( (float)(NewSlot->X+Padding) / Atlas->GetWidth(), (float)(NewSlot->Y+Padding) / Atlas->GetHeight() ); NewProxy->SizeUV = FVector2D( (float)(NewSlot->Width-Padding*2) / Atlas->GetWidth(), (float)(NewSlot->Height-Padding*2) / Atlas->GetHeight() ); NewProxy->ActualSize = FIntPoint( Width, Height ); } else { // The texture is not atlased create a new texture proxy and just point it to the actual texture NewProxy = new FSlateShaderResourceProxy; // Keep track of non-atlased textures so we can free their resources later FSlateD3DTexture* Texture = new FSlateD3DTexture( Width, Height ); NonAtlasedTextures.Add( Texture ); NewProxy->Resource = Texture; NewProxy->StartUV = FVector2D(0.0f,0.0f); NewProxy->SizeUV = FVector2D(1.0f, 1.0f); NewProxy->ActualSize = FIntPoint( Width, Height ); D3D11_SUBRESOURCE_DATA InitData; InitData.pSysMem = Info.TextureData->GetRawBytes().GetTypedData(); InitData.SysMemPitch = Width * 4; Texture->Init( Info.bSrgb ? DXGI_FORMAT_R8G8B8A8_UNORM_SRGB : DXGI_FORMAT_R8G8B8A8_UNORM, &InitData ); } return NewProxy; }
void RenderLandscapeMaterialForLightmass(const FLandscapeStaticLightingMesh* LandscapeMesh, FMaterialRenderProxy* MaterialProxy, const FRenderTarget* RenderTarget) { const ULandscapeComponent* LandscapeComponent = CastChecked<ULandscapeComponent>(LandscapeMesh->Component); const int32 SubsectionSizeQuads = LandscapeComponent->SubsectionSizeQuads; const int32 NumSubsections = LandscapeComponent->NumSubsections; const int32 ComponentSizeQuads = LandscapeComponent->ComponentSizeQuads; int32 PatchExpandCountX = 0; int32 PatchExpandCountY = 0; int32 DesiredSize = 1; const float LightMapOffset = 0.0f; const float LightMapRes = LandscapeComponent->StaticLightingResolution > 0.f ? LandscapeComponent->StaticLightingResolution : LandscapeComponent->GetLandscapeProxy()->StaticLightingResolution; const int32 LightingLOD = LandscapeComponent->GetLandscapeProxy()->StaticLightingLOD; const float LightMapRatio = ::GetTerrainExpandPatchCount(LightMapRes, PatchExpandCountX, PatchExpandCountY, ComponentSizeQuads, (NumSubsections * (SubsectionSizeQuads + 1)), DesiredSize, LightingLOD); const FVector2D PatchExpandOffset = FVector2D((float)PatchExpandCountX / (ComponentSizeQuads + 2 * PatchExpandCountX), (float)PatchExpandCountY / (ComponentSizeQuads + 2 * PatchExpandCountY)) * FVector2D(RenderTarget->GetSizeXY()); const FVector2D PatchExpandScale = FVector2D((float)ComponentSizeQuads / (ComponentSizeQuads + 2 * PatchExpandCountX), (float)ComponentSizeQuads / (ComponentSizeQuads + 2 * PatchExpandCountY)); TArray<FLightmassLandscapeVertex> Vertices; TArray<uint16> Indices; Vertices.Reserve(FMath::Square(NumSubsections) * 4); Indices.Reserve(FMath::Square(NumSubsections) * 6); const float fraction = 1.0f / NumSubsections; const FVector2D PositionScale = FVector2D(RenderTarget->GetSizeXY()) * fraction * PatchExpandScale; const float LayerScale = SubsectionSizeQuads; const float WeightmapSubsection = LandscapeComponent->WeightmapSubsectionOffset; const FVector2D WeightmapBias = FVector2D(LandscapeComponent->WeightmapScaleBias.Z, LandscapeComponent->WeightmapScaleBias.W); const FVector2D WeightmapScale = FVector2D(LandscapeComponent->WeightmapScaleBias.X, LandscapeComponent->WeightmapScaleBias.Y) * SubsectionSizeQuads; const int32 SubsectionX_Start = PatchExpandCountX > 0 ? -1 : 0; const int32 SubsectionX_End = NumSubsections + (PatchExpandCountX > 0 ? 1 : 0); const int32 SubsectionY_Start = PatchExpandCountY > 0 ? -1 : 0; const int32 SubsectionY_End = NumSubsections + (PatchExpandCountY > 0 ? 1 : 0); for (int32 SubsectionY = SubsectionY_Start; SubsectionY < SubsectionY_End; ++SubsectionY) { for (int32 SubsectionX = SubsectionX_Start; SubsectionX < SubsectionX_End; ++SubsectionX) { const FIntPoint UVSubsection = FIntPoint((SubsectionX >= 0 ? SubsectionX : 0), (SubsectionY >= 0 ? SubsectionY : 0)); const FVector2D UVScale = FVector2D((SubsectionX >= 0 && SubsectionX < NumSubsections ? 1 : 0), (SubsectionY >= 0 && SubsectionY < NumSubsections ? 1 : 0)); const FVector2D BasePosition = PatchExpandOffset + FVector2D(SubsectionX, SubsectionY) * PositionScale; const FVector2D BaseLayerCoords = FVector2D(UVSubsection) * LayerScale; const FVector2D BaseWeightmapCoords = WeightmapBias + FVector2D(UVSubsection) * WeightmapSubsection; int32 Index = Vertices.Add(FLightmassLandscapeVertex(FVector(BasePosition /*FVector2D(0, 0) * PositionScale*/, 0), FVector(BaseLayerCoords /*FVector2D(0, 0) * UVScale * LayerScale*/, 0), BaseWeightmapCoords /*FVector2D(0, 0) * UVScale * WeightmapScale*/)); verifySlow( Vertices.Add(FLightmassLandscapeVertex(FVector(BasePosition + FVector2D(1, 0) * PositionScale, 0), FVector(BaseLayerCoords + FVector2D(1, 0) * UVScale * LayerScale, 0), BaseWeightmapCoords + FVector2D(1, 0) * UVScale * WeightmapScale )) == Index + 1); verifySlow( Vertices.Add(FLightmassLandscapeVertex(FVector(BasePosition + FVector2D(0, 1) * PositionScale, 0), FVector(BaseLayerCoords + FVector2D(0, 1) * UVScale * LayerScale, 0), BaseWeightmapCoords + FVector2D(0, 1) * UVScale * WeightmapScale )) == Index + 2); verifySlow( Vertices.Add(FLightmassLandscapeVertex(FVector(BasePosition + FVector2D(1, 1) * PositionScale, 0), FVector(BaseLayerCoords + FVector2D(1, 1) * UVScale * LayerScale, 0), BaseWeightmapCoords + FVector2D(1, 1) * UVScale * WeightmapScale )) == Index + 3); checkSlow(Index + 3 <= MAX_uint16); Indices.Add(Index); Indices.Add(Index + 3); Indices.Add(Index + 1); Indices.Add(Index); Indices.Add(Index + 2); Indices.Add(Index + 3); } } FMeshBatch MeshElement; MeshElement.DynamicVertexStride = sizeof(FLightmassLandscapeVertex); MeshElement.UseDynamicData = true; MeshElement.bDisableBackfaceCulling = true; MeshElement.CastShadow = false; MeshElement.bWireframe = false; MeshElement.Type = PT_TriangleList; MeshElement.DepthPriorityGroup = SDPG_Foreground; MeshElement.bUseAsOccluder = false; MeshElement.bSelectable = false; MeshElement.DynamicVertexData = Vertices.GetData(); MeshElement.VertexFactory = &LightmassLandscapeVertexFactory; MeshElement.MaterialRenderProxy = MaterialProxy; FMeshBatchElement& BatchElement = MeshElement.Elements[0]; BatchElement.PrimitiveUniformBufferResource = &LightmassLandscapeUniformBuffer; BatchElement.DynamicIndexData = Indices.GetData(); BatchElement.FirstIndex = 0; BatchElement.NumPrimitives = Indices.Num() / 3; BatchElement.MinVertexIndex = 0; BatchElement.MaxVertexIndex = Vertices.Num() - 1; BatchElement.DynamicIndexStride = sizeof(uint16); FSceneViewFamily ViewFamily(FSceneViewFamily::ConstructionValues( RenderTarget, NULL, FEngineShowFlags(ESFIM_Game)) .SetWorldTimes(0, 0, 0) .SetGammaCorrection(RenderTarget->GetDisplayGamma())); const FIntRect ViewRect(FIntPoint(0, 0), RenderTarget->GetSizeXY()); // make a temporary view FSceneViewInitOptions ViewInitOptions; ViewInitOptions.ViewFamily = &ViewFamily; ViewInitOptions.SetViewRectangle(ViewRect); ViewInitOptions.ViewOrigin = FVector::ZeroVector; ViewInitOptions.ViewRotationMatrix = FMatrix::Identity; ViewInitOptions.ProjectionMatrix = FCanvas::CalcBaseTransform2D(RenderTarget->GetSizeXY().X, RenderTarget->GetSizeXY().Y); ViewInitOptions.BackgroundColor = FLinearColor::Black; ViewInitOptions.OverlayColor = FLinearColor::White; FSceneView View(ViewInitOptions); ENQUEUE_UNIQUE_RENDER_COMMAND_ONEPARAMETER( CanvasFlushSetupCommand, const FRenderTarget*, RenderTarget, RenderTarget, { //SCOPED_DRAW_EVENT(RHICmdList, CanvasFlush); // Set the RHI render target. ::SetRenderTarget(RHICmdList, RenderTarget->GetRenderTargetTexture(), FTextureRHIRef()); // disable depth test & writes RHICmdList.SetDepthStencilState(TStaticDepthStencilState<false,CF_Always>::GetRHI()); const FIntRect RTViewRect = FIntRect(0, 0, RenderTarget->GetRenderTargetTexture()->GetSizeX(), RenderTarget->GetRenderTargetTexture()->GetSizeY()); // set viewport to RT size RHICmdList.SetViewport(RTViewRect.Min.X, RTViewRect.Min.Y, 0.0f, RTViewRect.Max.X, RTViewRect.Max.Y, 1.0f); });
/** Add stream to topology */ FIntPoint FImfVideoPlayer::AddStreamToTopology( IMFTopology* Topology, IMFPresentationDescriptor* PresentationDesc, IMFStreamDescriptor* StreamDesc, FImfSampleGrabberCallback* SampleGrabberCallback ) { FIntPoint OutDimensions = FIntPoint( ForceInit ); HRESULT HResult = S_OK; IMFActivate* SinkActivate = NULL; { IMFMediaTypeHandler* Handler = NULL; HResult = StreamDesc->GetMediaTypeHandler( &Handler ); check( SUCCEEDED( HResult ) ); GUID MajorType; HResult = Handler->GetMajorType( &MajorType ); check( SUCCEEDED( HResult ) ); /* Audio stream */ if( MajorType == MFMediaType_Audio ) { /* No audio required */ Handler->Release( ); return FIntPoint( ForceInit ); } /* Video stream */ else if( MajorType == MFMediaType_Video ) { IMFMediaType* OutputType = NULL; HResult = Handler->GetCurrentMediaType( &OutputType ); check( SUCCEEDED( HResult ) ); IMFMediaType* InputType = NULL; HResult = MFCreateMediaType( &InputType ); UINT32 Width = 0, Height = 0; HResult = MFGetAttributeSize( OutputType, MF_MT_FRAME_SIZE, &Width, &Height ); check( SUCCEEDED( HResult ) ); HResult = InputType->SetGUID( MF_MT_MAJOR_TYPE, MFMediaType_Video ); check( SUCCEEDED( HResult ) ); HResult = InputType->SetGUID( MF_MT_SUBTYPE, MFVideoFormat_RGB32 ); check( SUCCEEDED( HResult ) ); HResult = InputType->SetUINT32( MF_MT_ALL_SAMPLES_INDEPENDENT, TRUE ); check( SUCCEEDED( HResult ) ); HResult = MFCreateSampleGrabberSinkActivate( InputType, SampleGrabberCallback, &SinkActivate ); check( SUCCEEDED( HResult ) ); InputType->Release( ); OutputType->Release( ); OutDimensions = FIntPoint( Width, Height ); } Handler->Release( ); } IMFTopologyNode* SourceNode = NULL; { HResult = MFCreateTopologyNode( MF_TOPOLOGY_SOURCESTREAM_NODE, &SourceNode ); check( SUCCEEDED( HResult ) ); HResult = SourceNode->SetUnknown( MF_TOPONODE_SOURCE, MediaSource ); check( SUCCEEDED( HResult ) ); HResult = SourceNode->SetUnknown( MF_TOPONODE_PRESENTATION_DESCRIPTOR, PresentationDesc ); check( SUCCEEDED( HResult ) ); HResult = SourceNode->SetUnknown( MF_TOPONODE_STREAM_DESCRIPTOR, StreamDesc ); check( SUCCEEDED( HResult ) ); HResult = Topology->AddNode( SourceNode ); check( SUCCEEDED( HResult ) ); } IMFTopologyNode* OutputNode = NULL; { HResult = MFCreateTopologyNode( MF_TOPOLOGY_OUTPUT_NODE, &OutputNode ); check( SUCCEEDED( HResult ) ); HResult = OutputNode->SetObject( SinkActivate ); check( SUCCEEDED( HResult ) ); HResult = OutputNode->SetUINT32( MF_TOPONODE_STREAMID, 0 ); check( SUCCEEDED( HResult ) ); HResult = OutputNode->SetUINT32( MF_TOPONODE_NOSHUTDOWN_ON_REMOVE, 0 ); check( SUCCEEDED( HResult ) ); HResult = Topology->AddNode( OutputNode ); check( SUCCEEDED( HResult ) ); } HResult = SourceNode->ConnectOutput( 0, OutputNode, 0 ); check( SUCCEEDED( HResult ) ); SourceNode->Release( ); OutputNode->Release( ); SinkActivate->Release( ); return OutDimensions; }
void FRCPassPostProcessHistogram::Process(FRenderingCompositePassContext& Context) { SCOPED_DRAW_EVENT(Context.RHICmdList, PostProcessHistogram); const FPooledRenderTargetDesc* InputDesc = GetInputDesc(ePId_Input0); if(!InputDesc) { // input is not hooked up correctly return; } const FSceneView& View = Context.View; const FSceneViewFamily& ViewFamily = *(View.Family); FIntPoint SrcSize = InputDesc->Extent; FIntRect DestRect = View.ViewRect; const FSceneRenderTargetItem& DestRenderTarget = PassOutputs[0].RequestSurface(Context); TShaderMapRef<FPostProcessHistogramCS> ComputeShader(Context.GetShaderMap()); SetRenderTarget(Context.RHICmdList, FTextureRHIRef(), FTextureRHIRef()); Context.RHICmdList.SetComputeShader(ComputeShader->GetComputeShader()); // set destination check(DestRenderTarget.UAV); Context.RHICmdList.TransitionResource(EResourceTransitionAccess::ERWBarrier, EResourceTransitionPipeline::EGfxToCompute, DestRenderTarget.UAV); Context.RHICmdList.SetUAVParameter(ComputeShader->GetComputeShader(), ComputeShader->HistogramRWTexture.GetBaseIndex(), DestRenderTarget.UAV); FIntPoint GatherExtent = ComputeGatherExtent(View); FIntPoint ThreadGroupCountValue = ComputeThreadGroupCount(GatherExtent); ComputeShader->SetCS(Context.RHICmdList, Context, ThreadGroupCountValue, (DestRect.Min + FIntPoint(1, 1)) / 2, GatherExtent); DispatchComputeShader(Context.RHICmdList, *ComputeShader, ThreadGroupCountValue.X, ThreadGroupCountValue.Y, 1); // un-set destination Context.RHICmdList.SetUAVParameter(ComputeShader->GetComputeShader(), ComputeShader->HistogramRWTexture.GetBaseIndex(), NULL); Context.RHICmdList.TransitionResource(EResourceTransitionAccess::EReadable, EResourceTransitionPipeline::EComputeToGfx, DestRenderTarget.UAV); ensureMsgf(DestRenderTarget.TargetableTexture == DestRenderTarget.ShaderResourceTexture, TEXT("%s should be resolved to a separate SRV"), *DestRenderTarget.TargetableTexture->GetName().ToString()); }
FIntPoint FRCPassPostProcessHistogram::ComputeGatherExtent(const FSceneView& View) { // we currently assume the input is half res, one full res pixel less to avoid getting bilinear filtered input return (View.ViewRect.Size() - FIntPoint(1, 1)) / 2; }
FReply FTextEditHelper::OnKeyDown( const FKeyEvent& InKeyEvent, const TSharedRef< ITextEditorWidget >& TextEditor ) { const FKey Key = InKeyEvent.GetKey(); if( Key == EKeys::Left ) { return TextEditor->MoveCursor( FMoveCursor::Cardinal( // Ctrl moves a whole word instead of one character. InKeyEvent.IsControlDown( ) ? ECursorMoveGranularity::Word : ECursorMoveGranularity::Character, // Move left FIntPoint( -1, 0 ), // Shift selects text. InKeyEvent.IsShiftDown() ? ECursorAction::SelectText : ECursorAction::MoveCursor )); } else if( Key == EKeys::Right ) { return TextEditor->MoveCursor( FMoveCursor::Cardinal( // Ctrl moves a whole word instead of one character. InKeyEvent.IsControlDown( ) ? ECursorMoveGranularity::Word : ECursorMoveGranularity::Character, // Move right FIntPoint( +1, 0 ), // Shift selects text. InKeyEvent.IsShiftDown() ? ECursorAction::SelectText : ECursorAction::MoveCursor )); } else if ( Key == EKeys::Up ) { return TextEditor->MoveCursor( FMoveCursor::Cardinal( InKeyEvent.IsControlDown( ) ? ECursorMoveGranularity::Word : ECursorMoveGranularity::Character, // Move up FIntPoint( 0, -1 ), // Shift selects text. InKeyEvent.IsShiftDown() ? ECursorAction::SelectText : ECursorAction::MoveCursor )); } else if ( Key == EKeys::Down ) { return TextEditor->MoveCursor( FMoveCursor::Cardinal( InKeyEvent.IsControlDown( ) ? ECursorMoveGranularity::Word : ECursorMoveGranularity::Character, // Move down FIntPoint( 0, +1 ), // Shift selects text. InKeyEvent.IsShiftDown() ? ECursorAction::SelectText : ECursorAction::MoveCursor )); } else if( Key == EKeys::Home ) { // Go to the beginning of the document; select text if Shift is down. TextEditor->JumpTo( (InKeyEvent.IsControlDown() ) ? ETextLocation::BeginningOfDocument : ETextLocation::BeginningOfLine, (InKeyEvent.IsShiftDown()) ? ECursorAction::SelectText : ECursorAction::MoveCursor ); return FReply::Handled(); } else if ( Key == EKeys::End ) { // Go to the end of the document; select text if Shift is down. TextEditor->JumpTo( (InKeyEvent.IsControlDown() ) ? ETextLocation::EndOfDocument : ETextLocation::EndOfLine, (InKeyEvent.IsShiftDown()) ? ECursorAction::SelectText : ECursorAction::MoveCursor ); return FReply::Handled(); } else if( Key == EKeys::Enter && !TextEditor->GetIsReadOnly() ) { FScopedTextTransaction TextTransaction(TextEditor); TextEditor->OnEnter(); return FReply::Handled(); } else if( Key == EKeys::Delete && !TextEditor->GetIsReadOnly() ) { // @Todo: Slate keybindings support more than one set of keys. // Delete to next word boundary (Ctrl+Delete) if (InKeyEvent.IsControlDown() && !InKeyEvent.IsAltDown() && !InKeyEvent.IsShiftDown()) { TextEditor->MoveCursor( FMoveCursor::Cardinal( ECursorMoveGranularity::Word, // Move right FIntPoint(+1, 0), // selects text. ECursorAction::SelectText )); } FScopedTextTransaction TextTransaction(TextEditor); // Delete selected text TextEditor->DeleteChar(); return FReply::Handled(); } else if( Key == EKeys::Escape ) { return TextEditor->OnEscape(); } // @Todo: Slate keybindings support more than one set of keys. //Alternate key for cut (Shift+Delete) else if( Key == EKeys::Delete && InKeyEvent.IsShiftDown() && TextEditor->CanExecuteCut() ) { // Cut text to clipboard TextEditor->CutSelectedTextToClipboard(); return FReply::Handled(); } // @Todo: Slate keybindings support more than one set of keys. // Alternate key for copy (Ctrl+Insert) else if( Key == EKeys::Insert && InKeyEvent.IsControlDown() && TextEditor->CanExecuteCopy() ) { // Copy text to clipboard TextEditor->CopySelectedTextToClipboard(); return FReply::Handled(); } // @Todo: Slate keybindings support more than one set of keys. // Alternate key for paste (Shift+Insert) else if( Key == EKeys::Insert && InKeyEvent.IsShiftDown() && TextEditor->CanExecutePaste() ) { // Paste text from clipboard TextEditor->PasteTextFromClipboard(); return FReply::Handled(); } // @Todo: Slate keybindings support more than one set of keys. //Alternate key for undo (Alt+Backspace) else if( Key == EKeys::BackSpace && InKeyEvent.IsAltDown() && !InKeyEvent.IsShiftDown() && TextEditor->CanExecuteUndo() ) { // Undo TextEditor->Undo(); return FReply::Handled(); } // @Todo: Slate keybindings support more than one set of keys. // Delete to previous word boundary (Ctrl+Backspace) else if( Key == EKeys::BackSpace && InKeyEvent.IsControlDown() && !InKeyEvent.IsAltDown() && !InKeyEvent.IsShiftDown() && !TextEditor->GetIsReadOnly() ) { FScopedTextTransaction TextTransaction(TextEditor); TextEditor->MoveCursor( FMoveCursor::Cardinal( ECursorMoveGranularity::Word, // Move left FIntPoint(-1, 0), ECursorAction::SelectText )); TextEditor->BackspaceChar(); return FReply::Handled(); } // Ctrl+Y (or Ctrl+Shift+Z, or Alt+Shift+Backspace) to redo else if( !TextEditor->GetIsReadOnly() && ( ( Key == EKeys::Y && InKeyEvent.IsControlDown() ) || ( Key == EKeys::Z && InKeyEvent.IsControlDown() && InKeyEvent.IsShiftDown() ) || ( Key == EKeys::BackSpace && InKeyEvent.IsAltDown() && InKeyEvent.IsShiftDown() ) ) ) { // Redo TextEditor->Redo(); return FReply::Handled(); } else if( !InKeyEvent.IsAltDown() && !InKeyEvent.IsControlDown() && InKeyEvent.GetKey() != EKeys::Tab && InKeyEvent.GetCharacter() != 0 ) { // Shift and a character was pressed or a single character was pressed. We will type something in an upcoming OnKeyChar event. // Absorb this event so it is not bubbled and handled by other widgets that could have something bound to the key press. //Note: Tab can generate a character code but not result in a typed character in this box so we ignore it. return FReply::Handled(); } else { return FReply::Unhandled(); } }