// Copyright Epic Games, Inc. All Rights Reserved.

#include "DataWrappers/ChaosVDCollisionDataWrappers.h"
#include "DataWrappers/ChaosVDDataSerializationMacros.h"
#include "UObject/FortniteMainBranchObjectVersion.h"

#include UE_INLINE_GENERATED_CPP_BY_NAME(ChaosVDCollisionDataWrappers)

FStringView FChaosVDConstraint::WrapperTypeName = TEXT("FChaosVDConstraint");
FStringView FChaosVDParticlePairMidPhase::WrapperTypeName = TEXT("FChaosVDParticlePairMidPhase");
FStringView FChaosVDCollisionChannelsInfoContainer::WrapperTypeName = TEXT("FChaosVDCollisionChannelsInfoContainer");

bool FChaosVDContactPoint::Serialize(FArchive& Ar)
{
	CVD_SERIALIZE_STATIC_ARRAY(Ar, ShapeContactPoints);
	Ar << ShapeContactNormal;
	Ar << Phi;
	Ar << FaceIndex;
	Ar << ContactType;

	return !Ar.IsError();
}

bool FChaosVDManifoldPoint::Serialize(FArchive& Ar)
{
	EChaosVDManifoldPointFlags PackedFlags = EChaosVDManifoldPointFlags::None;

	
	// Note: When the UI is done to show the enums in the same way we show these bitfiedls as read only booleans in CVD, we can remove all
	// this macro boilerplate and just serialize the the flags directly
	if (Ar.IsLoading())
	{
		Ar << PackedFlags;
		CVD_UNPACK_BITFIELD_DATA(bDisabled, PackedFlags, EChaosVDManifoldPointFlags::Disabled);
		CVD_UNPACK_BITFIELD_DATA(bWasRestored, PackedFlags, EChaosVDManifoldPointFlags::WasRestored);
		CVD_UNPACK_BITFIELD_DATA(bWasReplaced, PackedFlags, EChaosVDManifoldPointFlags::WasReplaced);
		CVD_UNPACK_BITFIELD_DATA(bHasStaticFrictionAnchor, PackedFlags, EChaosVDManifoldPointFlags::HasStaticFrictionAnchor);
		CVD_UNPACK_BITFIELD_DATA(bIsValid, PackedFlags, EChaosVDManifoldPointFlags::IsValid);
		CVD_UNPACK_BITFIELD_DATA(bInsideStaticFrictionCone, PackedFlags, EChaosVDManifoldPointFlags::InsideStaticFrictionCone);
	}
	else
	{
		CVD_PACK_BITFIELD_DATA(bDisabled, PackedFlags, EChaosVDManifoldPointFlags::Disabled);
		CVD_PACK_BITFIELD_DATA(bWasRestored, PackedFlags, EChaosVDManifoldPointFlags::WasRestored);
		CVD_PACK_BITFIELD_DATA(bWasReplaced, PackedFlags, EChaosVDManifoldPointFlags::WasReplaced);
		CVD_PACK_BITFIELD_DATA(bHasStaticFrictionAnchor, PackedFlags, EChaosVDManifoldPointFlags::HasStaticFrictionAnchor);
		CVD_PACK_BITFIELD_DATA(bIsValid, PackedFlags, EChaosVDManifoldPointFlags::IsValid);
		CVD_PACK_BITFIELD_DATA(bInsideStaticFrictionCone, PackedFlags, EChaosVDManifoldPointFlags::InsideStaticFrictionCone);
		Ar << PackedFlags;
	}

	Ar << NetPushOut;
	Ar << NetImpulse;

	Ar << TargetPhi;
	Ar << InitialPhi;

	CVD_SERIALIZE_STATIC_ARRAY(Ar, ShapeAnchorPoints);
	CVD_SERIALIZE_STATIC_ARRAY(Ar, InitialShapeContactPoints);

	Ar << ContactPoint;
	CVD_SERIALIZE_STATIC_ARRAY(Ar, ShapeContactPoints);

	return true;
}

bool FChaosVDCollisionMaterial::Serialize(FArchive& Ar)
{
	Ar << FaceIndex;
	Ar << MaterialDynamicFriction;
	Ar << MaterialStaticFriction;
	Ar << MaterialRestitution;
	Ar << DynamicFriction;
	Ar << StaticFriction;
	Ar << Restitution;
	Ar << RestitutionThreshold;
	Ar << InvMassScale0;
	Ar << InvMassScale1;
	Ar << InvInertiaScale0;
	Ar << InvInertiaScale1;

	return true;
}

