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();
}
}
const FHullShaderRHIRef& FShaderResource::GetHullShader()
{
checkSlow(Target.Frequency == SF_Hull);
if (!IsInitialized())
{
STAT(double ShaderInitializationTime = 0);
{
SCOPE_CYCLE_COUNTER(STAT_Shaders_FrameRTShaderInitForRenderingTime);
SCOPE_SECONDS_COUNTER(ShaderInitializationTime);
InitResourceFromPossiblyParallelRendering();
}
INC_FLOAT_STAT_BY(STAT_Shaders_TotalRTShaderInitForRenderingTime,(float)ShaderInitializationTime);
}
checkSlow(IsInitialized());
return HullShader;
}
void FD3D11DynamicRHI::RHIBeginDrawingViewport(FViewportRHIParamRef ViewportRHI, FTextureRHIParamRef RenderTarget)
{
DYNAMIC_CAST_D3D11RESOURCE(Viewport,Viewport);
SCOPE_CYCLE_COUNTER(STAT_D3D11PresentTime);
check(!DrawingViewport);
DrawingViewport = Viewport;
// Set the render target and viewport.
if( RenderTarget == NULL )
{
RenderTarget = Viewport->GetBackBuffer();
}
FRHIRenderTargetView View(RenderTarget);
RHISetRenderTargets(1,&View,FTextureRHIRef(),0,NULL);
// Set an initially disabled scissor rect.
RHISetScissorRect(false,0,0,0,0);
}
void UBodySetup::UpdateTriMeshVertices(const TArray<FVector> & NewPositions)
{
SCOPE_CYCLE_COUNTER(STAT_UpdateTriMeshVertices);
#if WITH_PHYSX
if (TriMeshes.Num())
{
check(TriMeshes[0] != nullptr);
PxU32 PNumVerts = TriMeshes[0]->getNbVertices(); // Get num of verts we expect
PxVec3 * PNewPositions = TriMeshes[0]->getVerticesForModification(); //we only update the first trimesh. We assume this per poly case is not updating welded trimeshes
int32 NumToCopy = FMath::Min<int32>(PNumVerts, NewPositions.Num()); // Make sure we don't write off end of array provided
for (int32 i = 0; i < NumToCopy; ++i)
{
PNewPositions[i] = U2PVector(NewPositions[i]);
}
TriMeshes[0]->refitBVH();
}
#endif
}
void FVulkanCommandListContext::RHIEndDrawIndexedPrimitiveUP()
{
SCOPE_CYCLE_COUNTER(STAT_VulkanDrawCallTime);
FVulkanBoundShaderState& Shader = PendingState->GetBoundShaderState();
PendingState->SetStreamSource(0, PendingDrawPrimUPVertexAllocInfo.GetHandle(), PendingVertexDataStride, PendingDrawPrimUPVertexAllocInfo.GetBindOffset());
FVulkanCmdBuffer* CmdBuffer = CommandBufferManager->GetActiveCmdBuffer();
VkCommandBuffer Cmd = CmdBuffer->GetHandle();
PendingState->PrepareDraw(this, CmdBuffer, UEToVulkanType((EPrimitiveType)PendingPrimitiveType));
uint32 NumIndices = GetVertexCountForPrimitiveCount(PendingNumPrimitives, PendingPrimitiveType);
VulkanRHI::vkCmdBindIndexBuffer(Cmd, PendingDrawPrimUPIndexAllocInfo.GetHandle(), PendingDrawPrimUPIndexAllocInfo.GetBindOffset(), PendingPrimitiveIndexType);
VulkanRHI::vkCmdDrawIndexed(Cmd, NumIndices, 1, PendingMinVertexIndex, 0, 0);
if (IsImmediate())
{
VulkanRHI::GManager.GPUProfilingData.RegisterGPUWork(PendingNumPrimitives, PendingNumVertices);
}
}
void FDeferredShadingSceneRenderer::SortBasePassStaticData(FVector ViewPosition)
{
// If we're not using a depth only pass, sort the static draw list buckets roughly front to back, to maximize HiZ culling
// Note that this is only a very rough sort, since it does not interfere with state sorting, and each list is sorted separately
if (EarlyZPassMode == DDM_None)
{
SCOPE_CYCLE_COUNTER(STAT_SortStaticDrawLists);
for (int32 DrawType = 0; DrawType < FScene::EBasePass_MAX; DrawType++)
{
Scene->BasePassNoLightMapDrawList[DrawType].SortFrontToBack(ViewPosition);
Scene->BasePassSimpleDynamicLightingDrawList[DrawType].SortFrontToBack(ViewPosition);
Scene->BasePassCachedVolumeIndirectLightingDrawList[DrawType].SortFrontToBack(ViewPosition);
Scene->BasePassCachedPointIndirectLightingDrawList[DrawType].SortFrontToBack(ViewPosition);
Scene->BasePassHighQualityLightMapDrawList[DrawType].SortFrontToBack(ViewPosition);
Scene->BasePassDistanceFieldShadowMapLightMapDrawList[DrawType].SortFrontToBack(ViewPosition);
Scene->BasePassLowQualityLightMapDrawList[DrawType].SortFrontToBack(ViewPosition);
}
}
}
void FVulkanCommandListContext::RHIDrawPrimitive(uint32 PrimitiveType, uint32 BaseVertexIndex, uint32 NumPrimitives, uint32 NumInstances)
{
check(Device);
SCOPE_CYCLE_COUNTER(STAT_VulkanDrawCallTime);
FVulkanBoundShaderState& BSS = PendingState->GetBoundShaderState();
uint32 NumVertices = GetVertexCountForPrimitiveCount(NumPrimitives, PrimitiveType);
FVulkanCmdBuffer* CmdBuffer = CommandBufferManager->GetActiveCmdBuffer();
PendingState->PrepareDraw(this, CmdBuffer, UEToVulkanType((EPrimitiveType)PrimitiveType));
NumInstances = FMath::Max(1U, NumInstances);
VulkanRHI::vkCmdDraw(CmdBuffer->GetHandle(), NumVertices, NumInstances, BaseVertexIndex, 0);
//if (IsImmediate())
{
VulkanRHI::GManager.GPUProfilingData.RegisterGPUWork(NumPrimitives * NumInstances, NumVertices * NumInstances);
}
}
void APlayerCameraManager::UpdateCamera(float DeltaTime)
{
if ((PCOwner->Player && PCOwner->IsLocalPlayerController()) || !bUseClientSideCameraUpdates || bDebugClientSideCamera)
{
DoUpdateCamera(DeltaTime);
if (bShouldSendClientSideCameraUpdate && IsNetMode(NM_Client))
{
SCOPE_CYCLE_COUNTER(STAT_ServerUpdateCamera);
// compress the rotation down to 4 bytes
int32 const ShortYaw = FRotator::CompressAxisToShort(CameraCache.POV.Rotation.Yaw);
int32 const ShortPitch = FRotator::CompressAxisToShort(CameraCache.POV.Rotation.Pitch);
int32 const CompressedRotation = (ShortYaw << 16) | ShortPitch;
PCOwner->ServerUpdateCamera(CameraCache.POV.Location, CompressedRotation);
bShouldSendClientSideCameraUpdate = false;
}
}
}
void FPhysXCPUDispatcherSingleThread::submitTask( PxBaseTask& Task )
{
SCOPE_CYCLE_COUNTER(STAT_PhysXSingleThread);
check(IsInGameThread());
TaskStack.Push(&Task);
if (TaskStack.Num() > 1)
{
return;
}
Task.run();
Task.release();
while (TaskStack.Num() > 1)
{
PxBaseTask& ChildTask = *TaskStack.Pop();
ChildTask.run();
ChildTask.release();
}
verify(&Task == TaskStack.Pop() && !TaskStack.Num());
}
FGameplayTagContainer FGameplayTagContainer::Filter(const FGameplayTagContainer& OtherContainer, TEnumAsByte<EGameplayTagMatchType::Type> TagMatchType, TEnumAsByte<EGameplayTagMatchType::Type> OtherTagMatchType) const
{
SCOPE_CYCLE_COUNTER(STAT_FGameplayTagContainer_Filter);
FGameplayTagContainer ResultContainer;
UGameplayTagsManager& TagManager = IGameplayTagsModule::GetGameplayTagsManager();
for (TArray<FGameplayTag>::TConstIterator OtherIt(OtherContainer.GameplayTags); OtherIt; ++OtherIt)
{
for (TArray<FGameplayTag>::TConstIterator It(this->GameplayTags); It; ++It)
{
if (TagManager.GameplayTagsMatch(*It, TagMatchType, *OtherIt, OtherTagMatchType) == true)
{
ResultContainer.AddTag(*It);
}
}
}
return ResultContainer;
}
void UGameEngine::RedrawViewports( bool bShouldPresent /*= true*/ )
{
SCOPE_CYCLE_COUNTER(STAT_RedrawViewports);
if ( GameViewport != NULL )
{
GameViewport->LayoutPlayers();
if ( GameViewport->Viewport != NULL )
{
GameViewport->Viewport->Draw(bShouldPresent);
}
}
// render the secondary viewports
checkSlow(SecondaryViewportClients.Num() == SecondaryViewportFrames.Num());
for (int32 SecondaryIndex = 0; SecondaryIndex < SecondaryViewportFrames.Num(); SecondaryIndex++)
{
SecondaryViewportFrames[SecondaryIndex]->GetViewport()->Draw(bShouldPresent);
}
}
int32 FServiceConnection::FindOrAddThread(const FStatNameAndInfo& Thread)
{
SCOPE_CYCLE_COUNTER(STAT_PC_FindOrAddThread);
// The description of a thread group contains the thread id
const FString Desc = Thread.GetDescription();
const uint32 ThreadID = FStatsUtils::ParseThreadID( Desc );
const FName ShortName = Thread.GetShortName();
// add to the meta data
FScopeLock ScopeLock( &CriticalSection );
const int32 OldNum = MetaData.ThreadDescriptions.Num();
MetaData.ThreadDescriptions.Add( ThreadID, ShortName.ToString() );
const int32 NewNum = MetaData.ThreadDescriptions.Num();
// meta data has been updated
CurrentData.MetaDataUpdated = CurrentData.MetaDataUpdated || OldNum != NewNum;
return ThreadID;
}
void FMixerSource::Update()
{
SCOPE_CYCLE_COUNTER(STAT_AudioUpdateSources);
if (!WaveInstance || !MixerSourceVoice || Paused || !bInitialized)
{
return;
}
UpdatePitch();
UpdateVolume();
UpdateSpatialization();
UpdateEffects();
UpdateChannelMaps();
FSoundSource::DrawDebugInfo();
}
void UTimelineComponent::TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction)
{
SCOPE_CYCLE_COUNTER(STAT_TimelineCompTick);
Super::TickComponent(DeltaTime, TickType, ThisTickFunction);
if (bIsActive)
{
TheTimeline.TickTimeline(DeltaTime);
if (!IsNetSimulating())
{
// Do not deactivate if we are done, since bActive is a replicated property and we shouldn't have simulating
// clients touch replicated variables.
if (!TheTimeline.IsPlaying())
{
Deactivate();
}
}
}
}
void FOnlineVoiceSteam::Tick(float DeltaTime)
{
SCOPE_CYCLE_COUNTER(STAT_Voice_Interface);
// If we aren't in a networked match, no need to update networked voice
if (SessionInt && SessionInt->GetNumSessions() > 0)
{
// Processing voice data only valid with a voice engine to capture/play
if (VoiceEngine.IsValid())
{
VoiceEngine->Tick(DeltaTime);
// Queue local packets for sending via the network
ProcessLocalVoicePackets();
// Submit queued packets to audio system
ProcessRemoteVoicePackets();
// Fire off any talking notifications for hud display
ProcessTalkingDelegates(DeltaTime);
}
}
}
/**
* Submit the relevant audio buffers to the system
*/
void FCoreAudioSoundSource::SubmitPCMRTBuffers( void )
{
SCOPE_CYCLE_COUNTER( STAT_AudioSubmitBuffersTime );
FMemory::Memzero( CoreAudioBuffers, sizeof( CoreAudioBuffer ) * 2 );
bStreamedSound = true;
// Set up double buffer area to decompress to
CoreAudioBuffers[0].AudioData = ( uint8* )FMemory::Malloc( MONO_PCM_BUFFER_SIZE * Buffer->NumChannels );
CoreAudioBuffers[0].AudioDataSize = MONO_PCM_BUFFER_SIZE * Buffer->NumChannels;
CoreAudioBuffers[1].AudioData = ( uint8* )FMemory::Malloc( MONO_PCM_BUFFER_SIZE * Buffer->NumChannels );
CoreAudioBuffers[1].AudioDataSize = MONO_PCM_BUFFER_SIZE * Buffer->NumChannels;
NumActiveBuffers = 0;
BufferInUse = 0;
ReadMorePCMData(0);
ReadMorePCMData(1);
}
void USignificanceManager::UnregisterObject(const UObject* Object)
{
DEC_DWORD_STAT(STAT_SignificanceManager_NumObjects);
SCOPE_CYCLE_COUNTER(STAT_SignificanceManager_UnregisterObject);
FManagedObjectInfo* ObjectInfo;
if (ManagedObjects.RemoveAndCopyValue(Object, ObjectInfo))
{
TArray<const FManagedObjectInfo*>& ObjectsWithTag = ManagedObjectsByTag.FindChecked(ObjectInfo->GetTag());
if (ObjectsWithTag.Num() == 1)
{
check(ObjectsWithTag[0] == ObjectInfo);
ManagedObjectsByTag.Remove(ObjectInfo->GetTag());
}
else
{
ObjectsWithTag.RemoveSingle(ObjectInfo);
}
delete ObjectInfo;
}
}
void FOutputDeviceRedirector::PanicFlushThreadedLogs()
{
SCOPE_CYCLE_COUNTER(STAT_FlushThreadedLogs);
// Acquire a lock on SynchronizationObject and call the unsynchronized worker function.
FScopeLock ScopeLock( &SynchronizationObject );
// Flush threaded logs, but use the safe version.
UnsynchronizedFlushThreadedLogs( false );
// Flush devices.
for (int32 OutputDeviceIndex = 0; OutputDeviceIndex<OutputDevices.Num(); OutputDeviceIndex++)
{
FOutputDevice* OutputDevice = OutputDevices[OutputDeviceIndex];
if (OutputDevice->CanBeUsedOnAnyThread())
{
OutputDevice->Flush();
}
}
BufferedLines.Empty();
}
void FSlateRHIRenderingPolicy::UpdateVertexAndIndexBuffers(FRHICommandListImmediate& RHICmdList, FSlateBatchData& InBatchData)
{
SCOPE_CYCLE_COUNTER( STAT_SlateUpdateBufferRTTime );
// Should only be called by the rendering thread
check(IsInRenderingThread());
const int32 NumVertices = InBatchData.GetNumBatchedVertices();
const int32 NumIndices = InBatchData.GetNumBatchedIndices();
if( InBatchData.GetRenderBatches().Num() > 0 && NumVertices > 0 && NumIndices > 0)
{
TSlateElementVertexBuffer<FSlateVertex>& VertexBuffer = VertexBuffers[CurrentBufferIndex];
FSlateElementIndexBuffer& IndexBuffer = IndexBuffers[CurrentBufferIndex];
bool bShouldShrinkResources = false;
VertexBuffer.PreFillBuffer(NumVertices, bShouldShrinkResources);
IndexBuffer.PreFillBuffer(NumIndices, bShouldShrinkResources);
if(!GRHIThread || RHICmdList.Bypass())
{
uint8* VertexBufferData = (uint8*)VertexBuffer.LockBuffer_RenderThread(NumVertices);
uint8* IndexBufferData = (uint8*)IndexBuffer.LockBuffer_RenderThread(NumIndices);
InBatchData.FillVertexAndIndexBuffer( VertexBufferData, IndexBufferData );
VertexBuffer.UnlockBuffer_RenderThread();
IndexBuffer.UnlockBuffer_RenderThread();
}
else
{
new (RHICmdList.AllocCommand<FSlateUpdateVertexAndIndexBuffers>()) FSlateUpdateVertexAndIndexBuffers(VertexBuffer, IndexBuffer, InBatchData);
}
}
SET_DWORD_STAT( STAT_SlateNumLayers, InBatchData.GetNumLayers() );
SET_DWORD_STAT( STAT_SlateNumBatches, InBatchData.GetRenderBatches().Num() );
SET_DWORD_STAT( STAT_SlateVertexCount, InBatchData.GetNumBatchedVertices() );
}
void UPoseableMeshComponent::RefreshBoneTransforms(FActorComponentTickFunction* TickFunction)
{
SCOPE_CYCLE_COUNTER(STAT_RefreshBoneTransforms);
// Can't do anything without a SkeletalMesh
if( !SkeletalMesh )
{
return;
}
// Do nothing more if no bones in skeleton.
if( GetNumSpaceBases() == 0 )
{
return;
}
// We need the mesh space bone transforms now for renderer to get delta from ref pose:
FillSpaceBases();
FlipEditableSpaceBases();
MarkRenderDynamicDataDirty();
}
void UAvoidanceManager::RemoveOutdatedObjects()
{
SCOPE_CYCLE_COUNTER(STAT_AI_ObstacleAvoidance);
bRequestedUpdateTimer = false;
//Update RVO stuff. Mainly, this involves removing outdated RVO entries.
bool bHasActiveObstacles = false;
for (auto& AvoidanceObj : AvoidanceObjects)
{
FNavAvoidanceData& AvoidanceData = AvoidanceObj.Value;
if (AvoidanceData.RemainingTimeToLive > (DefaultTimeToLive * 0.5f))
{
//Update record with reduced TTL
AvoidanceData.RemainingTimeToLive -= (DefaultTimeToLive * 0.5f);
bHasActiveObstacles = true;
}
else if (!AvoidanceData.ShouldBeIgnored())
{
const int32 ObjectId = AvoidanceObj.Key;
AvoidanceData.RemainingTimeToLive = 0.0f;
//Expired, not in pool yet, assign to pool
//DrawDebugLine(GetWorld(), AvoidanceData.Center, AvoidanceData.Center + FVector(0,0,500), FColor(64,255,64), true, 2.0f, SDPG_MAX, 20.0f);
NewKeyPool.AddUnique(ObjectId);
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
if (DebugUIDs.Contains(ObjectId))
{
DebugUIDs.Remove(ObjectId);
}
#endif
}
}
if (bHasActiveObstacles)
{
RequestUpdateTimer();
}
}
void UAnimInstance::BlendSequences(const FA2Pose& Pose1, const FA2Pose& Pose2, float Alpha, FA2Pose& Result)
{
SCOPE_CYCLE_COUNTER(STAT_AnimNativeBlendPoses);
const FTransformArrayA2* Children[2];
float Weights[2];
Children[0] = &(Pose1.Bones);
Children[1] = &(Pose2.Bones);
Alpha = FMath::Clamp<float>(Alpha, 0.0f, 1.0f);
Weights[0] = 1.0f - Alpha;
Weights[1] = Alpha;
if (Result.Bones.Num() < Pose1.Bones.Num())
{
ensureMsg (false, TEXT("Source Pose has more bones than Target Pose"));
//@hack
Result.Bones.AddUninitialized(Pose1.Bones.Num() - Result.Bones.Num());
}
FAnimationRuntime::BlendPosesTogether(2, Children, Weights, RequiredBones, /*out*/ Result.Bones);
}
void UAISense_Sight::OnListenerUpdateImpl(const FPerceptionListener& UpdatedListener)
{
SCOPE_CYCLE_COUNTER(STAT_AI_Sense_Sight_ListenerUpdate);
// first, naive implementation:
// 1. remove all queries by this listener
// 2. proceed as if it was a new listener
// remove all queries
RemoveAllQueriesByListener(UpdatedListener, DontSort);
// see if this listener is a Target as well
const FAISightTarget::FTargetId AsTargetId = UpdatedListener.GetBodyActorName();
FAISightTarget* AsTarget = ObservedTargets.Find(AsTargetId);
if (AsTarget != NULL)
{
RemoveAllQueriesToTarget(AsTargetId, DontSort);
if (AsTarget->Target.IsValid())
{
RegisterTarget(*(AsTarget->Target.Get()), DontSort);
}
}
const FPerceptionListenerID ListenerID = UpdatedListener.GetListenerID();
if (UpdatedListener.HasSense(GetSenseID()))
{
const UAISenseConfig_Sight* SenseConfig = Cast<const UAISenseConfig_Sight>(UpdatedListener.Listener->GetSenseConfig(GetSenseID()));
check(SenseConfig);
FDigestedSightProperties& PropertiesDigest = DigestedProperties.FindOrAdd(ListenerID);
PropertiesDigest = FDigestedSightProperties(*SenseConfig);
GenerateQueriesForListener(UpdatedListener, PropertiesDigest);
}
else
{
DigestedProperties.FindAndRemoveChecked(ListenerID);
}
}
void FVulkanCommandListContext::RHIDrawIndexedPrimitiveIndirect(uint32 PrimitiveType,FIndexBufferRHIParamRef IndexBufferRHI,FVertexBufferRHIParamRef ArgumentBufferRHI,uint32 ArgumentOffset)
{
check(Device);
SCOPE_CYCLE_COUNTER(STAT_VulkanDrawCallTime);
#if 0
//@NOTE: don't prepare draw without actually drawing
#if !PLATFORM_ANDROID
PendingState->PrepareDraw(UEToVulkanType((EPrimitiveType)PrimitiveType));
FVulkanIndexBuffer* IndexBuffer = ResourceCast(IndexBufferRHI);
#if 0
FVulkanVertexBuffer* ArgumentBuffer = ResourceCast(ArgumentBufferRHI);
#endif
#endif
#endif
VULKAN_SIGNAL_UNIMPLEMENTED();
if (IsImmediate())
{
VulkanRHI::GManager.GPUProfilingData.RegisterGPUWork(0);
}
}
void FOpenGLDynamicRHI::RHIBeginDrawingViewport(FViewportRHIParamRef ViewportRHI, FTextureRHIParamRef RenderTarget)
{
VERIFY_GL_SCOPE();
FOpenGLViewport* Viewport = ResourceCast(ViewportRHI);
SCOPE_CYCLE_COUNTER(STAT_OpenGLPresentTime);
check(!DrawingViewport);
DrawingViewport = Viewport;
bRevertToSharedContextAfterDrawingViewport = false;
EOpenGLCurrentContext CurrentContext = PlatformOpenGLCurrentContext( PlatformDevice );
if( CurrentContext != CONTEXT_Rendering )
{
check(CurrentContext == CONTEXT_Shared);
check(!bIsRenderingContextAcquired || !GUseThreadedRendering);
bRevertToSharedContextAfterDrawingViewport = true;
PlatformRenderingContextSetup(PlatformDevice);
}
if(!GPUProfilingData.FrameTiming.IsInitialized())
{
GPUProfilingData.FrameTiming.InitResource();
}
// Set the render target and viewport.
if( RenderTarget )
{
FRHIRenderTargetView RTV(RenderTarget);
RHISetRenderTargets(1, &RTV, nullptr, 0, NULL);
}
else
{
FRHIRenderTargetView RTV(DrawingViewport->GetBackBuffer());
RHISetRenderTargets(1, &RTV, nullptr, 0, NULL);
}
}
uint32 FogWorker::Run()
{
while(!bIsTaskStopped)
{
FPlatformProcess::Sleep(0.1f);
if(Manager.bHasFOWTextureUpdate)
{
continue;
}
SCOPE_CYCLE_COUNTER(STAT_FogUpdatesCount);
auto world = Manager.GetWorld();
if(world)
{
auto delta = world->TimeSince(TimeTillLastTick);
Update(delta);
TimeTillLastTick = world->TimeSeconds;
}
}
return 0;
}
int32 SBox::OnPaint( const FPaintArgs& Args, const FGeometry& AllottedGeometry, const FSlateRect& MyClippingRect, FSlateWindowElementList& OutDrawElements, int32 LayerId, const FWidgetStyle& InWidgetStyle, bool bParentEnabled ) const
{
// An SBox just draws its only child
FArrangedChildren ArrangedChildren(EVisibility::Visible);
{
#if SLATE_HD_STATS
SCOPE_CYCLE_COUNTER( STAT_SlateOnPaint_SBox );
#endif
this->ArrangeChildren(AllottedGeometry, ArrangedChildren);
}
// Maybe none of our children are visible
if( ArrangedChildren.Num() > 0 )
{
check( ArrangedChildren.Num() == 1 );
FArrangedWidget& TheChild = ArrangedChildren[0];
const FSlateRect ChildClippingRect = AllottedGeometry.GetClippingRect().InsetBy( ChildSlot.SlotPadding.Get() * AllottedGeometry.Scale ).IntersectionWith(MyClippingRect);
return TheChild.Widget->Paint( Args.WithNewParent(this), TheChild.Geometry, ChildClippingRect, OutDrawElements, LayerId, InWidgetStyle, ShouldBeEnabled( bParentEnabled ) );
}
return LayerId;
}
void UAIPerceptionSystem::PerformSourceRegistration()
{
SCOPE_CYCLE_COUNTER(STAT_AI_PerceptionSys);
for (const auto& PercSource : SourcesToRegister)
{
AActor* SourceActor = PercSource.Source.Get();
if (SourceActor != nullptr && SourceActor->IsPendingKillPending() == false)
{
Senses[PercSource.SenseID]->RegisterSource(*SourceActor);
// hook into notification about actor's EndPlay to remove it as a source
SourceActor->OnEndPlay.AddUnique(StimuliSourceEndPlayDelegate);
// store information we have this actor as given sense's source
FPerceptionStimuliSource& StimuliSource = RegisteredStimuliSources.FindOrAdd(SourceActor);
StimuliSource.SourceActor = SourceActor;
StimuliSource.RelevantSenses.AcceptChannel(PercSource.SenseID);
}
}
SourcesToRegister.Reset();
}
void FVulkanCommandListContext::RHIBeginDrawIndexedPrimitiveUP( uint32 PrimitiveType, uint32 NumPrimitives, uint32 NumVertices, uint32 VertexDataStride,
void*& OutVertexData, uint32 MinVertexIndex, uint32 NumIndices, uint32 IndexDataStride, void*& OutIndexData)
{
SCOPE_CYCLE_COUNTER(STAT_VulkanUPPrepTime);
bool bAllocatedVB = TempFrameAllocationBuffer.Alloc(VertexDataStride * NumVertices, IndexDataStride, PendingDrawPrimUPVertexAllocInfo);
check(bAllocatedVB);
OutVertexData = PendingDrawPrimUPVertexAllocInfo.Data;
check(IndexDataStride == 2 || IndexDataStride == 4);
PendingPrimitiveIndexType = IndexDataStride == 2 ? VK_INDEX_TYPE_UINT16 : VK_INDEX_TYPE_UINT32;
bool bAllocatedIB = TempFrameAllocationBuffer.Alloc(IndexDataStride * NumIndices, IndexDataStride, PendingDrawPrimUPIndexAllocInfo);
check(bAllocatedIB);
OutIndexData = PendingDrawPrimUPIndexAllocInfo.Data;
PendingPrimitiveType = PrimitiveType;
PendingNumPrimitives = NumPrimitives;
PendingMinVertexIndex = MinVertexIndex;
PendingIndexDataStride = IndexDataStride;
PendingNumVertices = NumVertices;
PendingVertexDataStride = VertexDataStride;
}
void FDeferredShadingSceneRenderer::ClearLPVs()
{
// clear light propagation volumes
for(int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
{
FViewInfo& View = Views[ViewIndex];
FSceneViewState* ViewState = (FSceneViewState*)Views[ViewIndex].State;
if(ViewState)
{
FLightPropagationVolume* LightPropagationVolume = ViewState->GetLightPropagationVolume();
if(LightPropagationVolume)
{
SCOPED_DRAW_EVENT(ClearLPVs, DEC_SCENE_ITEMS);
SCOPE_CYCLE_COUNTER(STAT_UpdateLPVs);
LightPropagationVolume->InitSettings(Views[ViewIndex]);
LightPropagationVolume->Clear();
}
}
}
}
