CosmeticsComponent.h

Go to the documentation of this file.

// Copyright Blue Isle Studios Inc 2018. All Rights Reserved.
 
#pragma once
 
#include "CosmeticsManager.h"
#include "Engine/StreamableManager.h"
#include "CosmeticsComponent.generated.h"
 
USTRUCT(Blueprintable)
struct FKeyChain
{
    GENERATED_USTRUCT_BODY()
    FKeyChain() {}
    FKeyChain(const TSoftObjectPtr<USkeletalMesh> KeyChainMeshIn, const TArray<TSoftObjectPtr<UMaterialInstance>>& KeyChainMaterailsIn)
    {
        KeyChainMesh = KeyChainMeshIn;
        KeyChainMaterials = KeyChainMaterailsIn;
    }
 
    TSoftObjectPtr<USkeletalMesh> KeyChainMesh;
    TArray<TSoftObjectPtr<UMaterialInstance>> KeyChainMaterials;
};
 
USTRUCT(BlueprintType)
struct FVehicleSkin
{
    GENERATED_BODY()
    FVehicleSkin()
    {
        Materials = TArray<TSoftObjectPtr<UMaterialInstance>>();
        VehicleMesh = NULL;
        ParticleSystem = NULL;
    }
    FVehicleSkin(const TArray<TSoftObjectPtr<UMaterialInstance>>& NewMaterials, const TSoftObjectPtr<USkeletalMesh>& NewVehicleMesh,const TSoftObjectPtr<UParticleSystem> NewParticleSystem)
    {
        Materials = NewMaterials;
        VehicleMesh = NewVehicleMesh;
        ParticleSystem = NewParticleSystem;
    }
 
    UPROPERTY()
    TArray<TSoftObjectPtr<UMaterialInstance>> Materials = TArray<TSoftObjectPtr<UMaterialInstance>>();
    UPROPERTY()
    TSoftObjectPtr<UParticleSystem> ParticleSystem = NULL;
    UPROPERTY()
    TSoftObjectPtr<USkeletalMesh> VehicleMesh = NULL;
};
 
USTRUCT(BlueprintType)
struct FWeaponSkin
{
    GENERATED_BODY()
    FWeaponSkin() 
    {
        Materials = TArray<TSoftObjectPtr<UMaterialInstance>>();
        WeaponMesh1P = NULL;
        WeaponMesh3P = NULL;
        ParticleSystem = NULL;
    }
    FWeaponSkin(const TArray<TSoftObjectPtr<UMaterialInstance>>& NewMaterials, const TSoftObjectPtr<USkeletalMesh>& NewWeaponMesh1P, const TSoftObjectPtr<USkeletalMesh>& NewWeaponMesh3P, const TSoftObjectPtr<UParticleSystem> NewParticleSystem)
    {
        Materials = NewMaterials;
        WeaponMesh1P = NewWeaponMesh1P;
        WeaponMesh3P = NewWeaponMesh3P;
        ParticleSystem = NewParticleSystem;
    }
 
    UPROPERTY()
    TArray<TSoftObjectPtr<UMaterialInstance>> Materials = TArray<TSoftObjectPtr<UMaterialInstance>>();
    UPROPERTY()
    TSoftObjectPtr<UParticleSystem> ParticleSystem = NULL;
    UPROPERTY()
    TSoftObjectPtr<USkeletalMesh> WeaponMesh1P = NULL;
    UPROPERTY()
    TSoftObjectPtr<USkeletalMesh> WeaponMesh3P = NULL;
};
 
USTRUCT(BlueprintType)
struct FSkinMaterial
{
    GENERATED_BODY()
    FSkinMaterial() {};
 
    void UpdatedLoadedMaterial(UMaterialInstance* NewLoadedMaterial)
    {
        Material = NewLoadedMaterial;
        bLoaded = true;
    }
    UPROPERTY()
    UMaterialInstance* Material = NULL;
    bool bLoaded = false;
};
 
USTRUCT(BlueprintType)
struct FPlayerSkinPortion
{
    GENERATED_BODY()
 
    FPlayerSkinPortion() {}
 
    bool IsSkinPortionLoaded()
    {
        return bLoadedMesh && bLoadedMaterials;
    }
    UPROPERTY()
    TArray<FSkinMaterial> Materials = TArray<FSkinMaterial>();
    UPROPERTY()
    USkeletalMesh* Mesh = NULL;
    bool bLoadedMesh = false;
    bool bLoadedMaterials = false;
};
 
