(Feat) Customisation de personnage -- donnees et montage
Lot 2 du chantier : le corps du lot precedent devient assemblable. Tete, coiffure, sourcils, barbe et moustache sont montes en leader pose sur le mesh du Character, et les couleurs sont posees sur des MID. FCharacterAppearance tient en 11 octets : des INDEX et jamais des chemins d'assets. Un chemin couterait une chaine a chaque replication, alors qu'un index tient dans un octet et se VALIDE contre le catalogue -- un client ne peut donc pas demander un asset arbitraire. Le corps se monte depuis une LISTE de meshes meme si elle n'a qu'une case. Le pack livre exprès SKM_BodyA_torso, _arms, _legs_01/02/03 pour qu'une armure puisse eteindre les segments qu'elle recouvre : le jour venu la case 0 devient SKM_BodyA_empty et les huit segments suivent, sans que ce code change. Un pointeur unique imposerait de tout reprendre au premier plastron. Trois pieges rencontres, aucun visible depuis le code : - Les UFUNCTION(Exec) d'un UActorComponent ne sont JAMAIS appelees. La chaine de routage (UPlayer::Exec) interroge le monde, le PlayerInput, le controller, le pawn, le HUD, le GameMode, le CheatManager, le GameState et le camera manager -- jamais les composants, AActor ne surchargeant pas ProcessConsoleExec. Et rien ne proteste. D'ou EmberPart / EmberColor / EmberAppearanceDump posees sur AFpsPlayer, qui delegue. - L'ordre des slots de materiau varie d'un mesh a l'autre : sur SKM_HeadA_01 l'Element 0 est celui des YEUX et le 1 celui de la peau. Les six tetes venant de deux packs, on cherche le slot par son NOM et on ne pose rien si aucun ne correspond -- ecraser le slot de la peau repeint le visage entier de la couleur des yeux. - Un nom de parametre materiau se lit dans le Material INSTANCE, pas dans les chaines du master : M_Head_Base contient « Skin Base color » mais le parametre expose s'appelle « Skin ». D'ou des UPROPERTY de catalogue plutot que des constantes, pour corriger sans recompiler. Body B reste a remplir dans DA_CharacterParts, avec son ABP_PlayerBody_B et sans barbes ni moustaches -- le pack n'en livre pas, et une liste vide se comporte deja comme NoPart. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,165 @@
|
||||
// Fill out your copyright notice in the Description page of Project Settings.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "Components/ActorComponent.h"
|
||||
#include "CharacterAppearanceTypes.h"
|
||||
#include "CharacterAppearanceComponent.generated.h"
|
||||
|
||||
class UCharacterPartsDataAsset;
|
||||
class USkeletalMeshComponent;
|
||||
struct FCharacterBodySet;
|
||||
|
||||
/** Diffuse a chaque apparence appliquee, pour que l'UI se rafraichisse. */
|
||||
DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnAppearanceApplied);
|
||||
|
||||
/**
|
||||
* Monte un personnage a partir d'une FCharacterAppearance : assigne les meshes,
|
||||
* les met en leader pose, et pose les couleurs sur des materiaux dynamiques.
|
||||
*
|
||||
* Un systeme = un composant, comme le reste du projet. Mais celui-ci a une
|
||||
* particularite qui vaut d'etre tenue : il ne suppose PAS vivre sur le pawn. Il
|
||||
* cherche le mesh d'un ACharacter s'il en trouve un, accepte qu'on lui en
|
||||
* designe un autre, et fonctionne donc a l'identique sur le mannequin de l'ecran
|
||||
* de customisation. C'est ce qui garantit que le personnage montre au joueur et
|
||||
* celui que ses amis verront ne peuvent pas diverger : c'est le meme code.
|
||||
*
|
||||
* Il ne replique rien -- l'apparence vivra sur ASurvivalPlayerState, comme le
|
||||
* pseudo, et pour la meme raison : elle doit survivre a la mort du pawn.
|
||||
*/
|
||||
UCLASS(ClassGroup = (Survival), meta = (BlueprintSpawnableComponent))
|
||||
class SURVIVAL_PROJET_API UCharacterAppearanceComponent : public UActorComponent
|
||||
{
|
||||
GENERATED_BODY()
|
||||
|
||||
public:
|
||||
UCharacterAppearanceComponent();
|
||||
|
||||
virtual void BeginPlay() override;
|
||||
|
||||
UPROPERTY(BlueprintAssignable, Category = "Appearance")
|
||||
FOnAppearanceApplied OnAppearanceApplied;
|
||||
|
||||
/** Ton DA_CharacterParts. Sans lui le composant ne monte rien et le dit. */
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Appearance")
|
||||
TObjectPtr<UCharacterPartsDataAsset> Catalog;
|
||||
|
||||
/**
|
||||
* L'apparence posee au BeginPlay, tant que rien ne l'a remplacee.
|
||||
*
|
||||
* Elle sert au mannequin de l'ecran, aux tests en PIE, et de repli si les
|
||||
* reglages du joueur sont vides -- c'est-a-dire au tout premier lancement.
|
||||
*/
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Appearance")
|
||||
FCharacterAppearance DefaultAppearance;
|
||||
|
||||
/**
|
||||
* Designe le mesh porteur. A appeler AVANT la premiere application.
|
||||
*
|
||||
* Inutile sur un ACharacter, dont le mesh est trouve tout seul. Necessaire
|
||||
* sur un acteur quelconque -- le mannequin de l'ecran de customisation.
|
||||
*/
|
||||
UFUNCTION(BlueprintCallable, Category = "Appearance")
|
||||
void SetTargetMesh(USkeletalMeshComponent* InTargetMesh);
|
||||
|
||||
/**
|
||||
* Monte l'apparence demandee. Idempotente, et bon marche a la repetition :
|
||||
* les meshes ne sont retouches que si une PIECE a change, jamais pour une
|
||||
* simple couleur. C'est ce qui permet a un curseur d'appeler cette fonction
|
||||
* a chaque image sans engendrer un materiau par frame.
|
||||
*/
|
||||
UFUNCTION(BlueprintCallable, Category = "Appearance")
|
||||
void ApplyAppearance(const FCharacterAppearance& InAppearance);
|
||||
|
||||
UFUNCTION(BlueprintPure, Category = "Appearance")
|
||||
const FCharacterAppearance& GetAppearance() const { return Appearance; }
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Reglage par nom -- ce qui permet de tester le montage avant qu'il
|
||||
// existe la moindre interface.
|
||||
//
|
||||
// Ces fonctions ne portent PAS le specificateur Exec, et ce n'est pas un
|
||||
// oubli : la chaine de routage des commandes console (voir Player.cpp)
|
||||
// interroge le monde, le PlayerInput, le controller, le pawn, le HUD, le
|
||||
// GameMode, le CheatManager, le GameState et le camera manager -- jamais
|
||||
// les composants, AActor ne surchargeant pas ProcessConsoleExec pour les
|
||||
// parcourir. Une UFUNCTION(Exec) posee ici serait silencieusement ignoree.
|
||||
// Les commandes vivent donc sur AFpsPlayer, qui delegue ici.
|
||||
// ------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Cherche, parmi les slots de materiau du mesh de tete, celui dont le nom
|
||||
* contient SlotHint. INDEX_NONE si aucun -- l'appelant ne pose alors rien.
|
||||
*/
|
||||
static int32 FindEyeMaterialSlot(const USkeletalMeshComponent* HeadComponent, FName SlotHint);
|
||||
|
||||
/** Categories : body, head, hair, eyebrows, beard, mustache, eyes. */
|
||||
UFUNCTION(BlueprintCallable, Category = "Appearance|Debug")
|
||||
void ApplyPartByName(const FString& Part, int32 Index);
|
||||
|
||||
/** Categories : skin, hair, eye, underwear. */
|
||||
UFUNCTION(BlueprintCallable, Category = "Appearance|Debug")
|
||||
void ApplyColorByName(const FString& Part, int32 ColorIndex);
|
||||
|
||||
/** Ecrit l'apparence courante et le nombre d'options de chaque categorie. */
|
||||
UFUNCTION(BlueprintCallable, Category = "Appearance|Debug")
|
||||
void LogAppearance() const;
|
||||
|
||||
protected:
|
||||
virtual void OnUnregister() override;
|
||||
|
||||
private:
|
||||
/**
|
||||
* Trouve le mesh porteur : celui de l'ACharacter en priorite, sinon le
|
||||
* premier SkeletalMesh de l'acteur.
|
||||
*
|
||||
* L'ordre compte et n'est pas anodin : AFpsPlayer porte AUSSI FirstPersonArms,
|
||||
* et prendre « le premier trouve » y monterait la tete du personnage sur les
|
||||
* bras vus a l'ecran.
|
||||
*/
|
||||
USkeletalMeshComponent* ResolveTargetMesh();
|
||||
|
||||
/** Cree le composant d'une categorie s'il manque, et le rend. */
|
||||
USkeletalMeshComponent* EnsurePartComponent(ECharacterPartCategory Category);
|
||||
|
||||
/** Cree un composant enfant deja attache, leader-pose et configure. */
|
||||
USkeletalMeshComponent* CreateFollowerComponent(FName ComponentName);
|
||||
|
||||
/** Assigne les meshes de corps, l'AnimBP, les pieces et le materiau d'iris. */
|
||||
void RebuildMeshes(const FCharacterBodySet& BodySet);
|
||||
|
||||
/** Pose les quatre couleurs sur les materiaux dynamiques. */
|
||||
void ApplyColors(const FCharacterBodySet& BodySet);
|
||||
|
||||
/** Pose un parametre vectoriel sur TOUS les elements d'un mesh. */
|
||||
static void TintAllElements(USkeletalMeshComponent* MeshComponent, FName Parameter, const FLinearColor& Color);
|
||||
|
||||
/** Le mesh porteur, leader de tous les autres. */
|
||||
UPROPERTY(Transient)
|
||||
TObjectPtr<USkeletalMeshComponent> TargetMesh;
|
||||
|
||||
/**
|
||||
* Un composant par categorie, indexe par ECharacterPartCategory.
|
||||
*
|
||||
* Un tableau plutot qu'un membre nomme par piece : le montage tient alors
|
||||
* dans une boucle, et ajouter une categorie ne demande qu'une valeur
|
||||
* d'enum. Une case peut rester nulle -- une silhouette sans barbe n'engendre
|
||||
* jamais le composant correspondant.
|
||||
*/
|
||||
UPROPERTY(Transient)
|
||||
TArray<TObjectPtr<USkeletalMeshComponent>> PartComponents;
|
||||
|
||||
/**
|
||||
* Les morceaux de corps au-dela du porteur. Vide aujourd'hui : le catalogue
|
||||
* n'a qu'un mesh par silhouette. C'est ici qu'atterriront les segments le
|
||||
* jour des armures, sans que la logique change.
|
||||
*/
|
||||
UPROPERTY(Transient)
|
||||
TArray<TObjectPtr<USkeletalMeshComponent>> ExtraBodyComponents;
|
||||
|
||||
FCharacterAppearance Appearance;
|
||||
|
||||
/** Faux tant qu'aucun montage n'a eu lieu : force la premiere reconstruction. */
|
||||
bool bBuilt = false;
|
||||
};
|
||||
@@ -0,0 +1,143 @@
|
||||
// Fill out your copyright notice in the Description page of Project Settings.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "CharacterAppearanceTypes.generated.h"
|
||||
|
||||
class USkeletalMesh;
|
||||
class UTexture2D;
|
||||
|
||||
/** Les deux silhouettes livrees par le pack. */
|
||||
UENUM(BlueprintType)
|
||||
enum class ECharacterBodyType : uint8
|
||||
{
|
||||
BodyA UMETA(DisplayName = "Body A"),
|
||||
BodyB UMETA(DisplayName = "Body B"),
|
||||
|
||||
/** Sentinelle, comme ECraftingStation::Count. Jamais une valeur valide. */
|
||||
Count UMETA(Hidden)
|
||||
};
|
||||
|
||||
/**
|
||||
* Les emplacements de pieces montees sur le corps.
|
||||
*
|
||||
* Sert d'index dans le tableau de composants du monteur : une seule fonction de
|
||||
* montage plutot qu'un membre nomme par piece, et ajouter une categorie ne
|
||||
* demande qu'une entree ici.
|
||||
*/
|
||||
UENUM(BlueprintType)
|
||||
enum class ECharacterPartCategory : uint8
|
||||
{
|
||||
Head,
|
||||
Hair,
|
||||
Eyebrows,
|
||||
Beard,
|
||||
Mustache,
|
||||
|
||||
Count UMETA(Hidden)
|
||||
};
|
||||
|
||||
/**
|
||||
* Une entree du catalogue : la piece que le joueur choisit dans une categorie.
|
||||
*/
|
||||
USTRUCT(BlueprintType)
|
||||
struct FCharacterPartEntry
|
||||
{
|
||||
GENERATED_BODY()
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Part")
|
||||
TObjectPtr<USkeletalMesh> Mesh;
|
||||
|
||||
/**
|
||||
* La vignette du bouton, dans la grille de l'ecran de customisation.
|
||||
* Meme type que l'icone d'UItemDataAsset, pour que les deux grilles du jeu
|
||||
* se dessinent de la meme facon.
|
||||
*/
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Part")
|
||||
TObjectPtr<UTexture2D> Icon;
|
||||
};
|
||||
|
||||
/**
|
||||
* L'apparence d'un personnage, en 11 octets.
|
||||
*
|
||||
* Des INDEX et jamais des chemins d'assets, pour deux raisons qui vont dans le
|
||||
* meme sens : un chemin coute une chaine de caracteres a chaque replication,
|
||||
* alors qu'un index tient dans un octet ; et un index se VALIDE contre le
|
||||
* catalogue, quand un chemin envoye par un client pourrait designer n'importe
|
||||
* quel asset du jeu.
|
||||
*
|
||||
* Les couleurs suivent la meme logique : un index dans la palette, pas un
|
||||
* FLinearColor. C'est ce qui permet a la struct entiere de tenir dans une
|
||||
* poignee d'octets, et de se sauvegarder telle quelle dans le .ini de
|
||||
* USurvivalUserSettings.
|
||||
*/
|
||||
USTRUCT(BlueprintType)
|
||||
struct FCharacterAppearance
|
||||
{
|
||||
GENERATED_BODY()
|
||||
|
||||
/** Index qui signifie « aucune piece » -- barbe rasee, crane nu. */
|
||||
static constexpr uint8 NoPart = 255;
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Appearance")
|
||||
ECharacterBodyType BodyType = ECharacterBodyType::BodyA;
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Appearance")
|
||||
uint8 HeadIndex = 0;
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Appearance")
|
||||
uint8 HairIndex = 0;
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Appearance")
|
||||
uint8 EyebrowsIndex = 0;
|
||||
|
||||
/** NoPart par defaut : un visage glabre est le point de depart naturel. */
|
||||
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Appearance")
|
||||
uint8 BeardIndex = NoPart;
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Appearance")
|
||||
uint8 MustacheIndex = NoPart;
|
||||
|
||||
/**
|
||||
* Les yeux ne sont pas un mesh mais un MATERIAU pose sur un slot du mesh de
|
||||
* tete -- le pack ne livre aucun `SKM_Eyes`. D'ou une categorie a part,
|
||||
* absente d'ECharacterPartCategory qui ne parle que de composants.
|
||||
*/
|
||||
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Appearance")
|
||||
uint8 EyesIndex = 0;
|
||||
|
||||
// --------------------------------------------------------------
|
||||
// Couleurs : un index dans la palette correspondante du catalogue.
|
||||
// Un bouton de l'ecran = un index, sans reglage intermediaire.
|
||||
// --------------------------------------------------------------
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Appearance|Colors")
|
||||
uint8 SkinColorIndex = 0;
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Appearance|Colors")
|
||||
uint8 HairColorIndex = 0;
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Appearance|Colors")
|
||||
uint8 EyeColorIndex = 0;
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Appearance|Colors")
|
||||
uint8 UnderwearColorIndex = 0;
|
||||
|
||||
bool operator==(const FCharacterAppearance& Other) const
|
||||
{
|
||||
return BodyType == Other.BodyType
|
||||
&& HeadIndex == Other.HeadIndex
|
||||
&& HairIndex == Other.HairIndex
|
||||
&& EyebrowsIndex == Other.EyebrowsIndex
|
||||
&& BeardIndex == Other.BeardIndex
|
||||
&& MustacheIndex == Other.MustacheIndex
|
||||
&& EyesIndex == Other.EyesIndex
|
||||
&& SkinColorIndex == Other.SkinColorIndex
|
||||
&& HairColorIndex == Other.HairColorIndex
|
||||
&& EyeColorIndex == Other.EyeColorIndex
|
||||
&& UnderwearColorIndex == Other.UnderwearColorIndex;
|
||||
}
|
||||
|
||||
bool operator!=(const FCharacterAppearance& Other) const { return !(*this == Other); }
|
||||
};
|
||||
@@ -0,0 +1,194 @@
|
||||
// Fill out your copyright notice in the Description page of Project Settings.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "CoreMinimal.h"
|
||||
#include "Engine/DataAsset.h"
|
||||
#include "CharacterAppearanceTypes.h"
|
||||
#include "CharacterPartsDataAsset.generated.h"
|
||||
|
||||
class UAnimInstance;
|
||||
class UMaterialInterface;
|
||||
class USkeletalMesh;
|
||||
class UTexture2D;
|
||||
|
||||
/**
|
||||
* Tout ce qui compose une silhouette : ses meshes de corps, son AnimBP, et les
|
||||
* pieces disponibles pour chaque categorie.
|
||||
*/
|
||||
USTRUCT(BlueprintType)
|
||||
struct FCharacterBodySet
|
||||
{
|
||||
GENERATED_BODY()
|
||||
|
||||
/** La vignette du bouton de silhouette, meme role que celle d'une piece. */
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Body")
|
||||
TObjectPtr<UTexture2D> Icon;
|
||||
|
||||
/**
|
||||
* Les morceaux du corps, dans l'ordre. Le PREMIER est le porteur : c'est lui
|
||||
* qui va sur le composant Mesh du Character et qui joue l'animation, les
|
||||
* suivants deviennent des composants enfants en leader pose.
|
||||
*
|
||||
* Une LISTE alors qu'il n'y a qu'une case aujourd'hui, et ce n'est pas de la
|
||||
* sur-conception : le pack livre exprès `SKM_BodyA_torso`, `_arms`,
|
||||
* `_legs_01/02/03`, `_hands`, `_feet`, precisement pour qu'une armure puisse
|
||||
* eteindre les segments qu'elle recouvre. Le jour venu, la case 0 deviendra
|
||||
* `SKM_BodyA_empty` -- invisible, porteur d'animation -- et les huit segments
|
||||
* suivront derriere, SANS que ce code change. Un TObjectPtr unique, lui,
|
||||
* imposerait de tout reprendre au premier plastron.
|
||||
*/
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Body")
|
||||
TArray<TObjectPtr<USkeletalMesh>> BodyMeshes;
|
||||
|
||||
/** L'AnimBP du porteur. Il change avec la silhouette, d'ou sa place ici. */
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Body")
|
||||
TSubclassOf<UAnimInstance> AnimClass;
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Parts")
|
||||
TArray<FCharacterPartEntry> Heads;
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Parts")
|
||||
TArray<FCharacterPartEntry> Hairstyles;
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Parts")
|
||||
TArray<FCharacterPartEntry> Eyebrows;
|
||||
|
||||
/** Vide pour une silhouette qui n'en porte pas -- le pack n'en donne qu'a A. */
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Parts")
|
||||
TArray<FCharacterPartEntry> Beards;
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Parts")
|
||||
TArray<FCharacterPartEntry> Mustaches;
|
||||
|
||||
/**
|
||||
* Fragment cherche dans le NOM des slots de materiau du mesh de tete pour y
|
||||
* trouver celui des yeux.
|
||||
*
|
||||
* Les yeux ne sont pas un mesh : le pack les livre comme un element du mesh
|
||||
* de tete. Il ne suffit donc pas de poser un parametre de couleur, il faut
|
||||
* REMPLACER le materiau de ce slot -- encore faut-il savoir lequel.
|
||||
*
|
||||
* Un fragment de nom et pas un index, parce qu'un index est faux deux fois :
|
||||
* il oblige a le verifier a la main dans l'editeur, et il suppose surtout
|
||||
* que les six tetes rangent leurs slots dans le MEME ordre. Les slots du
|
||||
* pack s'appellent `M_Eye_A_01`, `M_Eye`, `M_Eyes_02`... tous contiennent
|
||||
* « Eye », aucun slot de peau ne le contient.
|
||||
*
|
||||
* Si le fragment ne trouve rien, le materiau n'est PAS pose et un
|
||||
* avertissement part dans le log. C'est volontaire : poser l'oeil sur un
|
||||
* slot au hasard repeindrait le visage entier, un symptome qu'on met bien
|
||||
* plus longtemps a diagnostiquer qu'une ligne de log.
|
||||
*/
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Parts")
|
||||
FName EyeMaterialSlotHint = TEXT("Eye");
|
||||
};
|
||||
|
||||
/**
|
||||
* Le catalogue : la table de correspondance entre les index d'une
|
||||
* FCharacterAppearance et les assets reels.
|
||||
*
|
||||
* Un seul asset a remplir, et le SEUL endroit a toucher pour ajouter une
|
||||
* coiffure. C'est aussi lui qui borne ce qu'un client peut demander : une
|
||||
* apparence arrivee du reseau est passee a Sanitize(), qui ramene tout index
|
||||
* hors bornes a une valeur sure.
|
||||
*/
|
||||
UCLASS(BlueprintType)
|
||||
class SURVIVAL_PROJET_API UCharacterPartsDataAsset : public UPrimaryDataAsset
|
||||
{
|
||||
GENERATED_BODY()
|
||||
|
||||
public:
|
||||
/**
|
||||
* Une entree par valeur d'ECharacterBodyType, dans l'ordre de l'enum.
|
||||
* L'ordre EST le contrat : c'est lui qui donne son sens a BodyType.
|
||||
*/
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Catalog")
|
||||
TArray<FCharacterBodySet> BodySets;
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Palettes : une couleur = un bouton a l'ecran, sans reglage entre les
|
||||
// deux. L'ordre EST l'ordre d'affichage, et l'index qui part sur le reseau.
|
||||
//
|
||||
// Partagees par les deux silhouettes : deux nuanciers de peau a tenir a
|
||||
// jour divergeraient au premier ajout.
|
||||
// ------------------------------------------------------------------
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Catalog|Palettes")
|
||||
TArray<FLinearColor> SkinColors;
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Catalog|Palettes")
|
||||
TArray<FLinearColor> HairColors;
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Catalog|Palettes")
|
||||
TArray<FLinearColor> EyeColors;
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Catalog|Palettes")
|
||||
TArray<FLinearColor> UnderwearColors;
|
||||
|
||||
/** Les materiaux d'iris, un par forme d'oeil proposee. */
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Catalog|Palettes")
|
||||
TArray<TObjectPtr<UMaterialInterface>> EyeMaterials;
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Noms des parametres des materiaux du pack.
|
||||
//
|
||||
// Ici et pas en dur dans le C++ : ils appartiennent aux assets, pas au
|
||||
// code. Changer de pack de personnages ne doit demander qu'un nouveau
|
||||
// catalogue -- et ces noms contiennent des ESPACES, ce qu'on n'invente
|
||||
// pas de memoire.
|
||||
// ------------------------------------------------------------------
|
||||
|
||||
/** `M_Body_Base`. */
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Catalog|Material Parameters")
|
||||
FName SkinColorParameter = TEXT("Skin color");
|
||||
|
||||
/**
|
||||
* `M_Head_Base` -- le meme role que ci-dessus, mais l'autre master, et
|
||||
* surtout un NOM DIFFERENT : `Skin` cote tete, `Skin color` cote corps.
|
||||
*
|
||||
* Le master contient bien la chaine « Skin Base color », mais ce n'est pas
|
||||
* le nom du parametre expose -- verifie dans `MI_HeadA_01_a`, ou le chercher
|
||||
* ne rend aucun resultat alors que `Skin` apparait dans le groupe
|
||||
* « Base colors ». Morale : un nom de parametre se lit dans l'editeur du
|
||||
* Material Instance, jamais dans les chaines du binaire du master.
|
||||
*/
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Catalog|Material Parameters")
|
||||
FName HeadSkinColorParameter = TEXT("Skin");
|
||||
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Catalog|Material Parameters")
|
||||
FName UnderwearColorParameter = TEXT("Underware color");
|
||||
|
||||
/** `M_Hairstyle_Base`, parent des cheveux, barbes, moustaches ET sourcils. */
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Catalog|Material Parameters")
|
||||
FName HairColorParameter = TEXT("Color");
|
||||
|
||||
/** `M_Eyes_Base`. */
|
||||
UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Catalog|Material Parameters")
|
||||
FName EyeColorParameter = TEXT("Eye color");
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Lecture
|
||||
// ------------------------------------------------------------------
|
||||
|
||||
/** Le jeu de pieces d'une silhouette, ou nullptr si l'index est hors bornes. */
|
||||
const FCharacterBodySet* GetBodySet(ECharacterBodyType BodyType) const;
|
||||
|
||||
/** La liste d'une categorie pour une silhouette, vide si rien n'est defini. */
|
||||
const TArray<FCharacterPartEntry>& GetParts(ECharacterBodyType BodyType, ECharacterPartCategory Category) const;
|
||||
|
||||
/** Nombre d'options d'une categorie. Sert a borner l'UI comme la console. */
|
||||
UFUNCTION(BlueprintPure, Category = "Catalog")
|
||||
int32 GetPartCount(ECharacterBodyType BodyType, ECharacterPartCategory Category) const;
|
||||
|
||||
/**
|
||||
* Ramene une apparence dans les bornes du catalogue.
|
||||
*
|
||||
* Appelee sur le SERVEUR a la reception d'une apparence client, et au
|
||||
* chargement des reglages -- un catalogue ampute entre deux versions du jeu
|
||||
* laisserait sinon des index qui ne designent plus rien. Les pieces
|
||||
* facultatives (barbe, moustache) retombent sur NoPart, les obligatoires
|
||||
* sur 0 : mieux vaut la mauvaise tete que pas de tete.
|
||||
*/
|
||||
void Sanitize(FCharacterAppearance& InOut) const;
|
||||
};
|
||||
@@ -9,6 +9,7 @@
|
||||
class APickupItem;
|
||||
class UAnimMontage;
|
||||
class UCameraComponent;
|
||||
class UCharacterAppearanceComponent;
|
||||
class UCraftingComponent;
|
||||
class UHeadBobComponent;
|
||||
class UInputAction;
|
||||
@@ -122,6 +123,37 @@ public:
|
||||
UFUNCTION(BlueprintPure, Category = "Survie")
|
||||
USurvivalStatsComponent* GetSurvivalStats() const { return SurvivalStats; }
|
||||
|
||||
UFUNCTION(BlueprintPure, Category = "Apparence")
|
||||
UCharacterAppearanceComponent* GetAppearanceComponent() const { return AppearanceComponent; }
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Commandes console d'apparence
|
||||
//
|
||||
// Elles vivent ICI et non sur UCharacterAppearanceComponent, ou leur place
|
||||
// serait pourtant plus naturelle : la chaine de routage des commandes
|
||||
// (UPlayer::Exec, dans Player.cpp) interroge le monde, le PlayerInput, le
|
||||
// controller, le PAWN, le HUD, le GameMode, le CheatManager, le GameState
|
||||
// et le camera manager -- jamais les composants, AActor ne surchargeant pas
|
||||
// ProcessConsoleExec pour les parcourir. Une UFUNCTION(Exec) posee sur un
|
||||
// composant est silencieusement ignoree, sans le moindre message.
|
||||
//
|
||||
// Le pawn est le maillon le plus proche du composant dans cette chaine,
|
||||
// d'ou ces trois delegations d'une ligne. Elles disparaitront le jour ou
|
||||
// l'ecran de customisation existera.
|
||||
// ------------------------------------------------------------------
|
||||
|
||||
/** `EmberPart hair 3` -- body, head, hair, eyebrows, beard, mustache, eyes. */
|
||||
UFUNCTION(Exec, Category = "Apparence")
|
||||
void EmberPart(const FString& Part, int32 Index);
|
||||
|
||||
/** `EmberColor skin 2` -- skin, hair, eye, underwear. Index dans la palette. */
|
||||
UFUNCTION(Exec, Category = "Apparence")
|
||||
void EmberColor(const FString& Part, int32 ColorIndex);
|
||||
|
||||
/** Ecrit l'apparence courante et le nombre d'options de chaque categorie. */
|
||||
UFUNCTION(Exec, Category = "Apparence")
|
||||
void EmberAppearanceDump();
|
||||
|
||||
/** Sert a l'UI pour afficher la vraie touche mappee, plutot qu'un "E" ecrit en dur. */
|
||||
UFUNCTION(BlueprintPure, Category = "Input")
|
||||
const UInputAction* GetInteractAction() const { return InteractAction; }
|
||||
@@ -276,6 +308,18 @@ protected:
|
||||
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Survie")
|
||||
TObjectPtr<USurvivalStatsComponent> SurvivalStats;
|
||||
|
||||
/**
|
||||
* Monte la tete, les cheveux, la barbe et les couleurs sur le mesh 3e
|
||||
* personne.
|
||||
*
|
||||
* Sur le pawn et non sur le controller, alors que l'apparence, elle, vivra
|
||||
* sur le PlayerState : ce composant ne STOCKE rien, il assemble un corps.
|
||||
* Or c'est le corps qui meurt et reapparait, et un nouveau pawn doit se
|
||||
* remonter tout seul.
|
||||
*/
|
||||
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Apparence")
|
||||
TObjectPtr<UCharacterAppearanceComponent> AppearanceComponent;
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Enhanced Input : assets à assigner dans le Blueprint
|
||||
// ------------------------------------------------------------------
|
||||
|
||||
Reference in New Issue
Block a user