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();
}
}