UENUM(BlueprintType, meta = (Bitflags))
enum class EPlayerSkinPart : uint8
{
    None = 0,
    Head = 0x00000001,
    Body1P = 0x00000002,
    Body3P = 0x00000004,
    Equipment = 0x00000008
};
ENUM_CLASS_FLAGS(EPlayerSkinPart)
 
USTRUCT(BlueprintType)
struct FPlayerSkin
{
    GENERATED_BODY()
 
    FPlayerSkin()
    {
        PlayerSkin.Add(EPlayerSkinPart::Body1P, FPlayerSkinPortion());
        PlayerSkin.Add(EPlayerSkinPart::Body3P, FPlayerSkinPortion());
        PlayerSkin.Add(EPlayerSkinPart::Equipment, FPlayerSkinPortion());
        PlayerSkin.Add(EPlayerSkinPart::Head, FPlayerSkinPortion());
    }
 
    USkeletalMesh* const GetLoadedMesh(EPlayerSkinPart Part)
    {
        if (!PlayerSkin.Contains(Part))
        {
            return NULL;
        }
 
        return PlayerSkin[Part].Mesh;
    }
 
    bool IsSkinLoaded()
    {
        for (const TPair<EPlayerSkinPart, FPlayerSkinPortion>& SkinPortion : PlayerSkin)
        {
            if (!SkinPortion.Value.bLoadedMaterials || !SkinPortion.Value.bLoadedMesh)
            {
                return false;
            }
        }
 
        return true;
    }
 
    void UpdateLoadedSkinMesh(EPlayerSkinPart Part, USkeletalMesh* Mesh)
    {
        if(PlayerSkin.Contains(Part))
        {
            PlayerSkin[Part].Mesh = Mesh;
            PlayerSkin[Part].bLoadedMesh = true;
        }
    }
 
    void InitializeMaterialsList(EPlayerSkinPart Part, int32 Size)
    {
        if (!PlayerSkin.Contains(Part))
        {
            return;
        }
        PlayerSkin[Part].Materials.Init(FSkinMaterial(), Size);
        if (!Size)
        {
            PlayerSkin[Part].bLoadedMaterials = true;
        }
    }
 
    void UpdateLoadedMaterial(EPlayerSkinPart Part, UMaterialInstance* Material, int i)
    {
        if (!PlayerSkin.Contains(Part) || PlayerSkin[Part].Materials.Num() <= i)
        {
            return;
        }
 
        PlayerSkin[Part].Materials[i].UpdatedLoadedMaterial(Material);
        for (const FSkinMaterial& MaterialInstance : PlayerSkin[Part].Materials)
        {
            if (!MaterialInstance.bLoaded)
            {
                return;
            }
        }
 
        PlayerSkin[Part].bLoadedMaterials = true;
    }
 
    void SetSkipLoadingPortion(EPlayerSkinPart LoadSkippingPortion)
    {
        if(!PlayerSkin.Contains(LoadSkippingPortion))
        {
            return;
        }
        PlayerSkin[LoadSkippingPortion].bLoadedMesh = true;
        PlayerSkin[LoadSkippingPortion].bLoadedMaterials = true;
    }
 
    UPROPERTY()
    TMap<EPlayerSkinPart,FPlayerSkinPortion> PlayerSkin = TMap<EPlayerSkinPart, FPlayerSkinPortion>();
};
 
 
UENUM(BlueprintType)
enum class EItemType : uint8
{
    Inventory = 0,
    Hats = 1,
    Shirts = 2,
    Weapon = 3,
    Pants = 4,
    Shoes = 5,
    Trinket = 6,
    Consumable = 7,
    None = 254
};
 
class UMeshComponent;
class USkeletalMesh;
class UStaticMeshComponent;
class USkeletalMeshComponent;
class UParticleSystemComponent;
class APlayerState;
class UMaterialInstance;
class UWeaponInstance;
class UMaterial;
class UBISSkeletalMeshComponent;
class UWeaponInstanceSpawnableVehicle;
class AProjectXVehicle;
 
DECLARE_DELEGATE(FDelegateBinding);
DECLARE_DELEGATE_TwoParams(FDelegateMaterialBinding,UMaterial*, int);
DECLARE_DELEGATE_TwoParams(FDelegateMaterialInstanceBinding,UMaterialInstance*, int);
DECLARE_DELEGATE_OneParam(FDelegateTextureBinding, UTexture*);
DECLARE_DELEGATE_OneParam(FDelegateParticleBinding, UParticleSystem*);
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnCosmeticLoadedSignature);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnPlayerSkinLoadedSignature, const UCosmeticPlayerSkinAsset*, SkinAsset);
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnCosmeticMeshLoadingSignature, USkeletalMeshComponent*, MeshComponent, bool, bLoaded);
 
