/**
* Retrieves the dynamic data for the emitter
*
* @param bSelected Whether the emitter is selected in the editor
*
* @return FDynamicEmitterDataBase* The dynamic data, or NULL if it shouldn't be rendered
*/
FDynamicEmitterDataBase* FParticleBeam2EmitterInstance::GetDynamicData(bool bSelected)
{
QUICK_SCOPE_CYCLE_COUNTER(STAT_ParticleBeam2EmitterInstance_GetDynamicData);
UParticleLODLevel* LODLevel = SpriteTemplate->GetCurrentLODLevel(this);
if (IsDynamicDataRequired(LODLevel) == false)
{
return NULL;
}
//@todo.SAS. Have this call the UpdateDynamicData function to reduce duplicate code!!!
//@SAS. This removes the need for the assertion in the actual render call...
if ((ActiveParticles > FDynamicBeam2EmitterData::MaxBeams) || // TTP #33330 - Max of 2048 beams from a single emitter
(ParticleStride >
((FDynamicBeam2EmitterData::MaxInterpolationPoints + 2) * (sizeof(FVector) + sizeof(float))) +
(FDynamicBeam2EmitterData::MaxNoiseFrequency * (sizeof(FVector) + sizeof(FVector) + sizeof(float) + sizeof(float)))
) // TTP #33330 - Max of 10k per beam (includes interpolation points, noise, etc.)
)
{
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
if (Component && Component->GetWorld())
{
FString ErrorMessage =
FString::Printf(TEXT("BeamEmitter with too much data: %s"),
Component ?
Component->Template ?
*(Component->Template->GetName()) :
TEXT("No template") :
TEXT("No component"));
FColor ErrorColor(255,0,0);
GEngine->AddOnScreenDebugMessage((uint64)((PTRINT)this), 5.0f, ErrorColor,ErrorMessage);
UE_LOG(LogParticles, Log, TEXT("%s"), *ErrorMessage);
}
#endif //#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
return NULL;
}
// Allocate the dynamic data
FDynamicBeam2EmitterData* NewEmitterData = ::new FDynamicBeam2EmitterData(LODLevel->RequiredModule);
{
SCOPE_CYCLE_COUNTER(STAT_ParticleMemTime);
INC_DWORD_STAT(STAT_DynamicEmitterCount);
INC_DWORD_STAT(STAT_DynamicBeamCount);
INC_DWORD_STAT_BY(STAT_DynamicEmitterMem, sizeof(FDynamicBeam2EmitterData));
}
// Now fill in the source data
if( !FillReplayData( NewEmitterData->Source ) )
{
delete NewEmitterData;
return NULL;
}
// Setup dynamic render data. Only call this AFTER filling in source data for the emitter.
NewEmitterData->Init( bSelected );
return NewEmitterData;
}
/** Async worker that checks the cache backend and if that fails, calls the deriver to build the data and then puts the results to the cache **/
void DoWork()
{
bool bGetResult;
{
INC_DWORD_STAT(STAT_DDC_NumGets);
STAT(double ThisTime = 0);
{
SCOPE_SECONDS_COUNTER(ThisTime);
bGetResult = FDerivedDataBackend::Get().GetRoot().GetCachedData(*CacheKey, Data);
}
INC_FLOAT_STAT_BY(STAT_DDC_SyncGetTime, bSynchronousForStats ? (float)ThisTime : 0.0f);
}
if (bGetResult)
{
check(Data.Num());
bSuccess = true;
delete DataDeriver;
DataDeriver = NULL;
}
else if (DataDeriver)
{
{
INC_DWORD_STAT(STAT_DDC_NumBuilds);
STAT(double ThisTime = 0);
{
SCOPE_SECONDS_COUNTER(ThisTime);
bSuccess = DataDeriver->Build(Data);
}
INC_FLOAT_STAT_BY(STAT_DDC_SyncBuildTime, bSynchronousForStats ? (float)ThisTime : 0.0f);
}
delete DataDeriver;
DataDeriver = NULL;
if (bSuccess)
{
check(Data.Num());
INC_DWORD_STAT(STAT_DDC_NumPuts);
STAT(double ThisTime = 0);
{
SCOPE_SECONDS_COUNTER(ThisTime);
FDerivedDataBackend::Get().GetRoot().PutCachedData(*CacheKey, Data, true);
}
INC_FLOAT_STAT_BY(STAT_DDC_PutTime, bSynchronousForStats ? (float)ThisTime : 0.0f);
}
}
if (!bSuccess)
{
Data.Empty();
}
FDerivedDataBackend::Get().AddToAsyncCompletionCounter(-1);
}
FD3D11UniformBuffer::~FD3D11UniformBuffer()
{
// Do not return the allocation to the pool if it is in the dynamic constant buffer!
if (!RingAllocation.IsValid() && Resource != nullptr)
{
check(IsInRenderingThread());
D3D11_BUFFER_DESC Desc;
Resource->GetDesc(&Desc);
// Return this uniform buffer to the free pool
if (Desc.CPUAccessFlags == D3D11_CPU_ACCESS_WRITE && Desc.Usage == D3D11_USAGE_DYNAMIC)
{
check(IsValidRef(Resource));
FPooledUniformBuffer NewEntry;
NewEntry.Buffer = Resource;
NewEntry.FrameFreed = GFrameNumberRenderThread;
NewEntry.CreatedSize = Desc.ByteWidth;
// Add to this frame's array of free uniform buffers
const int32 SafeFrameIndex = (GFrameNumberRenderThread - 1) % NumSafeFrames;
const uint32 BucketIndex = GetPoolBucketIndex(Desc.ByteWidth);
int32 LastNum = SafeUniformBufferPools[SafeFrameIndex][BucketIndex].Num();
check(Desc.ByteWidth <= GetPoolBucketSize(Desc.ByteWidth));
SafeUniformBufferPools[SafeFrameIndex][BucketIndex].Add(NewEntry);
INC_DWORD_STAT(STAT_D3D11NumFreeUniformBuffers);
INC_MEMORY_STAT_BY(STAT_D3D11FreeUniformBufferMemory, Desc.ByteWidth);
FPlatformMisc::MemoryBarrier(); // check for unwanted concurrency
check(SafeUniformBufferPools[SafeFrameIndex][BucketIndex].Num() == LastNum + 1);
}
}
}
int32 FAsyncIOSystemBase::CancelRequests( uint64* RequestIndices, int32 NumIndices )
{
FScopeLock ScopeLock( CriticalSection );
// Iterate over all outstanding requests and cancel matching ones.
int32 RequestsCanceled = 0;
for( int32 OutstandingIndex=OutstandingRequests.Num()-1; OutstandingIndex>=0 && RequestsCanceled<NumIndices; OutstandingIndex-- )
{
// Iterate over all indices of requests to cancel
for( int32 TheRequestIndex=0; TheRequestIndex<NumIndices; TheRequestIndex++ )
{
// Look for matching request index in queue.
const FAsyncIORequest IORequest = OutstandingRequests[OutstandingIndex];
if( IORequest.RequestIndex == RequestIndices[TheRequestIndex] )
{
INC_DWORD_STAT( STAT_AsyncIO_CanceledReadCount );
INC_DWORD_STAT_BY( STAT_AsyncIO_CanceledReadSize, IORequest.Size );
DEC_DWORD_STAT( STAT_AsyncIO_OutstandingReadCount );
DEC_DWORD_STAT_BY( STAT_AsyncIO_OutstandingReadSize, IORequest.Size );
// Decrement thread-safe counter to indicate that request has been "completed".
IORequest.Counter->Decrement();
// IORequest variable no longer valid after removal.
OutstandingRequests.RemoveAt( OutstandingIndex );
RequestsCanceled++;
// Break out of loop as we've modified OutstandingRequests AND it no longer is valid.
break;
}
}
}
return RequestsCanceled;
}
void FCanvasTileItem::RenderMaterialTile( class FCanvas* InCanvas, const FVector2D& InPosition )
{
// get sort element based on the current sort key from top of sort key stack
FCanvas::FCanvasSortElement& SortElement = InCanvas->GetSortElement(InCanvas->TopDepthSortKey());
// find a batch to use
FCanvasTileRendererItem* RenderBatch = NULL;
// get the current transform entry from top of transform stack
const FCanvas::FTransformEntry& TopTransformEntry = InCanvas->GetTransformStack().Top();
// try to use the current top entry in the render batch array
if( SortElement.RenderBatchArray.Num() > 0 )
{
checkSlow( SortElement.RenderBatchArray.Last() );
RenderBatch = SortElement.RenderBatchArray.Last()->GetCanvasTileRendererItem();
}
// if a matching entry for this batch doesn't exist then allocate a new entry
if( RenderBatch == NULL ||
!RenderBatch->IsMatch(MaterialRenderProxy,TopTransformEntry) )
{
INC_DWORD_STAT(STAT_Canvas_NumBatchesCreated);
RenderBatch = new FCanvasTileRendererItem( MaterialRenderProxy,TopTransformEntry,bFreezeTime );
SortElement.RenderBatchArray.Add(RenderBatch);
}
FHitProxyId HitProxyId = InCanvas->GetHitProxyId();
// add the quad to the tile render batch
RenderBatch->AddTile( InPosition.X, InPosition.Y ,Size.X, Size.Y, UV0.X, UV0.Y, UV1.X-UV0.X, UV1.Y-UV0.Y, HitProxyId );
}
void FDeferredShadingSceneRenderer::RenderLightShaftBloom(FRHICommandListImmediate& RHICmdList)
{
if (DoesViewFamilyAllowLightShafts(ViewFamily))
{
TRefCountPtr<IPooledRenderTarget> LightShafts0;
TRefCountPtr<IPooledRenderTarget> LightShafts1;
for (TSparseArray<FLightSceneInfoCompact>::TConstIterator LightIt(Scene->Lights); LightIt; ++LightIt)
{
const FLightSceneInfo* const LightSceneInfo = LightIt->LightSceneInfo;
if (LightSceneInfo->bEnableLightShaftBloom)
{
SCOPED_DRAW_EVENT(RHICmdList, RenderLightShaftBloom);
// Allocate light shaft render targets on demand, using the pool
AllocateOrReuseLightShaftRenderTarget(RHICmdList, LightShafts0, TEXT("LightShafts0"));
AllocateOrReuseLightShaftRenderTarget(RHICmdList, LightShafts1, TEXT("LightShafts1"));
for (int ViewIndex = 0;ViewIndex < Views.Num();ViewIndex++)
{
FViewInfo& View = Views[ViewIndex];
if (ShouldRenderLightShaftsForLight(View, LightSceneInfo))
{
INC_DWORD_STAT(STAT_LightShaftsLights);
// Generate the bloom source from scene color, masked by depth and downsampled
DownsamplePass<false>(RHICmdList, View, LightSceneInfo, LightShafts0, LightShafts1);
FSceneViewState* ViewState = (FSceneViewState*)View.State;
TRefCountPtr<IPooledRenderTarget>* HistoryState = NULL;
if (ViewState)
{
// Find the previous frame's bloom source for this light
HistoryState = &ViewState->LightShaftBloomHistoryRTs.FindOrAdd(LightSceneInfo->Proxy->GetLightComponent());
}
TRefCountPtr<IPooledRenderTarget> HistoryOutput;
// Apply temporal AA to the occlusion mask
// Result will be in HistoryOutput
ApplyTemporalAA(RHICmdList, View, TEXT("LSBloomHistory"), HistoryState, LightShafts0, HistoryOutput);
// Apply radial blur passes
// Send HistoryOutput in as the first pass input only, so it will not be overwritten by any subsequent passes, since it is needed for next frame
ApplyRadialBlurPasses(RHICmdList, View, LightSceneInfo, HistoryOutput, LightShafts0, LightShafts1);
// Add light shaft bloom to scene color in full res
ApplyLightShaftBloom(RHICmdList, View, LightSceneInfo, LightShafts0);
}
}
}
}
}
}
void USignificanceManager::RegisterObject(const UObject* Object, const FName Tag, FSignificanceFunction SignificanceFunction)
{
INC_DWORD_STAT(STAT_SignificanceManager_NumObjects);
SCOPE_CYCLE_COUNTER(STAT_SignificanceManager_RegisterObject);
check(Object);
checkf(!ManagedObjects.Contains(Object), TEXT("'%s' already added to significance manager. Original Tag: '%s' New Tag: '%s'"), *Object->GetName(), *ManagedObjects.FindChecked(Object)->GetTag().ToString(), *Tag.ToString());
FManagedObjectInfo* ObjectInfo = new FManagedObjectInfo(Object, Tag, SignificanceFunction);
// Calculate initial significance
if (Viewpoints.Num())
{
SCOPE_CYCLE_COUNTER(STAT_SignificanceManager_InitialSignificanceUpdate);
ObjectInfo->UpdateSignificance(Viewpoints);
}
ManagedObjects.Add(Object, ObjectInfo);
TArray<const FManagedObjectInfo*>& ManagedObjectInfos = ManagedObjectsByTag.FindOrAdd(Tag);
if (ManagedObjectInfos.Num() > 0)
{
// Insert in to the sorted list
int32 LowIndex = 0;
int32 HighIndex = ManagedObjectInfos.Num() - 1;
auto CompareFunction = PickCompareBySignificance(bSortSignificanceAscending);
while (true)
{
int32 MidIndex = LowIndex + (HighIndex - LowIndex) / 2;
if (CompareFunction(*ObjectInfo, *ManagedObjectInfos[MidIndex]))
{
if (LowIndex == MidIndex)
{
ManagedObjectInfos.Insert(ObjectInfo, LowIndex);
break;
}
else
{
HighIndex = MidIndex - 1;
}
}
else if (LowIndex == HighIndex)
{
ManagedObjectInfos.Insert(ObjectInfo, LowIndex + 1);
break;
}
else
{
LowIndex = MidIndex + 1;
}
}
}
else
{
ManagedObjectInfos.Add(ObjectInfo);
}
}
uint64 FAsyncIOSystemBase::QueueIORequest(
const FString& FileName,
int64 Offset,
int64 Size,
int64 UncompressedSize,
void* Dest,
ECompressionFlags CompressionFlags,
FThreadSafeCounter* Counter,
EAsyncIOPriority Priority )
{
check(Offset != INDEX_NONE);
check(Dest != nullptr || Size == 0);
FScopeLock ScopeLock(CriticalSection);
// Create an IO request containing passed in information.
FAsyncIORequest IORequest;
IORequest.RequestIndex = RequestIndex++;
IORequest.FileSortKey = INDEX_NONE;
IORequest.FileName = FileName;
IORequest.FileNameHash = FCrc::StrCrc32<TCHAR>(FileName.ToLower().GetCharArray().GetData());
IORequest.Offset = Offset;
IORequest.Size = Size;
IORequest.UncompressedSize = UncompressedSize;
IORequest.Dest = Dest;
IORequest.CompressionFlags = CompressionFlags;
IORequest.Counter = Counter;
IORequest.Priority = Priority;
static bool HasCheckedCommandline = false;
if (!HasCheckedCommandline)
{
HasCheckedCommandline = true;
if ( FParse::Param(FCommandLine::Get(), TEXT("logasync")))
{
GbLogAsyncLoading = true;
UE_LOG(LogStreaming, Warning, TEXT("*** ASYNC LOGGING IS ENABLED"));
}
}
if (GbLogAsyncLoading == true)
{
LogIORequest(TEXT("QueueIORequest"), IORequest);
}
INC_DWORD_STAT( STAT_AsyncIO_OutstandingReadCount );
INC_DWORD_STAT_BY( STAT_AsyncIO_OutstandingReadSize, IORequest.Size );
// Add to end of queue.
OutstandingRequests.Add( IORequest );
// Trigger event telling IO thread to wake up to perform work.
OutstandingRequestsEvent->Trigger();
// Return unique ID associated with request which can be used to cancel it.
return IORequest.RequestIndex;
}
virtual void Put(const TCHAR* CacheKey, TArray<uint8>& Data, bool bPutEvenIfExists = false) override
{
STAT(double ThisTime = 0);
{
SCOPE_SECONDS_COUNTER(ThisTime);
FDerivedDataBackend::Get().GetRoot().PutCachedData(CacheKey, Data, bPutEvenIfExists);
}
INC_FLOAT_STAT_BY(STAT_DDC_PutTime,(float)ThisTime);
INC_DWORD_STAT(STAT_DDC_NumPuts);
}
bool UBehaviorTreeManager::LoadTree(UBehaviorTree& Asset, UBTCompositeNode*& Root, uint16& InstanceMemorySize)
{
SCOPE_CYCLE_COUNTER(STAT_AI_BehaviorTree_LoadTime);
for (int32 TemplateIndex = 0; TemplateIndex < LoadedTemplates.Num(); TemplateIndex++)
{
FBehaviorTreeTemplateInfo& TemplateInfo = LoadedTemplates[TemplateIndex];
if (TemplateInfo.Asset == &Asset)
{
Root = TemplateInfo.Template;
InstanceMemorySize = TemplateInfo.InstanceMemorySize;
return true;
}
}
if (Asset.RootNode)
{
FBehaviorTreeTemplateInfo TemplateInfo;
TemplateInfo.Asset = &Asset;
TemplateInfo.Template = Cast<UBTCompositeNode>(StaticDuplicateObject(Asset.RootNode, this, TEXT("None")));
TArray<FNodeInitializationData> InitList;
uint16 ExecutionIndex = 0;
InitializeNodeHelper(NULL, TemplateInfo.Template, 0, ExecutionIndex, InitList, Asset, this);
#if USE_BEHAVIORTREE_DEBUGGER
// fill in information about next nodes in execution index, before sorting memory offsets
for (int32 Index = 0; Index < InitList.Num() - 1; Index++)
{
InitList[Index].Node->InitializeExecutionOrder(InitList[Index + 1].Node);
}
#endif
// sort nodes by memory size, so they can be packed better
// it still won't protect against structures, that are internally misaligned (-> uint8, uint32)
// but since all Engine level nodes are good...
InitList.Sort(FNodeInitializationData::FMemorySort());
uint16 MemoryOffset = 0;
for (int32 Index = 0; Index < InitList.Num(); Index++)
{
InitList[Index].Node->InitializeNode(InitList[Index].ParentNode, InitList[Index].ExecutionIndex, InitList[Index].SpecialDataSize + MemoryOffset, InitList[Index].TreeDepth);
MemoryOffset += InitList[Index].DataSize;
}
TemplateInfo.InstanceMemorySize = MemoryOffset;
INC_DWORD_STAT(STAT_AI_BehaviorTree_NumTemplates);
LoadedTemplates.Add(TemplateInfo);
Root = TemplateInfo.Template;
InstanceMemorySize = TemplateInfo.InstanceMemorySize;
return true;
}
return false;
}
virtual bool CachedDataProbablyExists(const TCHAR* CacheKey) override
{
bool bResult;
INC_DWORD_STAT(STAT_DDC_NumExist);
STAT(double ThisTime = 0);
{
SCOPE_SECONDS_COUNTER(ThisTime);
bResult = FDerivedDataBackend::Get().GetRoot().CachedDataProbablyExists(CacheKey);
}
INC_FLOAT_STAT_BY(STAT_DDC_ExistTime, (float)ThisTime);
return bResult;
}
FUniformBufferRHIRef CreatePrecomputedLightingUniformBuffer(
EUniformBufferUsage BufferUsage,
ERHIFeatureLevel::Type FeatureLevel,
const FIndirectLightingCache* LightingCache,
const FIndirectLightingCacheAllocation* LightingAllocation,
const FLightCacheInterface* LCI
)
{
INC_DWORD_STAT(STAT_IndirectLightingCacheUpdates);
FPrecomputedLightingParameters Parameters;
GetPrecomputedLightingParameters(FeatureLevel, Parameters, LightingCache, LightingAllocation, LCI);
return FPrecomputedLightingParameters::CreateUniformBuffer(Parameters, BufferUsage);
}
FD3D11BoundShaderState::FD3D11BoundShaderState(
FVertexDeclarationRHIParamRef InVertexDeclarationRHI,
FVertexShaderRHIParamRef InVertexShaderRHI,
FPixelShaderRHIParamRef InPixelShaderRHI,
FHullShaderRHIParamRef InHullShaderRHI,
FDomainShaderRHIParamRef InDomainShaderRHI,
FGeometryShaderRHIParamRef InGeometryShaderRHI,
ID3D11Device* Direct3DDevice
):
CacheLink(InVertexDeclarationRHI,InVertexShaderRHI,InPixelShaderRHI,InHullShaderRHI,InDomainShaderRHI,InGeometryShaderRHI,this)
{
INC_DWORD_STAT(STAT_D3D11NumBoundShaderState);
FD3D11VertexDeclaration* InVertexDeclaration = FD3D11DynamicRHI::ResourceCast(InVertexDeclarationRHI);
FD3D11VertexShader* InVertexShader = FD3D11DynamicRHI::ResourceCast(InVertexShaderRHI);
FD3D11PixelShader* InPixelShader = FD3D11DynamicRHI::ResourceCast(InPixelShaderRHI);
FD3D11HullShader* InHullShader = FD3D11DynamicRHI::ResourceCast(InHullShaderRHI);
FD3D11DomainShader* InDomainShader = FD3D11DynamicRHI::ResourceCast(InDomainShaderRHI);
FD3D11GeometryShader* InGeometryShader = FD3D11DynamicRHI::ResourceCast(InGeometryShaderRHI);
// Create an input layout for this combination of vertex declaration and vertex shader.
D3D11_INPUT_ELEMENT_DESC NullInputElement;
FMemory::Memzero(&NullInputElement,sizeof(D3D11_INPUT_ELEMENT_DESC));
VERIFYD3D11RESULT(Direct3DDevice->CreateInputLayout(
InVertexDeclaration ? InVertexDeclaration->VertexElements.GetData() : &NullInputElement,
InVertexDeclaration ? InVertexDeclaration->VertexElements.Num() : 0,
&InVertexShader->Code[ InVertexShader->Offset ], // TEMP ugly
InVertexShader->Code.Num() - 1 - InVertexShader->Offset,
InputLayout.GetInitReference()
));
VertexShader = InVertexShader->Resource;
PixelShader = InPixelShader ? InPixelShader->Resource : NULL;
HullShader = InHullShader ? InHullShader->Resource : NULL;
DomainShader = InDomainShader ? InDomainShader->Resource : NULL;
GeometryShader = InGeometryShader ? InGeometryShader->Resource : NULL;
FMemory::Memzero(&bShaderNeedsGlobalConstantBuffer,sizeof(bShaderNeedsGlobalConstantBuffer));
bShaderNeedsGlobalConstantBuffer[SF_Vertex] = InVertexShader->bShaderNeedsGlobalConstantBuffer;
bShaderNeedsGlobalConstantBuffer[SF_Hull] = InHullShader ? InHullShader->bShaderNeedsGlobalConstantBuffer : false;
bShaderNeedsGlobalConstantBuffer[SF_Domain] = InDomainShader ? InDomainShader->bShaderNeedsGlobalConstantBuffer : false;
bShaderNeedsGlobalConstantBuffer[SF_Pixel] = InPixelShader ? InPixelShader->bShaderNeedsGlobalConstantBuffer : false;
bShaderNeedsGlobalConstantBuffer[SF_Geometry] = InGeometryShader ? InGeometryShader->bShaderNeedsGlobalConstantBuffer : false;
static_assert(ARRAY_COUNT(bShaderNeedsGlobalConstantBuffer) == SF_NumFrequencies, "EShaderFrequency size should match with array count of bShaderNeedsGlobalConstantBuffer.");
}
void UAudioComponent::PlaybackCompleted(bool bFailedToStart)
{
// Mark inactive before calling destroy to avoid recursion
bIsActive = false;
if (!bFailedToStart && GetWorld() != nullptr && (OnAudioFinished.IsBound() || OnAudioFinishedNative.IsBound()))
{
INC_DWORD_STAT( STAT_AudioFinishedDelegatesCalled );
SCOPE_CYCLE_COUNTER( STAT_AudioFinishedDelegates );
OnAudioFinished.Broadcast();
OnAudioFinishedNative.Broadcast(this);
}
// Auto destruction is handled via marking object for deletion.
if (bAutoDestroy)
{
DestroyComponent();
}
}
FD3D12BoundShaderState::FD3D12BoundShaderState(
FVertexDeclarationRHIParamRef InVertexDeclarationRHI,
FVertexShaderRHIParamRef InVertexShaderRHI,
FPixelShaderRHIParamRef InPixelShaderRHI,
FHullShaderRHIParamRef InHullShaderRHI,
FDomainShaderRHIParamRef InDomainShaderRHI,
FGeometryShaderRHIParamRef InGeometryShaderRHI
) :
CacheLink(InVertexDeclarationRHI, InVertexShaderRHI, InPixelShaderRHI, InHullShaderRHI, InDomainShaderRHI, InGeometryShaderRHI, this),
UniqueID(InterlockedIncrement64(reinterpret_cast<volatile int64*>(&BoundShaderStateID)))
{
INC_DWORD_STAT(STAT_D3D12NumBoundShaderState);
// Warning: Input layout desc contains padding which must be zero-initialized to prevent PSO cache misses
FMemory::Memzero(&InputLayout, sizeof(InputLayout));
FD3D12VertexDeclaration* InVertexDeclaration = FD3D12DynamicRHI::ResourceCast(InVertexDeclarationRHI);
FD3D12VertexShader* InVertexShader = FD3D12DynamicRHI::ResourceCast(InVertexShaderRHI);
FD3D12PixelShader* InPixelShader = FD3D12DynamicRHI::ResourceCast(InPixelShaderRHI);
FD3D12HullShader* InHullShader = FD3D12DynamicRHI::ResourceCast(InHullShaderRHI);
FD3D12DomainShader* InDomainShader = FD3D12DynamicRHI::ResourceCast(InDomainShaderRHI);
FD3D12GeometryShader* InGeometryShader = FD3D12DynamicRHI::ResourceCast(InGeometryShaderRHI);
// Create an input layout for this combination of vertex declaration and vertex shader.
InputLayout.NumElements = (InVertexDeclaration ? InVertexDeclaration->VertexElements.Num() : 0);
InputLayout.pInputElementDescs = (InVertexDeclaration ? InVertexDeclaration->VertexElements.GetData() : nullptr);
bShaderNeedsGlobalConstantBuffer[SF_Vertex] = InVertexShader->bShaderNeedsGlobalConstantBuffer;
bShaderNeedsGlobalConstantBuffer[SF_Hull] = InHullShader ? InHullShader->bShaderNeedsGlobalConstantBuffer : false;
bShaderNeedsGlobalConstantBuffer[SF_Domain] = InDomainShader ? InDomainShader->bShaderNeedsGlobalConstantBuffer : false;
bShaderNeedsGlobalConstantBuffer[SF_Pixel] = InPixelShader ? InPixelShader->bShaderNeedsGlobalConstantBuffer : false;
bShaderNeedsGlobalConstantBuffer[SF_Geometry] = InGeometryShader ? InGeometryShader->bShaderNeedsGlobalConstantBuffer : false;
static_assert(ARRAY_COUNT(bShaderNeedsGlobalConstantBuffer) == SF_NumFrequencies, "EShaderFrequency size should match with array count of bShaderNeedsGlobalConstantBuffer.");
#if D3D12_SUPPORTS_PARALLEL_RHI_EXECUTE
CacheLink.AddToCache();
#endif
}
/**
* Kill off any dead particles. (Remove them from the active array)
*/
void FParticleBeam2EmitterInstance::KillParticles()
{
if (ActiveParticles > 0)
{
UParticleLODLevel* LODLevel = SpriteTemplate->GetCurrentLODLevel(this);
check(LODLevel);
FParticleEventInstancePayload* EventPayload = NULL;
if (LODLevel->EventGenerator)
{
EventPayload = (FParticleEventInstancePayload*)GetModuleInstanceData(LODLevel->EventGenerator);
if (EventPayload && (EventPayload->bDeathEventsPresent == false))
{
EventPayload = NULL;
}
}
// Loop over the active particles... If their RelativeTime is > 1.0f (indicating they are dead),
// move them to the 'end' of the active particle list.
for (int32 i=ActiveParticles-1; i>=0; i--)
{
const int32 CurrentIndex = ParticleIndices[i];
const uint8* ParticleBase = ParticleData + CurrentIndex * ParticleStride;
FBaseParticle& Particle = *((FBaseParticle*) ParticleBase);
if (Particle.RelativeTime > 1.0f)
{
if (EventPayload)
{
LODLevel->EventGenerator->HandleParticleKilled(this, EventPayload, &Particle);
}
ParticleIndices[i] = ParticleIndices[ActiveParticles-1];
ParticleIndices[ActiveParticles-1] = CurrentIndex;
ActiveParticles--;
INC_DWORD_STAT(STAT_BeamParticlesKilled);
}
}
}
}
SWidget::SWidget()
: Cursor( TOptional<EMouseCursor::Type>() )
, EnabledState( true )
, Visibility( EVisibility::Visible )
, RenderTransform( )
, RenderTransformPivot( FVector2D::ZeroVector )
, DesiredSize(FVector2D::ZeroVector)
, ToolTip()
, LayoutCache(nullptr)
, bIsHovered(false)
, bCanTick(true)
, bCanSupportFocus(true)
, bCanHaveChildren(true)
, bToolTipForceFieldEnabled(false)
, bForceVolatile(false)
, bCachedVolatile(false)
, bInheritedVolatility(false)
{
if (GIsRunning)
{
INC_DWORD_STAT(STAT_SlateTotalWidgets);
}
}
void SWidget::TickWidgetsRecursively( const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime )
{
INC_DWORD_STAT(STAT_SlateNumTickedWidgets);
// Execute any pending active timers for this widget, followed by the passive tick
ExecuteActiveTimers( InCurrentTime, InDeltaTime );
{
SLATE_CYCLE_COUNTER_SCOPE_CUSTOM_DETAILED(SLATE_STATS_DETAIL_LEVEL_MED, GSlateWidgetTick, GetType());
Tick(AllottedGeometry, InCurrentTime, InDeltaTime);
}
// Gather all children, whether they're visible or not. We need to allow invisible widgets to
// consider whether they should still be invisible in their tick functions, as well as maintain
// other state when hidden,
FArrangedChildren ArrangedChildren(TickInvisibleWidgets.GetValueOnGameThread() ? EVisibility::All : EVisibility::Visible);
ArrangeChildren(AllottedGeometry, ArrangedChildren);
// Recur!
for(int32 ChildIndex=0; ChildIndex < ArrangedChildren.Num(); ++ChildIndex)
{
FArrangedWidget& SomeChild = ArrangedChildren[ChildIndex];
SomeChild.Widget->TickWidgetsRecursively( SomeChild.Geometry, InCurrentTime, InDeltaTime );
}
}
/**
* Issues level streaming load/unload requests based on whether
* players are inside/outside level streaming volumes.
*/
void UWorld::ProcessLevelStreamingVolumes(FVector* OverrideViewLocation)
{
// if we are delaying using streaming volumes, return now
if( StreamingVolumeUpdateDelay > 0 )
{
StreamingVolumeUpdateDelay--;
return;
}
// Option to skip indefinitely.
else if( StreamingVolumeUpdateDelay == INDEX_NONE )
{
return;
}
SCOPE_CYCLE_COUNTER( STAT_VolumeStreamingTickTime );
// Begin by assembling a list of kismet streaming objects that have non-EditorPreVisOnly volumes associated with them.
// @todo DB: Cache this, e.g. level startup.
TArray<ULevelStreaming*> LevelStreamingObjectsWithVolumes;
TMap<ULevelStreaming*,bool> LevelStreamingObjectsWithVolumesOtherThanBlockingLoad;
for( int32 LevelIndex = 0 ; LevelIndex < StreamingLevels.Num() ; ++LevelIndex )
{
ULevelStreaming* LevelStreamingObject = StreamingLevels[LevelIndex];
if( LevelStreamingObject )
{
for ( int32 i = 0 ; i < LevelStreamingObject->EditorStreamingVolumes.Num() ; ++i )
{
ALevelStreamingVolume* StreamingVolume = LevelStreamingObject->EditorStreamingVolumes[i];
if( StreamingVolume
&& !StreamingVolume->bEditorPreVisOnly
&& !StreamingVolume->bDisabled )
{
LevelStreamingObjectsWithVolumes.Add( LevelStreamingObject );
if( StreamingVolume->StreamingUsage != SVB_BlockingOnLoad )
{
LevelStreamingObjectsWithVolumesOtherThanBlockingLoad.Add( LevelStreamingObject, true );
}
break;
}
}
}
}
// The set of levels with volumes whose volumes current contain player viewpoints.
TMap<ULevelStreaming*,FVisibleLevelStreamingSettings> VisibleLevelStreamingObjects;
// Iterate over all players and build a list of level streaming objects with
// volumes that contain player viewpoints.
bool bStreamingVolumesAreRelevant = false;
for( FConstPlayerControllerIterator Iterator = GetPlayerControllerIterator(); Iterator; ++Iterator )
{
APlayerController* PlayerActor = *Iterator;
if (PlayerActor->bIsUsingStreamingVolumes)
{
bStreamingVolumesAreRelevant = true;
FVector ViewLocation(0,0,0);
// let the caller override the location to check for volumes
if (OverrideViewLocation)
{
ViewLocation = *OverrideViewLocation;
}
else
{
FRotator ViewRotation(0,0,0);
PlayerActor->GetPlayerViewPoint( ViewLocation, ViewRotation );
}
TMap<AVolume*,bool> VolumeMap;
// Iterate over streaming levels with volumes and compute whether the
// player's ViewLocation is in any of their volumes.
for( int32 LevelIndex = 0 ; LevelIndex < LevelStreamingObjectsWithVolumes.Num() ; ++LevelIndex )
{
ULevelStreaming* LevelStreamingObject = LevelStreamingObjectsWithVolumes[ LevelIndex ];
// StreamingSettings is an OR of all level streaming settings of volumes containing player viewpoints.
FVisibleLevelStreamingSettings StreamingSettings;
// See if level streaming settings were computed for other players.
FVisibleLevelStreamingSettings* ExistingStreamingSettings = VisibleLevelStreamingObjects.Find( LevelStreamingObject );
if ( ExistingStreamingSettings )
{
// Stop looking for viewpoint-containing volumes once all streaming settings have been enabled for the level.
if ( ExistingStreamingSettings->AllSettingsEnabled() )
{
continue;
}
// Initialize the level's streaming settings with settings that were computed for other players.
StreamingSettings = *ExistingStreamingSettings;
}
// For each streaming volume associated with this level . . .
for ( int32 i = 0 ; i < LevelStreamingObject->EditorStreamingVolumes.Num() ; ++i )
{
ALevelStreamingVolume* StreamingVolume = LevelStreamingObject->EditorStreamingVolumes[i];
if ( StreamingVolume && !StreamingVolume->bEditorPreVisOnly && !StreamingVolume->bDisabled )
{
bool bViewpointInVolume;
bool* bResult = VolumeMap.Find(StreamingVolume);
if ( bResult )
{
// This volume has already been considered for another level.
bViewpointInVolume = *bResult;
}
else
{
// Compute whether the viewpoint is inside the volume and cache the result.
bViewpointInVolume = StreamingVolume->EncompassesPoint( ViewLocation );
VolumeMap.Add( StreamingVolume, bViewpointInVolume );
INC_DWORD_STAT( STAT_VolumeStreamingChecks );
}
if ( bViewpointInVolume )
{
// Copy off the streaming settings for this volume.
StreamingSettings |= FVisibleLevelStreamingSettings( (EStreamingVolumeUsage) StreamingVolume->StreamingUsage );
// Update the streaming settings for the level.
// This also marks the level as "should be loaded".
VisibleLevelStreamingObjects.Add( LevelStreamingObject, StreamingSettings );
// Stop looking for viewpoint-containing volumes once all streaming settings have been enabled.
if ( StreamingSettings.AllSettingsEnabled() )
{
break;
}
}
}
}
} // for each streaming level
} // bIsUsingStreamingVolumes
} // for each PlayerController
// do nothing if no players are using streaming volumes
if (bStreamingVolumesAreRelevant)
{
// Iterate over all streaming levels and set the level's loading status based
// on whether it was found to be visible by a level streaming volume.
for( int32 LevelIndex = 0 ; LevelIndex < LevelStreamingObjectsWithVolumes.Num() ; ++LevelIndex )
{
ULevelStreaming* LevelStreamingObject = LevelStreamingObjectsWithVolumes[LevelIndex];
// Figure out whether level should be loaded and keep track of original state for notifications on change.
FVisibleLevelStreamingSettings* NewStreamingSettings= VisibleLevelStreamingObjects.Find( LevelStreamingObject );
bool bShouldAffectLoading = LevelStreamingObjectsWithVolumesOtherThanBlockingLoad.Find( LevelStreamingObject ) != NULL;
bool bShouldBeLoaded = (NewStreamingSettings != NULL);
bool bOriginalShouldBeLoaded = LevelStreamingObject->bShouldBeLoaded;
bool bOriginalShouldBeVisible = LevelStreamingObject->bShouldBeVisible;
bool bOriginalShouldBlockOnLoad = LevelStreamingObject->bShouldBlockOnLoad;
int32 bOriginalLODIndex = LevelStreamingObject->LevelLODIndex;
if( bShouldBeLoaded || bShouldAffectLoading )
{
if( bShouldBeLoaded )
{
// Loading.
LevelStreamingObject->bShouldBeLoaded = true;
LevelStreamingObject->bShouldBeVisible = NewStreamingSettings->ShouldBeVisible( bOriginalShouldBeVisible );
LevelStreamingObject->bShouldBlockOnLoad = NewStreamingSettings->ShouldBlockOnLoad();
}
// Prevent unload request flood. The additional check ensures that unload requests can still be issued in the first UnloadCooldownTime seconds of play.
else
if( TimeSeconds - LevelStreamingObject->LastVolumeUnloadRequestTime > LevelStreamingObject->MinTimeBetweenVolumeUnloadRequests
|| LevelStreamingObject->LastVolumeUnloadRequestTime < 0.1f )
{
//UE_LOG(LogLevel, Warning, TEXT("Unloading") );
if( GetPlayerControllerIterator() )
{
LevelStreamingObject->LastVolumeUnloadRequestTime = TimeSeconds;
LevelStreamingObject->bShouldBeLoaded = false;
LevelStreamingObject->bShouldBeVisible = false;
}
}
// Notify players of the change.
if( bOriginalShouldBeLoaded != LevelStreamingObject->bShouldBeLoaded
|| bOriginalShouldBeVisible != LevelStreamingObject->bShouldBeVisible
|| bOriginalShouldBlockOnLoad != LevelStreamingObject->bShouldBlockOnLoad
|| bOriginalLODIndex != LevelStreamingObject->LevelLODIndex)
{
for( FConstPlayerControllerIterator Iterator = GetPlayerControllerIterator(); Iterator; ++Iterator )
{
APlayerController* PlayerController = *Iterator;
PlayerController->LevelStreamingStatusChanged(
LevelStreamingObject,
LevelStreamingObject->bShouldBeLoaded,
LevelStreamingObject->bShouldBeVisible,
LevelStreamingObject->bShouldBlockOnLoad,
LevelStreamingObject->LevelLODIndex);
}
}
}
}
}
}
/** Renders light shafts. */
FLightShaftsOutput FDeferredShadingSceneRenderer::RenderLightShaftOcclusion(FRHICommandListImmediate& RHICmdList)
{
FLightShaftsOutput Output;
if (DoesViewFamilyAllowLightShafts(ViewFamily))
{
TRefCountPtr<IPooledRenderTarget> LightShafts0;
TRefCountPtr<IPooledRenderTarget> LightShafts1;
for (TSparseArray<FLightSceneInfoCompact>::TConstIterator LightIt(Scene->Lights); LightIt; ++LightIt)
{
const FLightSceneInfo* const LightSceneInfo = LightIt->LightSceneInfo;
float OcclusionMaskDarkness;
float OcclusionDepthRange;
const bool bEnableOcclusion = LightSceneInfo->Proxy->GetLightShaftOcclusionParameters(OcclusionMaskDarkness, OcclusionDepthRange);
if (bEnableOcclusion && LightSceneInfo->Proxy->GetLightType() == LightType_Directional)
{
SCOPED_DRAW_EVENT(RHICmdList, RenderLightShaftOcclusion);
// Allocate light shaft render targets on demand, using the pool
// Need two targets to ping pong between
AllocateOrReuseLightShaftRenderTarget(RHICmdList, LightShafts0, TEXT("LightShafts0"));
AllocateOrReuseLightShaftRenderTarget(RHICmdList, LightShafts1, TEXT("LightShafts1"));
for (int ViewIndex = 0;ViewIndex < Views.Num();ViewIndex++)
{
FViewInfo& View = Views[ViewIndex];
if (ShouldRenderLightShaftsForLight(View, LightSceneInfo))
{
INC_DWORD_STAT(STAT_LightShaftsLights);
// Create a downsampled occlusion mask from scene depth, result will be in LightShafts0
DownsamplePass<true>(RHICmdList, View, LightSceneInfo, LightShafts0, LightShafts1);
FSceneViewState* ViewState = (FSceneViewState*)View.State;
// Find the previous frame's occlusion mask
TRefCountPtr<IPooledRenderTarget>* HistoryState = ViewState ? &ViewState->LightShaftOcclusionHistoryRT : NULL;
TRefCountPtr<IPooledRenderTarget> HistoryOutput;
// Apply temporal AA to the occlusion mask
// Result will be in HistoryOutput
ApplyTemporalAA(RHICmdList, View, TEXT("LSOcclusionHistory"), HistoryState, LightShafts0, HistoryOutput);
// Apply radial blur passes
// Send HistoryOutput in as the first pass input only, so it will not be overwritten by any subsequent passes, since it is needed for next frame
ApplyRadialBlurPasses(RHICmdList, View, LightSceneInfo, HistoryOutput, LightShafts0, LightShafts1);
// Apply post-blur masking
FinishOcclusionTerm(RHICmdList, View, LightSceneInfo, LightShafts0, LightShafts1);
//@todo - different views could have different result render targets
Output.LightShaftOcclusion = LightShafts1;
Output.bRendered = true;
}
}
}
}
}
return Output;
}
/**
* Tick the instance.
*
* @param DeltaTime The time slice to use
* @param bSuppressSpawning If true, do not spawn during Tick
*/
void FParticleBeam2EmitterInstance::Tick(float DeltaTime, bool bSuppressSpawning)
{
SCOPE_CYCLE_COUNTER(STAT_BeamTickTime);
if (Component)
{
UParticleLODLevel* LODLevel = SpriteTemplate->GetCurrentLODLevel(this);
check(LODLevel); // TTP #33141
// Handle EmitterTime setup, looping, etc.
float EmitterDelay = Tick_EmitterTimeSetup(DeltaTime, LODLevel);
// Kill before the spawn... Otherwise, we can get 'flashing'
KillParticles();
// If not suppressing spawning...
if (!bHaltSpawning && !bSuppressSpawning && (EmitterTime >= 0.0f))
{
if ((LODLevel->RequiredModule->EmitterLoops == 0) ||
(LoopCount < LODLevel->RequiredModule->EmitterLoops) ||
(SecondsSinceCreation < (EmitterDuration * LODLevel->RequiredModule->EmitterLoops)))
{
// For beams, we probably want to ignore the SpawnRate distribution,
// and focus strictly on the BurstList...
float SpawnRate = 0.0f;
// Figure out spawn rate for this tick.
SpawnRate = LODLevel->SpawnModule->Rate.GetValue(EmitterTime, Component);
// Take Bursts into account as well...
int32 Burst = 0;
float BurstTime = GetCurrentBurstRateOffset(DeltaTime, Burst);
SpawnRate += BurstTime;
// Spawn new particles...
//@todo. Fix the issue of 'blanking' beams when the count drops...
// This is a temporary hack!
const float InvDeltaTime = (DeltaTime > 0.0f) ? 1.0f / DeltaTime : 0.0f;
if ((ActiveParticles < BeamCount) && (SpawnRate <= 0.0f))
{
// Force the spawn of a single beam...
SpawnRate = 1.0f * InvDeltaTime;
}
// Force beams if the emitter is marked "AlwaysOn"
if ((ActiveParticles < BeamCount) && BeamTypeData->bAlwaysOn)
{
Burst = BeamCount;
if (DeltaTime > KINDA_SMALL_NUMBER)
{
BurstTime = Burst * InvDeltaTime;
SpawnRate += BurstTime;
}
}
if (SpawnRate > 0.f)
{
SpawnFraction = SpawnBeamParticles(SpawnFraction, SpawnRate, DeltaTime, Burst, BurstTime);
}
}
}
// Reset particle data
ResetParticleParameters(DeltaTime);
// Not really necessary as beams do not LOD at the moment, but for consistency...
CurrentMaterial = LODLevel->RequiredModule->Material;
Tick_ModuleUpdate(DeltaTime, LODLevel);
Tick_ModulePostUpdate(DeltaTime, LODLevel);
// Calculate bounding box and simulate velocity.
UpdateBoundingBox(DeltaTime);
if (!bSuppressSpawning)
{
// Ensure that we flip the 'FirstEmission' flag
FirstEmission = false;
}
// Invalidate the contents of the vertex/index buffer.
IsRenderDataDirty = 1;
// Bump the tick count
TickCount++;
// 'Reset' the emitter time so that the delay functions correctly
EmitterTime += CurrentDelay;
// Reset particles position offset
PositionOffsetThisTick = FVector::ZeroVector;
}
INC_DWORD_STAT(STAT_BeamParticlesUpdateCalls);
}
void FAsyncIOSystemBase::Tick()
{
// Create file handles.
{
TArray<FString> FileNamesToCacheHandles;
// Only enter critical section for copying existing array over. We don't operate on the
// real array as creating file handles might take a while and we don't want to have other
// threads stalling on submission of requests.
{
FScopeLock ScopeLock( CriticalSection );
for( int32 RequestIdx=0; RequestIdx<OutstandingRequests.Num(); RequestIdx++ )
{
// Early outs avoid unnecessary work and string copies with implicit allocator churn.
FAsyncIORequest& OutstandingRequest = OutstandingRequests[RequestIdx];
if( OutstandingRequest.bHasAlreadyRequestedHandleToBeCached == false
&& OutstandingRequest.bIsDestroyHandleRequest == false
&& FindCachedFileHandle( OutstandingRequest.FileNameHash ) == NULL )
{
new(FileNamesToCacheHandles)FString(*OutstandingRequest.FileName);
OutstandingRequest.bHasAlreadyRequestedHandleToBeCached = true;
}
}
}
// Create file handles for requests down the pipe. This is done here so we can later on
// use the handles to figure out the sort keys.
for( int32 FileNameIndex=0; FileNameIndex<FileNamesToCacheHandles.Num(); FileNameIndex++ )
{
GetCachedFileHandle( FileNamesToCacheHandles[FileNameIndex] );
}
}
// Copy of request.
FAsyncIORequest IORequest;
bool bIsRequestPending = false;
{
FScopeLock ScopeLock( CriticalSection );
if( OutstandingRequests.Num() )
{
// Gets next request index based on platform specific criteria like layout on disc.
int32 TheRequestIndex = PlatformGetNextRequestIndex();
if( TheRequestIndex != INDEX_NONE )
{
// We need to copy as we're going to remove it...
IORequest = OutstandingRequests[ TheRequestIndex ];
// ...right here.
// NOTE: this needs to be a Remove, not a RemoveSwap because the base implementation
// of PlatformGetNextRequestIndex is a FIFO taking priority into account
OutstandingRequests.RemoveAt( TheRequestIndex );
// We're busy. Updated inside scoped lock to ensure BlockTillAllRequestsFinished works correctly.
BusyWithRequest.Increment();
bIsRequestPending = true;
}
}
}
// We only have work to do if there's a request pending.
if( bIsRequestPending )
{
// handle a destroy handle request from the queue
if( IORequest.bIsDestroyHandleRequest )
{
IFileHandle* FileHandle = FindCachedFileHandle( IORequest.FileNameHash );
if( FileHandle )
{
// destroy and remove the handle
delete FileHandle;
NameHashToHandleMap.Remove(IORequest.FileNameHash);
}
}
else
{
// Retrieve cached handle or create it if it wasn't cached. We purposefully don't look at currently
// set value as it might be stale by now.
IFileHandle* FileHandle = GetCachedFileHandle( IORequest.FileName );
if( FileHandle )
{
if( IORequest.UncompressedSize )
{
// Data is compressed on disc so we need to also decompress.
FulfillCompressedRead( IORequest, FileHandle );
}
else
{
// Read data after seeking.
InternalRead( FileHandle, IORequest.Offset, IORequest.Size, IORequest.Dest );
}
INC_DWORD_STAT( STAT_AsyncIO_FulfilledReadCount );
INC_DWORD_STAT_BY( STAT_AsyncIO_FulfilledReadSize, IORequest.Size );
}
else
{
//@todo streaming: add warning once we have thread safe logging.
}
DEC_DWORD_STAT( STAT_AsyncIO_OutstandingReadCount );
DEC_DWORD_STAT_BY( STAT_AsyncIO_OutstandingReadSize, IORequest.Size );
}
// Request fulfilled.
if( IORequest.Counter )
{
IORequest.Counter->Decrement();
}
// We're done reading for now.
BusyWithRequest.Decrement();
}
else
{
if( !OutstandingRequests.Num() && FPlatformProcess::SupportsMultithreading() )
{
// We're really out of requests now, wait till the calling thread signals further work
OutstandingRequestsEvent->Wait();
}
}
}
void FRuntimeAssetCacheAsyncWorker::DoWork()
{
const TCHAR* Bucket = CacheBuilder->GetTypeName();
FName BucketName = FName(Bucket);
FString CacheKey = BuildCacheKey(CacheBuilder);
FName CacheKeyName = FName(*CacheKey);
FRuntimeAssetCacheBucket* CurrentBucket = (*Buckets)[BucketName];
INC_DWORD_STAT(STAT_RAC_NumGets);
FCacheEntryMetadata* Metadata = nullptr;
{
DECLARE_SCOPE_CYCLE_COUNTER(TEXT("RAC async get time"), STAT_RAC_AsyncGetTime, STATGROUP_RAC);
Metadata = CurrentBucket->GetMetadata(CacheKey);
}
if (Metadata == nullptr)
{
FRuntimeAssetCacheBucketScopeLock Guard(*CurrentBucket);
CurrentBucket->AddMetadataEntry(CacheKey, new FCacheEntryMetadata(FDateTime::MaxValue(), 0, 0, CacheKeyName), false);
}
else
{
while (Metadata->IsBuilding())
{
FPlatformProcess::SleepNoStats(0.0f);
}
Metadata = FRuntimeAssetCacheBackend::Get().GetCachedData(BucketName, *CacheKey, Data);
}
ON_SCOPE_EXIT
{
/** Make sure completed work counter works properly regardless of where function is exited. */
GetRuntimeAssetCache().AddToAsyncCompletionCounter(-1);
};
/* Entry found. */
if (Metadata
/* But was saved with older builder version. */
&& Metadata->GetCachedAssetVersion() < CacheBuilder->GetAssetVersion())
{
/* Pretend entry wasn't found, so it gets rebuilt. */
FRuntimeAssetCacheBucketScopeLock Guard(*CurrentBucket);
FRuntimeAssetCacheBackend::Get().RemoveCacheEntry(BucketName, *CacheKey);
CurrentBucket->AddToCurrentSize(-Metadata->GetCachedAssetSize());
CurrentBucket->RemoveMetadataEntry(CacheKey);
delete Metadata;
Metadata = nullptr;
}
if (Metadata)
{
check(Data.Num());
INC_DWORD_STAT(STAT_RAC_NumCacheHits);
FRuntimeAssetCacheBucketScopeLock Guard(*CurrentBucket);
Metadata->SetCachedAssetSize(Data.Num());
Metadata->SetLastAccessTime(FDateTime::Now());
bEntryRetrieved = true;
return;
}
if (!CacheBuilder)
{
// Failed, cleanup data and return false.
INC_DWORD_STAT(STAT_RAC_NumFails);
Data.Empty();
bEntryRetrieved = false;
CurrentBucket->RemoveMetadataEntry(CacheKey);
return;
}
bool bSuccess;
{
INC_DWORD_STAT(STAT_RAC_NumBuilds);
DECLARE_SCOPE_CYCLE_COUNTER(TEXT("RAC async build time"), STAT_RAC_AsyncBuildTime, STATGROUP_RAC)
bSuccess = CacheBuilder->Build(Data);
}
if (!bSuccess)
{
// Failed, cleanup data and return false.
INC_DWORD_STAT(STAT_RAC_NumFails);
Data.Empty();
CurrentBucket->RemoveMetadataEntry(CacheKey);
return;
}
checkf(Data.Num(), TEXT("Size of asset to cache cannot be null. Asset cache key: %s"), *CacheKey);
checkf(Data.Num() < CurrentBucket->GetSize(), TEXT("Cached asset is bigger than cache size. Increase cache size or reduce asset size. Asset cache key: %s"), *CacheKey);
FRuntimeAssetCacheBucketScopeLock Lock(*CurrentBucket);
// Do we need to make some space in cache?
int32 SizeOfSpaceToFree = CurrentBucket->GetCurrentSize() + Data.Num() - CurrentBucket->GetSize();
if (SizeOfSpaceToFree > 0)
{
// Remove oldest entries from cache until we can fit upcoming entry.
FreeCacheSpace(BucketName, SizeOfSpaceToFree);
}
{
DECLARE_SCOPE_CYCLE_COUNTER(TEXT("RAC async put time"), STAT_RAC_PutTime, STATGROUP_RAC)
FDateTime Now = FDateTime::Now();
FCacheEntryMetadata* Metadata = CurrentBucket->GetMetadata(*CacheKey);
if (Metadata)
{
Metadata->SetLastAccessTime(Now);
if (Metadata->GetCachedAssetSize() == 0)
{
CurrentBucket->AddToCurrentSize(Data.Num());
}
Metadata->SetCachedAssetSize(Data.Num());
Metadata->SetCachedAssetVersion(CacheBuilder->GetAssetVersion());
CurrentBucket->AddMetadataEntry(CacheKey, Metadata, false);
}
else
{
Metadata = new FCacheEntryMetadata(Now, Data.Num(), CacheBuilder->GetAssetVersion(), CacheKeyName);
CurrentBucket->AddMetadataEntry(CacheKey, Metadata, true);
}
FRuntimeAssetCacheBackend::Get().PutCachedData(BucketName, *CacheKey, Data, Metadata);
// Mark that building is finished AFTER putting data into
// cache to avoid duplicate builds of the same entry.
Metadata->FinishBuilding();
}
bEntryRetrieved = true;
}
int32 SWidget::Paint(const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled) const
{
INC_DWORD_STAT(STAT_SlateNumPaintedWidgets);
SLATE_CYCLE_COUNTER_SCOPE_CUSTOM_DETAILED(SLATE_STATS_DETAIL_LEVEL_MED, GSlateOnPaint, GetType());
// Save the current layout cache we're associated with (if any)
LayoutCache = Args.GetLayoutCache();
// Record if we're part of a volatility pass, this is critical for ensuring we don't report a child
// of a volatile widget as non-volatile, causing the invalidation panel to do work that's not required.
bInheritedVolatility = Args.IsVolatilityPass();
// If this paint pass is to cache off our geometry, but we're a volatile widget,
// record this widget as volatile in the draw elements so that we get our own tick/paint
// pass later when the layout cache draws.
if ( Args.IsCaching() && IsVolatile() )
{
const int32 VolatileLayerId = LayerId + 1;
OutDrawElements.QueueVolatilePainting(
FSlateWindowElementList::FVolatilePaint(SharedThis(this), Args, AllottedGeometry, MyClippingRect, VolatileLayerId, InWidgetStyle, bParentEnabled));
return VolatileLayerId;
}
if ( bFoldTick && bCanTick )
{
FGeometry TickGeometry = AllottedGeometry;
TickGeometry.AppendTransform( FSlateLayoutTransform(Args.GetWindowToDesktopTransform()) );
SWidget* MutableThis = const_cast<SWidget*>(this);
MutableThis->ExecuteActiveTimers( Args.GetCurrentTime(), Args.GetDeltaTime() );
MutableThis->Tick( TickGeometry, Args.GetCurrentTime(), Args.GetDeltaTime() );
}
// Record hit test geometry, but only if we're not caching.
const FPaintArgs UpdatedArgs = Args.RecordHittestGeometry(this, AllottedGeometry, MyClippingRect);
// Paint the geometry of this widget.
int32 NewLayerID = OnPaint(UpdatedArgs, AllottedGeometry, MyClippingRect, OutDrawElements, LayerId, InWidgetStyle, bParentEnabled);
// Check if we need to show the keyboard focus ring, this is only necessary if the widget could be focused.
if ( bCanSupportFocus && SupportsKeyboardFocus() )
{
bool bShowUserFocus = FSlateApplicationBase::Get().ShowUserFocus(SharedThis(this));
if (bShowUserFocus)
{
const FSlateBrush* BrushResource = GetFocusBrush();
if (BrushResource != nullptr)
{
FSlateDrawElement::MakeBox(
OutDrawElements,
NewLayerID,
AllottedGeometry.ToPaintGeometry(),
BrushResource,
MyClippingRect,
ESlateDrawEffect::None,
BrushResource->GetTint(InWidgetStyle)
);
}
}
}
return NewLayerID;
}
