Guide de développement du décalque projeté vidéo

using LCCCore;
using UnityEngine;
using UnityEngine.Video;

public class VideoStreaming : MonoBehaviour
{
    [Header("Requis")]
    [Tooltip("L'instance LCCManager de la scène")]
    public LCCManager m_manager;
    [Tooltip("Un chemin de scène LCC valide")]
    public string m_filePath;

    [Header("Source vidéo (les images décodées sont projetées comme décalque)")]
    [Tooltip("Clip vidéo à projeter. Prioritaire sur l'URL ci-dessous")]
    public VideoClip m_videoClip;
    [Tooltip("Chemin / URL du fichier vidéo, utilisé lorsqu'aucun clip n'est assigné (par ex. file:///D:/xxx.mp4)")]
    public string m_videoUrl;
    [Tooltip("Lecture en boucle")]
    public bool m_videoLoop = true;

    [Header("Projecteur (projette le long de +Z)")]
    [Tooltip("Pose du projecteur. Laissez vide pour utiliser le transform de cet objet")]
    public Transform m_projector;
    [Range(1f, 179f)] public float m_fov = 60f;
    [Tooltip("Ratio d'aspect de la projection ; <=0 utilise automatiquement le ratio d'aspect de la vidéo")]
    public float m_aspect = 0f;
    public float m_near = 0.1f;
    public float m_far = 100f;

    [Header("Apparence du décalque")]
    [Range(0f, 1f)] public float m_opacity = 1.0f;
    [Range(0f, 0.5f)][Tooltip("Largeur du fondu de bord (ratio UV). 0 = bord dur")]
    public float m_edgeFade = 0.1f;
    [Tooltip("Actualiser la projection à chaque image, afin de pouvoir faire glisser le projecteur / ajuster les paramètres à l'exécution")]
    public bool m_updateEveryFrame = true;

    [Header("Occlusion culling (PC/Mac uniquement)")]
    [Tooltip("Lorsqu'il est activé, les points de face arrière/occlus derrière la géométrie avant ne sont plus colorés par le décalque (effet projecteur de diapositives) ; lorsqu'il est désactivé, c'est une radiographie")]
    public bool m_occlusion = false;
    [Range(0f, 1f)][Tooltip("Seuil d'opacité : seuls les splats avec une opacité >= cette valeur contribuent à la carte de profondeur, filtrant les points flottants/brumeux. 0 = tous participent")]
    public float m_occlusionCutoff = 0f;
    [Range(0f, 0.5f)][Tooltip("Tolérance de profondeur relative. Trop petite -> auto-occlusion près de la surface ; trop grande -> coloration radiographique qui fuit. Défaut 0.05")]
    public float m_occlusionBias = 0.05f;
    [Range(0, 16)][Tooltip("Plafond de rayon d'empreinte carrée (px), le principal réglage pour supprimer la transparence radiographique. 0 = un seul texel, défaut 2")]
    public int m_occlusionFootprint = 2;
    [Tooltip("Résolution de la carte de profondeur (px, puissance de deux 256~4096). Réduisez-la pour combler les trous en angle rasant. Défaut 1024")]
    public int m_occlusionResolution = 1024;

    // -- État d'exécution --
    private bool m_loaded;
    private bool m_lastOcclusion;
    private float m_lastCutoff = float.NaN;
    private float m_lastBias = float.NaN;
    private int m_lastFootprint = -1;
    private int m_lastResolution = -1;

    // -- État vidéo --
    private VideoPlayer m_videoPlayer;
    private RenderTexture m_videoRT;   // VideoPlayer décode la vidéo ici (GPU)
    private Texture2D m_frameTex;      // l'image actuelle est copiée ici et fournie au décalque
    private bool m_videoReady;
    private long m_lastVideoFrame = -1; // le dernier index d'image poussé vers le décalque