UCLASS()
class PROJECTX_API UCosmeticsComponent : public UActorComponent
{
    GENERATED_BODY()
 
public:
    UCosmeticsComponent();
 
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
    virtual void BeginPlay() override;
    /* FirstPerson Mesh Scale*/
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Cosmetics)
    FVector Scale1P = FVector(1.0f,1.0f,1.0f);
    /* Starting mesh offsets */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Cosmetics)
    FVector Position1P = FVector(-45.0f, 0.0f, -155.0f);
    /* Starting mesh offsets */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Cosmetics)
    FVector Rotation1P = FVector(8.0f, 0.0f, -90.0f);
    /* Starting mesh offsets */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Cosmetics)
    FVector Position3P = FVector(0.0f, 0.0f, -96.0f);
    /* Starting mesh offsets */
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = Cosmetics)
    FRotator Rotation3P = FRotator(0.0f, -90.0f, 0.0f);
 
    UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category = Mesh)
    bool bPreview = false;
 
    UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category = Mesh)
    UClass* AnimationBlendTree1P;
    UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category = Mesh)
    UClass* AnimationBlendTree3P;
 
    UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category = Mesh)
    USkeletalMesh* BodyMesh1P;
    UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category = Mesh)
    USkeletalMesh* BodyMesh3P;
    /* Class-specific clothing Skeletal Mesh */
    UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category = Mesh)
    USkeletalMesh* ClassClothingMesh3P;
    UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category = Mesh)
    USkeletalMesh* HeadVariant3P;
 
    UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category = Mesh)
    USkeletalMeshComponent* Mesh1P;
    UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category = Mesh)
    UBISSkeletalMeshComponent* Mesh3P;
 
    UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category = Mesh)
    USkeletalMeshComponent* Gun1P;
 
    UFUNCTION(BlueprintCallable)
    UTexture* GetPattern() const { return PatternMaterial; }
    UFUNCTION(BlueprintCallable)
    void SetPattern(UTexture* const NewPattern) { PatternMaterial = NewPattern; }
    UFUNCTION(BlueprintCallable, BlueprintPure)
    const TArray<UMeshComponent*>& Get3pMeshComponents() const { return AllMeshes3P; }
    /*Particle Trail behind the player for allies*/
    UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category = Mesh)
    class UParticleSystem* AllyPlayerTrailParticle;
    /*Particle Trail behind the player for enemies*/
    UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category = Mesh)
    class UParticleSystem* EnemyPlayerTrailParticle;
 
    /*Weapon Skins*/
    UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category = Mesh)
    TMap<FString,FWeaponSkin> WeaponSkins;
    UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category = Mesh)
    TMap<FString, FVehicleSkin> VehicleSkins;
    UPROPERTY(BlueprintReadWrite, EditDefaultsOnly, Category = Mesh)
    TMap<FString, FKeyChain> KeyChains;
    UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category = Mesh)
    UBISSkeletalMeshComponent* Head3P = nullptr;
 
    UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category = Mesh)
    UBISSkeletalMeshComponent* ClassClothing3P = nullptr;
    UPROPERTY(VisibleInstanceOnly, BlueprintReadOnly, Category = Mesh)
    UBISSkeletalMeshComponent* Gun3P = nullptr;
 
    TArray<UMeshComponent*> AllMeshes3P;
    TArray<UMeshComponent*> AllMeshes1P;
    TArray<UMeshComponent*> AllMeshes;
 
    void SetStaticMesh(UStaticMeshComponent* MeshComponent, UStaticMesh* Mesh);
    void SetSkeletalMesh(USkeletalMeshComponent* MeshComponent, USkeletalMesh* Mesh);
    void SetFirstPersonMesh();
 
    UFUNCTION(BlueprintCallable, Category = Cosmetics)
    void SetScalarParameterForAllMeshes(const FName& ParameterName, float ScalarParameter);
    UFUNCTION(BlueprintCallable, Category = Cosmetics)
    void SetVectorParameterForAllMeshes(const FName& ParameterName, FVector VectorParameter);
    UFUNCTION(BlueprintCallable, Category = Cosmetics)
    void SetTextureParameterForAllMeshes(const FName& ParameterName, UTexture* TextureParameter);
    UFUNCTION(BlueprintCallable, Category = Cosmetics)
    void SetMaterialLayer(UMaterialInterface* Material);
    UFUNCTION(BlueprintCallable, Category = Cosmetics)
    void ClearMaterialLayer();
    void CacheAllMaterials();
    void CacheMaterial(UMeshComponent* Mesh);
    void RestoreAllMaterials();
    void SetMaterialLayerForAllMeshes();
    void SetMaterialLayerForMesh(UMeshComponent* Mesh);
    
    void ApplyVehicleSkins(AProjectXVehicle* Vehicle);
 
    UFUNCTION(BlueprintCallable)
    bool IsLoadedCosmetic(ECosmeticType Type, UCosmeticAssetBase* Asset) const;
    TWeakObjectPtr<UMaterialInterface> MaterialLayer = nullptr;
    TMap<TWeakObjectPtr<UMeshComponent>, TArray<TWeakObjectPtr<UMaterialInterface>>> MaterialCache;
 
    UFUNCTION(BlueprintCallable, Category = Cosmetics)
    void LoadDefaultCosmetics();
 
    UFUNCTION(BlueprintCallable, Category = Cosmetics)
    void ToggleKeyChainVisiblity(bool bHideKeyChain);
 
    UFUNCTION(BlueprintCallable, Category = Cosmetics)
    void ToggleView(bool toggle);
    UFUNCTION(BlueprintCallable)
    virtual void OnWeaponChanged(UWeaponInstance* Weapon);
    UFUNCTION(BlueprintCallable)
    virtual void OnVehicleChanged(AProjectXCharacter* Driver,AProjectXVehicle* CurrentVehicle, AProjectXVehicle* PreviousVehicle);
    UFUNCTION(BlueprintCallable)
    virtual void PersonalVehicleChanged(UWeaponInstanceSpawnableVehicle* PVWeapon);
    UFUNCTION()
    void OnTightAimStart() { ToggleKeyChainVisiblity(true); }
    UFUNCTION()
    void OnTightAimEnd() { ToggleKeyChainVisiblity(false); }
    void OnCosmeticsLoaded();
    UFUNCTION(BlueprintCallable)
    void LoadCosmeticsForClass(const FEquips& Equips, ECosmeticType Type,const TSubclassOf<AProjectXCharacter> CharacterClass, const TSubclassOf<UWeaponInstance> WeaponClass = NULL);
    UFUNCTION()
    void OnEquipsUpdated(ECosmeticType Type,const FString& ShortCode, const FString& Key);
    
    bool IsLocallyControlled();
 
    void ToggleRagdoll(bool toggle);
    void ManageClothPhysics();
 
    UFUNCTION(BlueprintCallable,BlueprintPure)
    class UParticleSystem* GetPlayerTrail(bool bIsAlly) const;
 
    UFUNCTION(BlueprintCallable)
    UAnimMontage* GetTauntMontage() const { return TauntMontage; }
 
    void InitializeMesh1P(USkeletalMeshComponent*& Mesh, FName Name);
    void InitializeMesh3P(USkeletalMeshComponent*& Mesh, FName Name, bool bUseAttachedParentsBounds = false);
    UFUNCTION(BlueprintCallable)
    void InitializeFromCosmeticComponent(UCosmeticsComponent* CosmeticComponent);
    void AsyncLoadSkeletalMesh(TSoftObjectPtr<USkeletalMesh> AssetPointer, TWeakObjectPtr<USkeletalMeshComponent> MeshComponent);
    void AsyncLoadSkeletalMesh(TSoftObjectPtr<USkeletalMesh> AssetPointer, TWeakObjectPtr<USkeletalMeshComponent> MeshComponent, FDelegateBinding Callback);
    void AsyncLoadStaticMesh(TSoftObjectPtr<UStaticMesh> AssetPointer, TWeakObjectPtr<UStaticMeshComponent> MeshComponent);
    void AsyncLoadMaterialInstance(TSoftObjectPtr<UMaterialInstance> AssetPointer, int MaterialIndex, FDelegateMaterialInstanceBinding Callback);
    void AsyncLoadMaterial(TSoftObjectPtr<UMaterial> AssetPointer, int MaterialIndex, FDelegateMaterialBinding Callback);
    void AsyncLoadTexture(TSoftObjectPtr<UTexture> AssetPointer, FDelegateTextureBinding Callback);
    void AsyncLoadParticle(TSoftObjectPtr<UParticleSystem> AssetPointer, FDelegateParticleBinding Callback);
 
    void SpawnSkeletalMeshAttached(USkeletalMesh* Mesh, USceneComponent* AttachTo, FName Socket);
    void SpawnStaticMeshAttached(UStaticMesh* Mesh, USceneComponent* AttachTo, FName Socket);
    void SpawnKeyChainAttached(USkeletalMesh* Mesh, USceneComponent* AttachTo,TSubclassOf<UWeaponInstance> WeaponClass, FName Socket);
 
    template <class T>
    void AsyncLoadAsset(TSoftObjectPtr<T> AssetPointer, FDelegateBinding Callback);
 
    bool CanApplyCosmeticChanges() const;
 
    UFUNCTION(BlueprintCallable, Category = "Cosmetic")
    void RenderCustomDepth3P(const uint8 StencilValue, const bool bUseCustomDepth);
 
    UPROPERTY(BlueprintAssignable)
    FOnPlayerSkinLoadedSignature OnPlayerSkinLoaded;
    UPROPERTY(BlueprintAssignable)
    FOnCosmeticLoadedSignature OnPlayerTrailChangedEvent;
    UPROPERTY(BlueprintAssignable)
    FOnCosmeticMeshLoadingSignature On3PWeaponLoadedEvent;
    UPROPERTY(BlueprintAssignable)
    FOnCosmeticLoadedSignature OnPatternLoadedEvent;
 