bool FChaosVDConstraint::Serialize(FArchive& Ar)
{	
	EChaosVDConstraintFlags PackedFlags = EChaosVDConstraintFlags::None;

	
	// Note: When the UI is done to show the enums in the same way we show these bitfiedls as read only booleans in CVD, we can remove all
	// this macro boilerplate and just serialize the the flags directly
	if (Ar.IsLoading())
	{
		Ar << PackedFlags;
		CVD_UNPACK_BITFIELD_DATA(bIsCurrent, PackedFlags, EChaosVDConstraintFlags::IsCurrent);
		CVD_UNPACK_BITFIELD_DATA(bDisabled, PackedFlags, EChaosVDConstraintFlags::Disabled);
		CVD_UNPACK_BITFIELD_DATA(bUseManifold, PackedFlags, EChaosVDConstraintFlags::UseManifold);
		CVD_UNPACK_BITFIELD_DATA(bUseIncrementalManifold, PackedFlags, EChaosVDConstraintFlags::UseIncrementalManifold);
		CVD_UNPACK_BITFIELD_DATA(bCanRestoreManifold, PackedFlags, EChaosVDConstraintFlags::CanRestoreManifold);
		CVD_UNPACK_BITFIELD_DATA(bWasManifoldRestored, PackedFlags, EChaosVDConstraintFlags::WasManifoldRestored);
		CVD_UNPACK_BITFIELD_DATA(bIsQuadratic0, PackedFlags, EChaosVDConstraintFlags::IsQuadratic0);
		CVD_UNPACK_BITFIELD_DATA(bIsProbe, PackedFlags, EChaosVDConstraintFlags::IsProbe);
		CVD_UNPACK_BITFIELD_DATA(bCCDEnabled, PackedFlags, EChaosVDConstraintFlags::CCDEnabled);
		CVD_UNPACK_BITFIELD_DATA(bCCDSweepEnabled, PackedFlags, EChaosVDConstraintFlags::CCDSweepEnabled);
		CVD_UNPACK_BITFIELD_DATA(bModifierApplied, PackedFlags, EChaosVDConstraintFlags::ModifierApplied);
		CVD_UNPACK_BITFIELD_DATA(bMaterialSet, PackedFlags, EChaosVDConstraintFlags::MaterialSet);
	}
	else
	{
		CVD_PACK_BITFIELD_DATA(bIsCurrent, PackedFlags, EChaosVDConstraintFlags::IsCurrent);
		CVD_PACK_BITFIELD_DATA(bDisabled, PackedFlags, EChaosVDConstraintFlags::Disabled);
		CVD_PACK_BITFIELD_DATA(bUseManifold, PackedFlags, EChaosVDConstraintFlags::UseManifold);
		CVD_PACK_BITFIELD_DATA(bUseIncrementalManifold, PackedFlags, EChaosVDConstraintFlags::UseIncrementalManifold);
		CVD_PACK_BITFIELD_DATA(bCanRestoreManifold, PackedFlags, EChaosVDConstraintFlags::CanRestoreManifold);
		CVD_PACK_BITFIELD_DATA(bWasManifoldRestored, PackedFlags, EChaosVDConstraintFlags::WasManifoldRestored);
		CVD_PACK_BITFIELD_DATA(bIsQuadratic0, PackedFlags, EChaosVDConstraintFlags::IsQuadratic0);
		CVD_PACK_BITFIELD_DATA(bIsProbe, PackedFlags, EChaosVDConstraintFlags::IsProbe);
		CVD_PACK_BITFIELD_DATA(bCCDEnabled, PackedFlags, EChaosVDConstraintFlags::CCDEnabled);
		CVD_PACK_BITFIELD_DATA(bCCDSweepEnabled, PackedFlags, EChaosVDConstraintFlags::CCDSweepEnabled);
		CVD_PACK_BITFIELD_DATA(bModifierApplied, PackedFlags, EChaosVDConstraintFlags::ModifierApplied);
		CVD_PACK_BITFIELD_DATA(bMaterialSet, PackedFlags, EChaosVDConstraintFlags::MaterialSet);
		Ar << PackedFlags;
	}

	Ar << Material;
	Ar << AccumulatedImpulse;
	Ar << ShapesType;

	CVD_SERIALIZE_STATIC_ARRAY(Ar, ShapeWorldTransforms);
	CVD_SERIALIZE_STATIC_ARRAY(Ar, ImplicitTransforms);

	Ar << CullDistance;
	Ar << CollisionMargins;	
	Ar << CollisionTolerance;	
	Ar << ClosestManifoldPointIndex;	
	Ar << ExpectedNumManifoldPoints;	
	Ar << LastShapeWorldPositionDelta;
	Ar << LastShapeWorldRotationDelta;
	Ar << Stiffness;
	Ar << MinInitialPhi;
	Ar << InitialOverlapDepenetrationVelocity;
	Ar << CCDTimeOfImpact;
	Ar << CCDEnablePenetration;
	Ar << CCDTargetPenetration;
	Ar << ManifoldPoints;
	Ar << SolverID;
	Ar << Particle0Index;
	Ar << Particle1Index;

	return !Ar.IsError();
}