    void Start()
    {
        if (m_manager == null || string.IsNullOrEmpty(m_filePath))
        {
            Debug.LogError("[VideoStreaming] m_manager ou m_filePath n'est pas assigné.");
            enabled = false;
            return;
        }

        // 1) Initialiser le pipeline de rendu en mode éditeur PC à scène unique
        m_manager.SetPlatformType(PlatformType.PC);
        m_manager.SwitchRenderPass(ActiveRenderMode.SingleRender);
        m_manager.SetEditorMode(true);

        // 2) Démarrer le décodage de la vidéo en parallèle avec le chargement de la scène
        SetupVideo();

        // 3) Charger la scène du nuage de points, puis activer le décalque (le décalque est un état global ; il est plus sûr de le définir après que la scène est prête)
        var renderer = m_manager.GetRender(this.transform);
        Debug.Log($"[VideoStreaming] Début du chargement : {m_filePath}");
        renderer.Load(m_filePath,
            _ => { /* callback de progression, inutilisé dans cet exemple */ },
            OnSceneLoaded);
    }

    /// <summary>Créer le VideoPlayer à l'exécution et commencer à préparer le clip/l'URL.</summary>
    private void SetupVideo()
    {
        m_videoPlayer = gameObject.AddComponent<VideoPlayer>();
        m_videoPlayer.playOnAwake = false;
        m_videoPlayer.isLooping = m_videoLoop;
        m_videoPlayer.renderMode = VideoRenderMode.RenderTexture;
        m_videoPlayer.audioOutputMode = VideoAudioOutputMode.None; // démo : pas d'audio

        if (m_videoClip != null)
        {
            m_videoPlayer.source = VideoSource.VideoClip;
            m_videoPlayer.clip = m_videoClip;
        }
        else
        {
            m_videoPlayer.source = VideoSource.Url;
            m_videoPlayer.url = m_videoUrl;
        }

        // Allouer le tampon d'image une fois la résolution connue, puis démarrer la lecture.
        m_videoPlayer.prepareCompleted += OnVideoPrepared;
        m_videoPlayer.Prepare();
    }

    private void OnVideoPrepared(VideoPlayer vp)
    {
        int w = (int)vp.width;
        int h = (int)vp.height;

        m_videoRT = new RenderTexture(w, h, 0, RenderTextureFormat.ARGB32);
        m_videoRT.Create();
        vp.targetTexture = m_videoRT;

        m_frameTex = new Texture2D(w, h, TextureFormat.RGBA32, false);

        m_videoReady = true;
        vp.Play();
        Debug.Log($"[VideoStreaming] Vidéo préparée : {w}x{h}, lecture en cours.");
    }

    private void OnSceneLoaded()
    {
        Debug.Log("[VideoStreaming] Chargement terminé, activation de la projection du décalque.");

        // -- Projection de base : 5 API --
        // Le contenu de la texture est piloté par les images décodées dans Update() ; ici, nous poussons d'abord l'image actuellement disponible.
        if (m_frameTex != null) m_manager.SetDecalTexture(m_frameTex);
        m_manager.SetDecalOpacity(m_opacity);        // opacité globale
        m_manager.SetDecalEdgeFade(m_edgeFade);      // fondu de bord
        ApplyProjection();                           // pose du projecteur (appelle en interne SetDecalProjection)
        m_manager.SetDecalEnabled(true);             // activer le décalque (mot-clé _DECAL)

        // -- Occlusion culling : 2 API -- doit être après ApplyProjection (la carte de profondeur a besoin d'une matrice VP de projecteur valide)
        m_manager.SetDecalOcclusionSettings(BuildOcclusionSettings());
        m_manager.SetDecalOcclusion(m_occlusion);
        CacheOcclusionState();

        m_loaded = true;
    }