protected:
    UFUNCTION(BlueprintCallable)
    void LoadPlayerSkin(class UCosmeticPlayerSkinAsset* SkinAsset);
    UFUNCTION(BlueprintCallable)
    void LoadParticleTrail(class UCosmeticTrailAsset* TrailAsset);
    UFUNCTION(BlueprintCallable)
    void LoadVehicleWeaponSkins(UCosmeticVehicleSkinAsset* VehicleSkinAsset, const FString& WeaponID);
    UFUNCTION(BlueprintCallable)
    void LoadWeaponSkins(class UCosmeticWeaponSkinAsset* WeaponSkinAsset,const FString& WeaponID);
    UFUNCTION(BlueprintCallable)
    void LoadDeathExplosion(class UCosmeticExplosionAsset* ExplosionAsset);
    UFUNCTION(BlueprintCallable)
    void LoadTaunt(class UCosmeticTauntAsset* TauntAsset);
    UFUNCTION(BlueprintCallable)
    void LoadKeyChain(class UCosmeticKeyChainAsset* KeyChainAsset, const FString& WeaponID);
    UFUNCTION()
    void OnPlayerStateUpdated(APlayerState* PlayerState);
 
    void LoadPlayerSkinPiece(UCosmeticPlayerSkinAsset* SkinAsset,TSoftObjectPtr<USkeletalMesh> MeshAsset, const TArray<TSoftObjectPtr<UMaterialInstance>>& Materials, EPlayerSkinPart SkinLoadedPortion);
    bool SkinLoadedResponse(UCosmeticPlayerSkinAsset* SkinAsset);
    void ApplyPlayerSkin(USkeletalMeshComponent* MeshComponent, EPlayerSkinPart Part, UCosmeticPlayerSkinAsset* SkinAsset);
 
    TWeakObjectPtr<UWeaponInstance> CachedActiveWeapon = nullptr;
    TWeakObjectPtr<UWeaponInstanceSpawnableVehicle> CachedVehicleWeapon = nullptr;
    TArray<USceneComponent*> Attachments;
    UBISSkeletalMeshComponent* KeyChain = nullptr;
    UAnimMontage* TauntMontage = nullptr;
    UTexture* PatternMaterial = nullptr;
 
    TMap<FString,TMap<uint8, UMaterialInstance*>> VehicleLoadedSkins;
    UPROPERTY()
    TMap<UCosmeticPlayerSkinAsset*,FPlayerSkin> LoadedPlayerSkin;
    UPROPERTY()
    TMap<ECosmeticType, UCosmeticAssetBase*> CachedLoadedCosmetics;
    
private:
    FTimerHandle RagdollTimerHandle;
    class AProjectXCharacter* Character = nullptr;
    class APlayerController* PlayerController = nullptr;
    class UCameraComponent* FPCamera = nullptr;
 
    bool bIsFirstPerson = true;
};