bool FChaosVDParticlePairMidPhase::Serialize(FArchive& Ar)
{
	Ar << SolverID;

	
	EChaosVDMidPhaseFlags PackedFlags = EChaosVDMidPhaseFlags::None;

	
	// Note: When the UI is done to show the enums in the same way we show these bitfiedls as read only booleans in CVD, we can remove all
	// this macro boilerplate and just serialize the the flags directly
	if (Ar.IsLoading())
	{
		Ar << PackedFlags;
		CVD_UNPACK_BITFIELD_DATA(bIsActive, PackedFlags, EChaosVDMidPhaseFlags::IsActive);
		CVD_UNPACK_BITFIELD_DATA(bIsCCD, PackedFlags, EChaosVDMidPhaseFlags::IsCCD);
		CVD_UNPACK_BITFIELD_DATA(bIsCCDActive, PackedFlags, EChaosVDMidPhaseFlags::IsCCDActive);
		CVD_UNPACK_BITFIELD_DATA(bIsCCDActive, PackedFlags, EChaosVDMidPhaseFlags::IsCCDActive);
		CVD_UNPACK_BITFIELD_DATA(bIsSleeping, PackedFlags, EChaosVDMidPhaseFlags::IsSleeping);
		CVD_UNPACK_BITFIELD_DATA(bIsModified, PackedFlags, EChaosVDMidPhaseFlags::IsModified);
	}
	else
	{
		CVD_PACK_BITFIELD_DATA(bIsActive, PackedFlags, EChaosVDMidPhaseFlags::IsActive);
		CVD_PACK_BITFIELD_DATA(bIsCCD, PackedFlags, EChaosVDMidPhaseFlags::IsCCD);
		CVD_PACK_BITFIELD_DATA(bIsCCDActive, PackedFlags, EChaosVDMidPhaseFlags::IsCCDActive);
		CVD_PACK_BITFIELD_DATA(bIsCCDActive, PackedFlags, EChaosVDMidPhaseFlags::IsCCDActive);
		CVD_PACK_BITFIELD_DATA(bIsSleeping, PackedFlags, EChaosVDMidPhaseFlags::IsSleeping);
		CVD_PACK_BITFIELD_DATA(bIsModified, PackedFlags, EChaosVDMidPhaseFlags::IsModified);
		Ar << PackedFlags;
	}
		
	Ar << LastUsedEpoch;

	Ar << Particle0Idx;
	Ar << Particle1Idx;

	Ar << Constraints;

	return !Ar.IsError();
}

bool FChaosVDCollisionFilterData::Serialize(FArchive& Ar)
{
	Ar << Word0;
	Ar << Word1;
	Ar << Word2;
	Ar << Word3;

	return !Ar.IsError();
}

bool FChaosVDShapeCollisionData::Serialize(FArchive& Ar)
{
	Ar.UsingCustomVersion(FFortniteMainBranchObjectVersion::GUID);

	Ar << CollisionTraceType;

	EChaosVDCollisionShapeDataFlags PackedFlags = EChaosVDCollisionShapeDataFlags::None;

	
	// Note: When the UI is done to show the enums in the same way we show these bitfiedls as read only booleans in CVD, we can remove all
	// this macro boilerplate and just serialize the the flags directly
	if (Ar.IsLoading())
	{
		Ar << PackedFlags;
		CVD_UNPACK_BITFIELD_DATA(bSimCollision, PackedFlags, EChaosVDCollisionShapeDataFlags::SimCollision);
		CVD_UNPACK_BITFIELD_DATA(bQueryCollision, PackedFlags, EChaosVDCollisionShapeDataFlags::QueryCollision);
		CVD_UNPACK_BITFIELD_DATA(bIsProbe, PackedFlags, EChaosVDCollisionShapeDataFlags::IsProbe);
	}
	else
	{
		CVD_PACK_BITFIELD_DATA(bSimCollision, PackedFlags, EChaosVDCollisionShapeDataFlags::SimCollision);
		CVD_PACK_BITFIELD_DATA(bQueryCollision, PackedFlags, EChaosVDCollisionShapeDataFlags::QueryCollision);
		CVD_PACK_BITFIELD_DATA(bIsProbe, PackedFlags, EChaosVDCollisionShapeDataFlags::IsProbe);
		Ar << PackedFlags;
	}

	if (Ar.CustomVer(FFortniteMainBranchObjectVersion::GUID) >= FFortniteMainBranchObjectVersion::SimAndQueryDataSupportInChaosVisualDebugger)
	{
		Ar << SimData;
		Ar << QueryData;
	}

	return !Ar.IsError();
}

bool FChaosVDShapeCollisionData::operator==(const FChaosVDShapeCollisionData& Other) const
{
	return CollisionTraceType == Other.CollisionTraceType
			&& bSimCollision == Other.bSimCollision
			&& bQueryCollision == Other.bQueryCollision
			&& bIsProbe == Other.bIsProbe
			&& QueryData == Other.QueryData
			&& SimData == Other.SimData;
}

bool FChaosVDCollisionChannelInfo::Serialize(FArchive& Ar)
{
	Ar << DisplayName;

	Ar << CollisionChannel;

	Ar << bIsTraceType;

	return !Ar.IsError();
}

bool FChaosVDCollisionChannelsInfoContainer::Serialize(FArchive& Ar)
{
	CVD_SERIALIZE_STATIC_ARRAY(Ar, CustomChannelsNames);

	return !Ar.IsError();
}