    void Update()
    {
        if (!m_loaded) return;

        // --- Mise à jour de l'image vidéo, découplée des FPS de rendu ---
        // VideoPlayer.frame ne s'incrémente qu'à la vitesse de lecture propre de la vidéo. Même si la scène rend à des centaines de FPS,
        // l'index reste le même entre deux images vidéo adjacentes, donc ce n'est que lorsqu'une nouvelle image décodée apparaît réellement
        // que nous copions cette image et poussons à nouveau la texture du décalque.
        if (m_videoReady && m_videoPlayer.frame != m_lastVideoFrame)
        {
            m_lastVideoFrame = m_videoPlayer.frame;

            // Copier le RenderTexture sur le GPU vers le Texture2D accepté par l'API du décalque.
            // Cela ne s'exécute qu'à la fréquence d'images de la vidéo, donc le coût de lecture est gérable.
            RenderTexture prev = RenderTexture.active;
            RenderTexture.active = m_videoRT;
            m_frameTex.ReadPixels(new Rect(0, 0, m_videoRT.width, m_videoRT.height), 0, 0, false);
            m_frameTex.Apply(false);
            RenderTexture.active = prev;

            m_manager.SetDecalTexture(m_frameTex);
        }

        // basculer l'occlusion à l'exécution
        if (m_occlusion != m_lastOcclusion)
        {
            m_manager.SetDecalOcclusion(m_occlusion);
            m_lastOcclusion = m_occlusion;
        }

        // si un paramètre de qualité d'occlusion a changé -> pousser la struct une fois
        if (!Mathf.Approximately(m_occlusionCutoff, m_lastCutoff) ||
            !Mathf.Approximately(m_occlusionBias, m_lastBias) ||
            m_occlusionFootprint != m_lastFootprint ||
            m_occlusionResolution != m_lastResolution)
        {
            m_manager.SetDecalOcclusionSettings(BuildOcclusionSettings());
            CacheOcclusionState();
        }

        // actualiser le projecteur / l'apparence à chaque image pour un réglage pratique à l'exécution
        if (!m_updateEveryFrame) return;
        m_manager.SetDecalOpacity(m_opacity);
        m_manager.SetDecalEdgeFade(m_edgeFade);
        ApplyProjection();
    }

    /// <summary>Construire la matrice de projection à partir de la pose actuelle du projecteur et des paramètres de perspective.</summary>
    private void ApplyProjection()
    {
        Transform p = m_projector != null ? m_projector : this.transform;
        float aspect = m_aspect > 0f
            ? m_aspect
            : (m_videoRT != null ? (float)m_videoRT.width / m_videoRT.height : 1920.0f / 1080.0f);
        m_manager.SetDecalProjection(p.position, p.rotation, m_fov, aspect, m_near, m_far);
    }

    /// <summary>Rassembler les 4 paramètres d'occlusion dans une struct.</summary>
    private DecalOcclusionSettings BuildOcclusionSettings()
    {
        return new DecalOcclusionSettings
        {
            opacityCutoff  = m_occlusionCutoff,
            depthBias      = m_occlusionBias,
            footprintMaxPx = m_occlusionFootprint,
            resolution     = m_occlusionResolution,
        };
    }

    private void CacheOcclusionState()
    {
        m_lastOcclusion  = m_occlusion;
        m_lastCutoff     = m_occlusionCutoff;
        m_lastBias       = m_occlusionBias;
        m_lastFootprint  = m_occlusionFootprint;
        m_lastResolution = m_occlusionResolution;
    }

    private void OnDestroy()
    {
        if (m_videoPlayer != null) m_videoPlayer.prepareCompleted -= OnVideoPrepared;
        if (m_videoRT != null)
        {
            m_videoRT.Release();
            Destroy(m_videoRT);
        }
        if (m_frameTex != null) Destroy(m_frameTex);
    }

    // -- Points d'entrée de débogage pratiques (clic droit dans l'Inspecteur) --
    [ContextMenu("Décalque activé")]  private void DecalOn()  { m_manager?.SetDecalEnabled(true); }
    [ContextMenu("Décalque désactivé")] private void DecalOff() { m_manager?.SetDecalEnabled(false); }
    [ContextMenu("Occlusion activée")]  private void OcclusionOn()  { m_occlusion = true;  m_manager?.SetDecalOcclusion(true);  m_lastOcclusion = true; }
    [ContextMenu("Occlusion désactivée")] private void OcclusionOff() { m_occlusion = false; m_manager?.SetDecalOcclusion(false); m_lastOcclusion = false; }
}

if (m_videoReady && m_videoPlayer.frame != m_lastVideoFrame)
{
    m_lastVideoFrame = m_videoPlayer.frame;

    // Ne lire qu'une fois et pousser le décalque lorsqu'une nouvelle image décodée arrive
    RenderTexture prev = RenderTexture.active;
    RenderTexture.active = m_videoRT;
    m_frameTex.ReadPixels(new Rect(0, 0, m_videoRT.width, m_videoRT.height), 0, 0, false);
    m_frameTex.Apply(false);
    RenderTexture.active = prev;

    m_manager.SetDecalTexture(m_frameTex);
}

// Valeur de retour : void
public void SetDecalTexture(Texture2D tex)