la collision ne fonctionne pas !

[pyramidal]

bonjour,

Dans ce projet Unreal Engine First Person C++ nommé drawline,je crée une classe C++ DrawDataReflect dont
DrawDataReflect.h:

// DrawDataReflect.h
//la normale de l'objet touché et le rayon reflechi ne se dessinent pas
//étudier les composantes de collision d'un acteur/objet

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "DrawDataReflect.generated.h"

UCLASS()
class DRAWLINE_API ADrawDataReflect : public AActor
{
    GENERATED_BODY()

public:
    // Constructeur
    ADrawDataReflect();

protected:
    // BeginPlay (appelé au démarrage)
    virtual void BeginPlay() override;

public:
    // Tick (appelé à chaque frame)
    virtual void Tick(float DeltaTime) override;

    // Acteur/objet qui est le point de départ du rayon dessiné
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "DrawDataReflect")
    AActor* StartActor;

    // Acteur/objet qui est le point d'arrivée du rayon dessiné
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "DrawDataReflect")
    AActor* EndActor;

    // Épaisseur du rayon
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "DrawDataReflect")
    float LineThickness = 5.0f;

    // Durée du rayon (en secondes)
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "DrawDataReflect")
    float LineDuration = -1.0f; // -1 pour une durée infinie

    // Couleur du rayon
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "DrawDataReflect")
    FLinearColor LineColor = FLinearColor::Red;

    // Longueur du rayon réfléchi
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "DrawDataReflect")
    float ReflectedLineLength = 500.0f;

    // Point d'impact du rayon (sortie)
    UPROPERTY(BlueprintReadOnly, Category = "DrawDataReflect")
    FVector ImpactPoint = FVector::ZeroVector;

    // Vecteur réfléchi (sortie)
    UPROPERTY(BlueprintReadOnly, Category = "DrawDataReflect")
    FVector ReflectedVector = FVector::ZeroVector;
};

et DrawDataReflect.cpp:

// DrawDataReflect.cpp

#include "DrawDataReflect.h"
#include "DrawDebugHelpers.h"
#include "Logging/LogMacros.h" // Inclure le header pour UE_LOG()
#include "Engine/Engine.h" 

ADrawDataReflect::ADrawDataReflect()
{
    PrimaryActorTick.bCanEverTick = true;
}

void ADrawDataReflect::BeginPlay()
{
    Super::BeginPlay();
}

void ADrawDataReflect::Tick(float DeltaTime)
{
    Super::Tick(DeltaTime);

    if (StartActor && EndActor)
    {
        FVector StartLocation = StartActor->GetActorLocation();
        FVector EndLocation = EndActor->GetActorLocation();

        FHitResult HitResult;
        FCollisionQueryParams CollisionParams;

        bool bHit = GetWorld()->LineTraceSingleByChannel(
            HitResult,
            StartLocation,
            EndLocation,
            ECollisionChannel::ECC_Visibility,
            CollisionParams
        );

        DrawDebugLine(
            GetWorld(),
            StartLocation,
            EndLocation,
            LineColor.ToFColor(true),
            false,
            LineDuration,
            0,
            LineThickness
        );

        if (bHit)
        {
            AActor* HitActor = HitResult.GetActor();
            if (HitActor)
            {
                UE_LOG(LogTemp, Warning, TEXT("Raycast a touché quelque chose: %s"), *HitActor->GetName());
                FString HitActorLabel = HitActor->GetActorLabel();
                UE_LOG(LogTemp, Warning, TEXT("Label de l'objet touché: %s"), *HitActorLabel);
                ImpactPoint = HitResult.ImpactPoint;

                // Calcul du vecteur réfléchi en utilisant FMath::GetReflectionVector()
                FVector IncidentVector = (HitResult.ImpactPoint - StartLocation).GetSafeNormal();
                FVector NormalVector = HitResult.Normal;
                ReflectedVector = FMath::GetReflectionVector(IncidentVector, NormalVector);

                // Dessiner le rayon réfléchi
                DrawDebugLine(
                    GetWorld(),
                    ImpactPoint,
                    ImpactPoint + ReflectedVector * ReflectedLineLength,
                    LineColor.ToFColor(true),
                    false,
                    LineDuration,
                    0,
                    LineThickness
                );

                // Dessiner la normale
                DrawDebugLine(
                    GetWorld(),
                    ImpactPoint,
                    ImpactPoint + NormalVector * 100.0f,
                    FColor::Blue,
                    false,
                    LineDuration,
                    0,
                    LineThickness
                );
            }
            else
            {
                UE_LOG(LogTemp, Warning, TEXT("Raycast a touché quelque chose, mais HitResult.GetActor() est nul."));
            }
        }
        else
        {
            //UE_LOG(LogTemp, Warning, TEXT("Raycast n'a rien touché."));
            ImpactPoint = EndLocation;
            ReflectedVector = FVector::ZeroVector;
        }
    }
    else
    {
        UE_LOG(LogTemp, Warning, TEXT("StartActor ou EndActor non valides."));
    }
}

problème:
Le message “Le rayon a touché un objet” n’apparaît jamais dans le journal donc j’en conclus qu’il n’y a jamais de collision.Pourquoi cela?
Quel bon préreglage de collision dois-je choisir sur l’objet touché par le rayon qui est bien visible?
Le point d’impact apparaît dans le journal

merci de votre aide