A Demo Project for the UnrealEngineSDK
Loading...
Searching...
No Matches
CollisionIgnoreSubsystem.cpp
Go to the documentation of this file.
1// Copyright 1998-2016 Epic Games, Inc. All Rights Reserved.
2
3#include "Misc/CollisionIgnoreSubsystem.h"
4#include "Components/SkeletalMeshComponent.h"
5#include "Runtime/Engine/Classes/Kismet/GameplayStatics.h"
6
7DEFINE_LOG_CATEGORY(VRE_CollisionIgnoreLog);
8
9
10void UCollisionIgnoreSubsystem::CheckActiveFilters()
11{
12
13 bool bDoubleCheckPairs = false;
14 for (const TPair<FCollisionPrimPair, FCollisionIgnorePairArray>& KeyPair : CollisionTrackedPairs)
15 {
16 // First check for invalid primitives
17 if (!KeyPair.Key.Prim1.IsValid() || !KeyPair.Key.Prim2.IsValid() /*|| KeyPair.Key.Prim1->IsPendingKill() || KeyPair.Key.Prim2->IsPendingKill()*/)
18 {
19 // If we don't have a map element for this pair, then add it now
20 if (!RemovedPairs.Contains(KeyPair.Key))
21 {
22 RemovedPairs.Add(KeyPair.Key, KeyPair.Value);
23 }
24 /*else
25 {
26 RemovedPairs[KeyPair.Key].PairArray.AddUnique(KeyPair.Value);
27 }*/
28
29 continue; // skip remaining checks as we have invalid primitives anyway
30 }
31
32 // Now check for lost physics handles
33 // Implement later
34 /*for (const FCollisionIgnorePair& IgnorePair : KeyPair.Value.PairArray)
35 {
36 if (
37 (!IgnorePair.Actor1.IsValid() || !FPhysicsInterface::IsValid(IgnorePair.Actor1)) ||
38 (!IgnorePair.Actor2.IsValid() || !FPhysicsInterface::IsValid(IgnorePair.Actor2))
39 )
40 {
41 // Reinit the ignoring, one of the handles got lost
42 // TODO
43 //
44 InitiateIgnore();
45
46 bDoubleCheckPairs = true;
47 }
48 }*/
49 }
50
51/*#if WITH_CHAOS
52 if (FPhysScene* PhysScene2 = GetWorld()->GetPhysicsScene())
53 {
54 Chaos::FIgnoreCollisionManager& IgnoreCollisionManager = PhysScene2->GetSolver()->GetEvolution()->GetBroadPhase().GetIgnoreCollisionManager();
55 int32 ExternalTimestamp = PhysScene2->GetSolver()->GetMarshallingManager().GetExternalTimestamp_External();
56 Chaos::FIgnoreCollisionManager::FPendingMap& ActivationMap = IgnoreCollisionManager.GetPendingDeactivationsForGameThread(ExternalTimestamp)
57 GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("Pending deactivation Chaos: %i"), ActivationMap.Num()));
58 }
59#endif*/
60
61 if (RemovedPairs.Num() > 0 || bDoubleCheckPairs == true)
62 {
63 if (FPhysScene* PhysScene = GetWorld()->GetPhysicsScene())
64 {
65#if WITH_CHAOS
66 // I think chaos may handle this itself here, i need to double check
67
68#elif PHYSICS_INTERFACE_PHYSX
69 if (PxScene* PScene = PhysScene->GetPxScene())
70 {
71 // Lock the scene since we are getting Callbacks
72 PScene->lockWrite();
73
74 if (FCCDContactModifyCallbackVR* ContactCallback = (FCCDContactModifyCallbackVR*)PScene->getCCDContactModifyCallback())
75 {
76 FRWScopeLock(ContactCallback->RWAccessLock, FRWScopeLockType::SLT_Write);
77
78 for (int i = ContactCallback->ContactsToIgnore.Num() - 1; i >= 0; --i)
79 {
80 if (
81 (!ContactCallback->ContactsToIgnore[i].Prim1.IsValid() || !ContactCallback->ContactsToIgnore[i].Prim2.IsValid()) ||
82 (!ContactCallback->ContactsToIgnore[i].Actor1.IsValid() || !FPhysicsInterface::IsValid(ContactCallback->ContactsToIgnore[i].Actor1)) ||
83 (!ContactCallback->ContactsToIgnore[i].Actor2.IsValid() || !FPhysicsInterface::IsValid(ContactCallback->ContactsToIgnore[i].Actor2))
84 )
85 {
86 ContactCallback->ContactsToIgnore.RemoveAt(i);
87 }
88 }
89
90 //GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("CCD IGNORE: %i"), ContactCallback->ContactsToIgnore.Num()));
91 }
92
93 if (FContactModifyCallbackVR* ContactCallback = (FContactModifyCallbackVR*)PScene->getContactModifyCallback())
94 {
95 FRWScopeLock(ContactCallback->RWAccessLock, FRWScopeLockType::SLT_Write);
96
97 for (int i = ContactCallback->ContactsToIgnore.Num() - 1; i >= 0; --i)
98 {
99 if (
100 (!ContactCallback->ContactsToIgnore[i].Prim1.IsValid() || !ContactCallback->ContactsToIgnore[i].Prim2.IsValid()) ||
101 (!ContactCallback->ContactsToIgnore[i].Actor1.IsValid() || !FPhysicsInterface::IsValid(ContactCallback->ContactsToIgnore[i].Actor1)) ||
102 (!ContactCallback->ContactsToIgnore[i].Actor2.IsValid() || !FPhysicsInterface::IsValid(ContactCallback->ContactsToIgnore[i].Actor2))
103 )
104 {
105 ContactCallback->ContactsToIgnore.RemoveAt(i);
106 }
107 }
108
109 //GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("IGNORE: %i"), ContactCallback->ContactsToIgnore.Num()));
110 }
111
112 // UnLock the scene since we are getting Callbacks
113 PScene->unlockWrite();
114 }
115#endif
116 }
117 }
118
119 for (const TPair<FCollisionPrimPair, FCollisionIgnorePairArray>& KeyPair : RemovedPairs)
120 {
121 if (CollisionTrackedPairs.Contains(KeyPair.Key))
122 {
123 CollisionTrackedPairs[KeyPair.Key].PairArray.Empty();
124 CollisionTrackedPairs.Remove(KeyPair.Key);
125 }
126 }
127
128 //GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, FString::Printf(TEXT("NumIgnored Actors: %i"), CollisionTrackedPairs.Num()));
129
130 UpdateTimer();
131}
132
133void UCollisionIgnoreSubsystem::RemoveComponentCollisionIgnoreState(UPrimitiveComponent* Prim1)
134{
135
136 if (!Prim1)
137 return;
138
139 for (const TPair<FCollisionPrimPair, FCollisionIgnorePairArray>& KeyPair : CollisionTrackedPairs)
140 {
141 // First check for invalid primitives
142 if (KeyPair.Key.Prim1 == Prim1 || KeyPair.Key.Prim2 == Prim1)
143 {
144 // If we don't have a map element for this pair, then add it now
145 if (!RemovedPairs.Contains(KeyPair.Key))
146 {
147 RemovedPairs.Add(KeyPair.Key, KeyPair.Value);
148 }
149 }
150 }
151
152 if (RemovedPairs.Num() > 0)
153 {
154 if (FPhysScene* PhysScene = GetWorld()->GetPhysicsScene())
155 {
156#if WITH_CHAOS
157 // I think chaos may handle this itself here, i need to double check
158
159#elif PHYSICS_INTERFACE_PHYSX
160 if (PxScene* PScene = PhysScene->GetPxScene())
161 {
162 // Lock the scene since we are getting Callbacks
163 PScene->lockWrite();
164
165 if (FCCDContactModifyCallbackVR* ContactCallback = (FCCDContactModifyCallbackVR*)PScene->getCCDContactModifyCallback())
166 {
167 FRWScopeLock(ContactCallback->RWAccessLock, FRWScopeLockType::SLT_Write);
168
169 for (int i = ContactCallback->ContactsToIgnore.Num() - 1; i >= 0; --i)
170 {
171 if (ContactCallback->ContactsToIgnore[i].Prim1 == Prim1 || ContactCallback->ContactsToIgnore[i].Prim2 == Prim1)
172 {
173 ContactCallback->ContactsToIgnore.RemoveAt(i);
174 }
175 }
176 }
177
178 if (FContactModifyCallbackVR* ContactCallback = (FContactModifyCallbackVR*)PScene->getContactModifyCallback())
179 {
180 FRWScopeLock(ContactCallback->RWAccessLock, FRWScopeLockType::SLT_Write);
181
182 for (int i = ContactCallback->ContactsToIgnore.Num() - 1; i >= 0; --i)
183 {
184 if (ContactCallback->ContactsToIgnore[i].Prim1 == Prim1 || ContactCallback->ContactsToIgnore[i].Prim2 == Prim1)
185 {
186 ContactCallback->ContactsToIgnore.RemoveAt(i);
187 }
188 }
189 }
190
191 // UnLock the scene since we are getting Callbacks
192 PScene->unlockWrite();
193 }
194#endif
195 }
196 }
197
198 for (const TPair<FCollisionPrimPair, FCollisionIgnorePairArray>& KeyPair : RemovedPairs)
199 {
200 if (CollisionTrackedPairs.Contains(KeyPair.Key))
201 {
202 CollisionTrackedPairs[KeyPair.Key].PairArray.Empty();
203 CollisionTrackedPairs.Remove(KeyPair.Key);
204 }
205 }
206
207 UpdateTimer();
208}
209
210bool UCollisionIgnoreSubsystem::IsComponentIgnoringCollision(UPrimitiveComponent* Prim1)
211{
212
213 if (!Prim1)
214 return false;
215
216 for (const TPair<FCollisionPrimPair, FCollisionIgnorePairArray>& KeyPair : CollisionTrackedPairs)
217 {
218 // First check for invalid primitives
219 if (KeyPair.Key.Prim1 == Prim1 || KeyPair.Key.Prim2 == Prim1)
220 {
221 return true;
222 }
223 }
224
225 return false;
226}
227
228bool UCollisionIgnoreSubsystem::AreComponentsIgnoringCollisions(UPrimitiveComponent* Prim1, UPrimitiveComponent* Prim2)
229{
230
231 if (!Prim1 || !Prim2)
232 return false;
233
234 TSet<FCollisionPrimPair> CurrentKeys;
235 int numKeys = CollisionTrackedPairs.GetKeys(CurrentKeys);
236
237 FCollisionPrimPair SearchPair;
238 SearchPair.Prim1 = Prim1;
239 SearchPair.Prim2 = Prim2;
240
241 // This checks if we exist already as well as provides an index
242 if (FCollisionPrimPair* ExistingPair = CurrentKeys.Find(SearchPair))
243 {
244 // These components are ignoring collision
245 return true;
246 }
247
248 return false;
249}
250
255
260
261void UCollisionIgnoreSubsystem::SetComponentCollisionIgnoreState(bool bIterateChildren1, bool bIterateChildren2, UPrimitiveComponent* Prim1, FName OptionalBoneName1, UPrimitiveComponent* Prim2, FName OptionalBoneName2, bool bIgnoreCollision, bool bCheckFilters)
262{
263 if (!Prim1 || !Prim2)
264 {
265 UE_LOG(VRE_CollisionIgnoreLog, Error, TEXT("Set Objects Ignore Collision called with invalid object(s)!!"));
266 return;
267 }
268
269 if (Prim1->GetCollisionEnabled() == ECollisionEnabled::NoCollision || Prim2->GetCollisionEnabled() == ECollisionEnabled::NoCollision)
270 {
271 UE_LOG(VRE_CollisionIgnoreLog, Error, TEXT("Set Objects Ignore Collision called with one or more objects with no collision!! %s, %s"), *Prim1->GetName(), *Prim2->GetName());
272 return;
273 }
274
275 if (Prim1->Mobility == EComponentMobility::Static || Prim2->Mobility == EComponentMobility::Static)
276 {
277 UE_LOG(VRE_CollisionIgnoreLog, Error, TEXT("Set Objects Ignore Collision called with at least one static mobility object (cannot ignore collision with it)!!"));
278 if (bIgnoreCollision)
279 {
280 return;
281 }
282 }
283
284 USkeletalMeshComponent* SkeleMesh = nullptr;
285 USkeletalMeshComponent* SkeleMesh2 = nullptr;
286
287 if (bIterateChildren1)
288 {
289 SkeleMesh = Cast<USkeletalMeshComponent>(Prim1);
290 }
291
292 if (bIterateChildren2)
293 {
294 SkeleMesh2 = Cast<USkeletalMeshComponent>(Prim2);
295 }
296
297 struct BodyPairStore
298 {
299 FBodyInstance* BInstance;
300 FName BName;
301
302 BodyPairStore(FBodyInstance* BI, FName BoneName)
303 {
304 BInstance = BI;
305 BName = BoneName;
306 }
307 };
308
309 TArray<BodyPairStore> ApplicableBodies;
310
311 if (SkeleMesh)
312 {
313 UPhysicsAsset* PhysAsset = SkeleMesh ? SkeleMesh->GetPhysicsAsset() : nullptr;
314 if (PhysAsset)
315 {
316 int32 NumBodiesFound = SkeleMesh->ForEachBodyBelow(OptionalBoneName1, true, false, [PhysAsset, &ApplicableBodies](FBodyInstance* BI)
317 {
318 const FName IterBodyName = PhysAsset->SkeletalBodySetups[BI->InstanceBodyIndex]->BoneName;
319 ApplicableBodies.Add(BodyPairStore(BI, IterBodyName));
320 });
321 }
322 }
323 else
324 {
325 FBodyInstance* Inst1 = Prim1->GetBodyInstance(OptionalBoneName1);
326 if (Inst1)
327 {
328 ApplicableBodies.Add(BodyPairStore(Inst1, OptionalBoneName1));
329 }
330 }
331
332 TArray<BodyPairStore> ApplicableBodies2;
333 if (SkeleMesh2)
334 {
335 UPhysicsAsset* PhysAsset = SkeleMesh2 ? SkeleMesh2->GetPhysicsAsset() : nullptr;
336 if (PhysAsset)
337 {
338 int32 NumBodiesFound = SkeleMesh2->ForEachBodyBelow(OptionalBoneName2, true, false, [PhysAsset, &ApplicableBodies2](FBodyInstance* BI)
339 {
340 const FName IterBodyName = PhysAsset->SkeletalBodySetups[BI->InstanceBodyIndex]->BoneName;
341 ApplicableBodies2.Add(BodyPairStore(BI, IterBodyName));
342 });
343 }
344 }
345 else
346 {
347 FBodyInstance* Inst1 = Prim2->GetBodyInstance(OptionalBoneName2);
348 if (Inst1)
349 {
350 ApplicableBodies2.Add(BodyPairStore(Inst1, OptionalBoneName2));
351 }
352 }
353
354
355 FCollisionPrimPair newPrimPair;
356 newPrimPair.Prim1 = Prim1;
357 newPrimPair.Prim2 = Prim2;
358
359 // Check our active filters and handle inconsistencies before we run the next logic
360 // (This prevents cases where null ptrs get added too)
361 if (bCheckFilters)
362 {
363 CheckActiveFilters();
364 }
365
366 // If we don't have a map element for this pair, then add it now
367 if (bIgnoreCollision && !CollisionTrackedPairs.Contains(newPrimPair))
368 {
369 CollisionTrackedPairs.Add(newPrimPair, FCollisionIgnorePairArray());
370 }
371 else if (!bIgnoreCollision && !CollisionTrackedPairs.Contains(newPrimPair))
372 {
373 // Early out, we don't even have this pair to remove it
374 return;
375 }
376
377 for (int i = 0; i < ApplicableBodies.Num(); ++i)
378 {
379 for (int j = 0; j < ApplicableBodies2.Num(); ++j)
380 {
381 if (ApplicableBodies[i].BInstance && ApplicableBodies2[j].BInstance)
382 {
383 if (FPhysScene* PhysScene = Prim1->GetWorld()->GetPhysicsScene())
384 {
385 FContactModBodyInstancePair newContactPair;
386 newContactPair.Actor1 = ApplicableBodies[i].BInstance->ActorHandle;
387 newContactPair.Actor2 = ApplicableBodies2[j].BInstance->ActorHandle;
388 newContactPair.Prim1 = Prim1;
389 newContactPair.Prim2 = Prim2;
390
391 FCollisionIgnorePair newIgnorePair;
392 newIgnorePair.Actor1 = ApplicableBodies[i].BInstance->ActorHandle;
393 newIgnorePair.BoneName1 = ApplicableBodies[i].BName;
394 newIgnorePair.Actor2 = ApplicableBodies2[j].BInstance->ActorHandle;
395 newIgnorePair.BoneName2 = ApplicableBodies2[j].BName;
396
397#if WITH_CHAOS
398 Chaos::FUniqueIdx ID0 = ApplicableBodies[i].BInstance->ActorHandle->GetParticle_LowLevel()->UniqueIdx();
399 Chaos::FUniqueIdx ID1 = ApplicableBodies2[j].BInstance->ActorHandle->GetParticle_LowLevel()->UniqueIdx();
400
401 Chaos::FIgnoreCollisionManager& IgnoreCollisionManager = PhysScene->GetSolver()->GetEvolution()->GetBroadPhase().GetIgnoreCollisionManager();
402
403 FPhysicsCommand::ExecuteWrite(PhysScene, [&]()
404 {
405 using namespace Chaos;
406
407 if (bIgnoreCollision)
408 {
409 if (!IgnoreCollisionManager.IgnoresCollision(ID0, ID1))
410 {
411 TPBDRigidParticleHandle<FReal, 3>* ParticleHandle0 = ApplicableBodies[i].BInstance->ActorHandle->GetHandle_LowLevel()->CastToRigidParticle();
412 TPBDRigidParticleHandle<FReal, 3>* ParticleHandle1 = ApplicableBodies2[j].BInstance->ActorHandle->GetHandle_LowLevel()->CastToRigidParticle();
413
414 if (ParticleHandle0 && ParticleHandle1)
415 {
416 ParticleHandle0->AddCollisionConstraintFlag(Chaos::ECollisionConstraintFlags::CCF_BroadPhaseIgnoreCollisions);
417 IgnoreCollisionManager.AddIgnoreCollisionsFor(ID0, ID1);
418
419 ParticleHandle1->AddCollisionConstraintFlag(Chaos::ECollisionConstraintFlags::CCF_BroadPhaseIgnoreCollisions);
420 IgnoreCollisionManager.AddIgnoreCollisionsFor(ID1, ID0);
421
422 if (CollisionTrackedPairs.Contains(newPrimPair))
423 {
424 CollisionTrackedPairs[newPrimPair].PairArray.AddUnique(newIgnorePair);
425 }
426
427 /*if (ApplicableBodies[i].BInstance->bContactModification != bIgnoreCollision)
428 ApplicableBodies[i].BInstance->SetContactModification(true);
429
430 if (ApplicableBodies2[j].BInstance->bContactModification != bIgnoreCollision)
431 ApplicableBodies2[j].BInstance->SetContactModification(true);*/
432 }
433 }
434 }
435 else
436 {
437 if (IgnoreCollisionManager.IgnoresCollision(ID0, ID1))
438 {
439 TPBDRigidParticleHandle<FReal, 3>* ParticleHandle0 = ApplicableBodies[i].BInstance->ActorHandle->GetHandle_LowLevel()->CastToRigidParticle();
440 TPBDRigidParticleHandle<FReal, 3>* ParticleHandle1 = ApplicableBodies2[j].BInstance->ActorHandle->GetHandle_LowLevel()->CastToRigidParticle();
441
442 if (ParticleHandle0 && ParticleHandle1)
443 {
444 IgnoreCollisionManager.RemoveIgnoreCollisionsFor(ID0, ID1);
445 IgnoreCollisionManager.RemoveIgnoreCollisionsFor(ID1, ID0);
446
447 if (IgnoreCollisionManager.NumIgnoredCollision(ID0) < 1)
448 {
449 ParticleHandle0->RemoveCollisionConstraintFlag(Chaos::ECollisionConstraintFlags::CCF_BroadPhaseIgnoreCollisions);
450 }
451
452 if (IgnoreCollisionManager.NumIgnoredCollision(ID1) < 1)
453 {
454 ParticleHandle1->RemoveCollisionConstraintFlag(Chaos::ECollisionConstraintFlags::CCF_BroadPhaseIgnoreCollisions);
455 }
456 }
457
458 CollisionTrackedPairs[newPrimPair].PairArray.Remove(newIgnorePair);
459 if (CollisionTrackedPairs[newPrimPair].PairArray.Num() < 1)
460 {
461 CollisionTrackedPairs.Remove(newPrimPair);
462 }
463
464 // If we don't have a map element for this pair, then add it now
465 if (!RemovedPairs.Contains(newPrimPair))
466 {
467 RemovedPairs.Add(newPrimPair, FCollisionIgnorePairArray >());
468 }
469 RemovedPairs[newPrimPair].PairArray.AddUnique(newIgnorePair);
470 }
471 }
472 });
473
474#elif PHYSICS_INTERFACE_PHYSX
475 if (PxScene* PScene = PhysScene->GetPxScene())
476 {
477 // Lock the scene since we are getting Callbacks
478 PScene->lockWrite();
479
480 if (FCCDContactModifyCallbackVR* ContactCallback = (FCCDContactModifyCallbackVR*)PScene->getCCDContactModifyCallback())
481 {
482 FRWScopeLock(ContactCallback->RWAccessLock, FRWScopeLockType::SLT_Write);
483
484 if (bIgnoreCollision)
485 {
486 if (CollisionTrackedPairs.Contains(newPrimPair))
487 {
488 CollisionTrackedPairs[newPrimPair].PairArray.AddUnique(newIgnorePair);
489 }
490
491 ContactCallback->ContactsToIgnore.AddUnique(newContactPair);
492
493 if (ApplicableBodies[i].BInstance->bContactModification != bIgnoreCollision)
494 ApplicableBodies[i].BInstance->SetContactModification(true);
495
496 if (ApplicableBodies2[j].BInstance->bContactModification != bIgnoreCollision)
497 ApplicableBodies2[j].BInstance->SetContactModification(true);
498 }
499 else
500 {
501 bool bHadPrimPair = false;
502
503 ContactCallback->ContactsToIgnore.Remove(newContactPair);
504 if (CollisionTrackedPairs.Contains(newPrimPair))
505 {
506 if (CollisionTrackedPairs[newPrimPair].PairArray.Contains(newIgnorePair))
507 {
508 bHadPrimPair = true;
509 CollisionTrackedPairs[newPrimPair].PairArray.Remove(newIgnorePair);
510 }
511
512 if (CollisionTrackedPairs[newPrimPair].PairArray.Num() < 1)
513 {
514 CollisionTrackedPairs.Remove(newPrimPair);
515 }
516 }
517
518 // If we don't have a map element for this pair, then add it now
519 if (bHadPrimPair)
520 {
521 if (!RemovedPairs.Contains(newPrimPair))
522 {
523 RemovedPairs.Add(newPrimPair, FCollisionIgnorePairArray());
524 }
525 RemovedPairs[newPrimPair].PairArray.AddUnique(newIgnorePair);
526 }
527 }
528 }
529
530 if (FContactModifyCallbackVR* ContactCallback = (FContactModifyCallbackVR*)PScene->getContactModifyCallback())
531 {
532 FRWScopeLock(ContactCallback->RWAccessLock, FRWScopeLockType::SLT_Write);
533
534 if (bIgnoreCollision)
535 {
536 ContactCallback->ContactsToIgnore.AddUnique(newContactPair);
537
538 if (CollisionTrackedPairs.Contains(newPrimPair))
539 {
540 CollisionTrackedPairs[newPrimPair].PairArray.AddUnique(newIgnorePair);
541 }
542
543 if (ApplicableBodies[i].BInstance->bContactModification != bIgnoreCollision)
544 ApplicableBodies[i].BInstance->SetContactModification(true);
545
546 if (ApplicableBodies2[j].BInstance->bContactModification != bIgnoreCollision)
547 ApplicableBodies2[j].BInstance->SetContactModification(true);
548 }
549 else
550 {
551
552 bool bHadPrimPair = false;
553
554 ContactCallback->ContactsToIgnore.Remove(newContactPair);
555 if (CollisionTrackedPairs.Contains(newPrimPair))
556 {
557 if (CollisionTrackedPairs[newPrimPair].PairArray.Contains(newIgnorePair))
558 {
559 bHadPrimPair = true;
560 CollisionTrackedPairs[newPrimPair].PairArray.Remove(newIgnorePair);
561 }
562
563 if (CollisionTrackedPairs[newPrimPair].PairArray.Num() < 1)
564 {
565 CollisionTrackedPairs.Remove(newPrimPair);
566 }
567 }
568
569 // If we don't have a map element for this pair, then add it now
570 if (bHadPrimPair)
571 {
572 if (!RemovedPairs.Contains(newPrimPair))
573 {
574 RemovedPairs.Add(newPrimPair, FCollisionIgnorePairArray());
575 }
576 RemovedPairs[newPrimPair].PairArray.AddUnique(newIgnorePair);
577 }
578 }
579 }
580
581 // UnLock the scene since we are getting Callbacks
582 PScene->unlockWrite();
583 }
584#endif
585 }
586 }
587 }
588 }
589
590 // Update our timer state
591 UpdateTimer();
592}
DEFINE_LOG_CATEGORY
DEFINE_LOG_CATEGORY(VRE_CollisionIgnoreLog)
UCollisionIgnoreSubsystem::IsComponentIgnoringCollision
bool IsComponentIgnoringCollision(UPrimitiveComponent *Prim1)
Definition CollisionIgnoreSubsystem.cpp:210
UCollisionIgnoreSubsystem::CheckActiveFilters
void CheckActiveFilters()
UFUNCTION(Category = "Collision")
Definition CollisionIgnoreSubsystem.cpp:10
UCollisionIgnoreSubsystem::AreComponentsIgnoringCollisions
bool AreComponentsIgnoringCollisions(UPrimitiveComponent *Prim1, UPrimitiveComponent *Prim2)
Definition CollisionIgnoreSubsystem.cpp:228
UCollisionIgnoreSubsystem::SetComponentCollisionIgnoreState
void SetComponentCollisionIgnoreState(bool bIterateChildren1, bool bIterateChildren2, UPrimitiveComponent *Prim1, FName OptionalBoneName1, UPrimitiveComponent *Prim2, FName OptionalBoneName2, bool bIgnoreCollision, bool bCheckFilters=false)
Definition CollisionIgnoreSubsystem.cpp:261
UCollisionIgnoreSubsystem::CollisionTrackedPairs
TMap< FCollisionPrimPair, FCollisionIgnorePairArray > CollisionTrackedPairs
UPROPERTY()
Definition CollisionIgnoreSubsystem.h:147
UCollisionIgnoreSubsystem::RemovedPairs
TMap< FCollisionPrimPair, FCollisionIgnorePairArray > RemovedPairs
UPROPERTY()
Definition CollisionIgnoreSubsystem.h:153
UCollisionIgnoreSubsystem::RemoveComponentCollisionIgnoreState
void RemoveComponentCollisionIgnoreState(UPrimitiveComponent *Prim1)
Definition CollisionIgnoreSubsystem.cpp:133
FCollisionIgnorePair::Actor1
FPhysicsActorHandle Actor1
FCollisionPrimPair PrimitivePair;.
Definition CollisionIgnoreSubsystem.h:68
FCollisionPrimPair::Prim2
TWeakObjectPtr< UPrimitiveComponent > Prim2
UPROPERTY()
Definition CollisionIgnoreSubsystem.h:30
FCollisionPrimPair::Prim1
TWeakObjectPtr< UPrimitiveComponent > Prim1
UPROPERTY()
Definition CollisionIgnoreSubsystem.h:26
FContactModBodyInstancePair
Definition GrippablePhysicsReplication.h:85
FContactModBodyInstancePair::Prim1
TWeakObjectPtr< UPrimitiveComponent > Prim1
Definition GrippablePhysicsReplication.h:88
FContactModBodyInstancePair::Prim2
TWeakObjectPtr< UPrimitiveComponent > Prim2
Definition GrippablePhysicsReplication.h:89
FContactModBodyInstancePair::Actor1
FPhysicsActorHandle Actor1
Definition GrippablePhysicsReplication.h:86
FContactModBodyInstancePair::Actor2
FPhysicsActorHandle Actor2
Definition GrippablePhysicsReplication.h:87