Guide de développement du décalque projeté

Aperçu de la fonctionnalité

La projection de décalque (Decal Projector) projette une image 2D sur la surface du nuage de points 3DGS comme un projecteur de diapositives. Le projecteur est un frustum de perspective fixe dans l'espace mondial ; le nuage de points à l'intérieur du frustum est recouvert par la couleur du décalque, et le nuage de points à l'extérieur du frustum n'est pas affecté. Le décalque est un état d'ombrage global qui a un effet d'ombrage cohérent sur toute la scène 3DGS.

En plus de la projection de base, l'occlusion culling peut être activée de manière optionnelle. Par défaut, le décalque est semblable à une radiographie : comme le 3DGS n'a pas de notion de surface, le décalque pénètre jusqu'aux faces arrière occluses par les objets avant et traverse toute la scène 3DGS. Après l'activation de l'occlusion culling, seule la surface avant faisant face au projecteur est colorée, tandis que les faces arrière occluses et les scènes occluses ne sont plus colorées, produisant un effet réaliste de projecteur de diapositives.

Remarque :

Le décalque et l'occlusion culling ne prennent effet que sur PC / Mac (pipeline URP). L'appel des interfaces associées sur les plateformes mobiles ou VR est ignoré par le SDK, qui affiche un journal d'avertissement. Vous n'avez pas besoin d'effectuer de vérifications de plateforme côté métier, mais ne vous attendez pas à voir l'effet sur ces plateformes.

Étape 1 : Créer la scène et les GameObjects

Créez une toute nouvelle scène dans Unity. Unity crée Caméra principale et Lumière directionnelle par défaut.

Configurer la Caméra principale

Sélectionnez Caméra principale dans la fenêtre Hiérarchie, et définissez ses propriétés dans la fenêtre Inspecteur comme illustré ci-dessous.

Définir les propriétés de la Caméra principale

Créer LCCManager

Faites un clic droit dans une zone vide de la fenêtre Hiérarchie, sélectionnez Créer vide dans le menu contextuel pour créer un GameObject vide, nommez-le LCCManager, normalisez son Transform, et ajoutez-y le script LCCManager via Ajouter un composant.

Créer le GameObject LCCManager et ajouter le script LCCManager

Créer LCCRenderer

Faites un clic droit dans une zone vide de la fenêtre Hiérarchie, sélectionnez Créer vide pour créer un GameObject vide, nommez-le LCCRenderer, et définissez son Transform sur Rotation.x = -90 et Scale.x = -1.

Créer LCCRenderer et définir son Transform (Rotation.x = -90, Scale.x = -1)

Remarque :

Les réglages de Transform du GameObject LCCRenderer (Rotation.x = -90, Scale.x = -1) l'alignent avec le système de coordonnées des données LCC. Pour plus de détails sur l'alignement du système de coordonnées, voir « Système de coordonnées des données LCC » dans Introduction au SDK Unity.

Créer le Projecteur

Faites un clic droit dans une zone vide de la fenêtre Hiérarchie, sélectionnez Créer vide pour créer un GameObject vide nommé Projector. Le but de la création de cet objet vide est d'utiliser son composant Transform pour contrôler la position et l'orientation du projecteur ; après l'avoir associé au code du script, vous pouvez ajuster les propriétés du projecteur à l'exécution. Le projecteur projette le long de sa direction +Z, et ses propriétés peuvent être définies selon les besoins.

Créer le GameObject vide Projector comme projecteur (+Z est la direction de projection)

Étape 2 : Ajouter une Render Feature

1. Dans la barre de menus Unity, sélectionnez Fichier → Paramètres du projet, choisissez Graphismes à gauche, et confirmez le Default Render Pipeline Asset actuel. Cet exemple utilise URP (Universal Render Pipeline Asset).

Confirmer le Default Render Pipeline Asset dans les paramètres Graphismes

2. Cliquez sur cet Asset, localisez le fichier d'asset correspondant dans la fenêtre Projet, et trouvez son Renderer associé (URP_Renderer.asset dans cet exemple).

3. Sélectionnez ce fichier d'asset Renderer, cliquez sur Add Renderer Feature dans la fenêtre Inspecteur, et ajoutez la Decal Depth Feature.

Ajouter la Decal Depth Feature au Renderer URP

Remarque :

La Decal Depth Feature est un prérequis pour l'occlusion culling. Si vous n'utilisez que la projection de base (décalque radiographique), vous n'avez pas besoin de l'ajouter ; mais pour activer l'occlusion culling, vous devez d'abord enregistrer cette Feature dans l'URP Renderer Asset, sinon la carte de profondeur d'occlusion ne sera pas générée et l'occlusion ne prendra pas effet.

Étape 3 : Écrire le script

Créez un nouveau script C# nommé Decal.cs. Le code complet ci-dessous simule la perspective de l'intégrateur et couvre les 7 méthodes liées au décalque (5 pour la projection de base + 2 pour l'occlusion culling) ; il peut être copié directement dans votre projet.

using LCCCore;
using UnityEngine;

/// <summary>
/// Projection de décalque — exemple d'utilisation minimal pour développeur.
///
/// Ce script simule un « script intégrateur » : il n'appelle que les API publiques de LCCManager et ne touche pas aux internes du SDK.
/// Couvre les 7 API de décalque :
///   Projection de base (5) : SetDecalEnabled / SetDecalTexture / SetDecalProjection / SetDecalOpacity / SetDecalEdgeFade
///   Occlusion culling (2) : SetDecalOcclusion / SetDecalOcclusionSettings
///
/// Étapes d'utilisation :
///   1) Créez un GameObject vide et attachez ce script ;
///   2) Dans l'Inspecteur, faites glisser le LCCManager de la scène vers m_manager ;
///   3) Définissez m_filePath sur un chemin de scène LCC valide ;
///   4) Faites glisser l'image à projeter dans m_decalTexture (recommandé d'activer Read/Write dans ses paramètres d'importation) ;
///   5) Faites glisser un objet vide dans m_projector comme projecteur (laissez vide pour utiliser cet objet) ; son axe +Z est la direction de projection ;
///   6) Jouez. Après la fin du chargement de la scène, le décalque s'active automatiquement ; faites glisser le projecteur pour voir le décalque sur le nuage de points en temps réel.
///
/// Remarque sur les plateformes : le décalque et l'occlusion culling ne prennent effet que sur PC/Mac (URP). Les appels sur mobile/VR sont ignorés par le SDK et consignés comme avertissements.
/// </summary>
public class Decal : 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;
    [Tooltip("L'image du décalque à projeter. RGB=couleur, A=masque propre du décalque")]
    public Texture2D m_decalTexture;

    [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 l'image du décalque")]
    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;

    void Start()
    {
        if (m_manager == null || string.IsNullOrEmpty(m_filePath))
        {
            Debug.LogError("[DecalDemo] 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) Charger la scène du nuage de points, puis activer le décalque après la fin (le décalque est un état global ; le définir après que la scène est prête est le plus sûr)
        var renderer = m_manager.GetRender(this.transform);
        Debug.Log($"[DecalDemo] Début du chargement : {m_filePath}");
        renderer.Load(m_filePath,
            _ => { /* callback de progression, inutilisé dans l'exemple */ },
            OnSceneLoaded);
    }

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

        // -- Projection de base : 5 API --
        m_manager.SetDecalTexture(m_decalTexture);   // contenu du décalque
        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 VP de projecteur valide)
        m_manager.SetDecalOcclusionSettings(BuildOcclusionSettings());
        m_manager.SetDecalOcclusion(m_occlusion);
        CacheOcclusionState();

        m_loaded = true;
    }

    /// <summary>
    /// Uniquement à des fins de démonstration. Dans les projets réels, pour de meilleures performances, vous n'avez pas besoin d'appeler
    /// SetDecalProjection / SetDecalOpacity / SetDecalEdgeFade à chaque image dans Update() ;
    /// n'appelez l'API correspondante que lorsque le paramètre change.
    /// </summary>
    void Update()
    {
        if (!m_loaded) return;

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

        // 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 débogage en temps réel pratique
        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_decalTexture != null ? (float)m_decalTexture.width / m_decalTexture.height : 1f);
        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;
    }

    // -- 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; }
}

Remarque :

Le décalque est un état d'ombrage global et doit être défini après la fin du chargement de la scène LCC (c'est-à-dire dans le callback onComplete).

L'exemple place SetDecalTexture / SetDecalProjection / SetDecalEnabled dans le callback de fin de Load (OnSceneLoaded) pour éviter de les définir avant que le nuage de points ne soit prêt.

Les API liées à l'occlusion culling SetDecalOcclusionSettings / SetDecalOcclusion doivent être appelées après ApplyProjection (c'est-à-dire SetDecalProjection), car la carte de profondeur d'occlusion a besoin d'une matrice vue-projection de projecteur valide.

Étape 4 : Attacher le script et configurer les propriétés

1. Attachez le script Decal.cs au GameObject LCCRenderer dans la fenêtre Hiérarchie.
2. Dans la fenêtre Inspecteur, faites glisser le GameObject LCCManager sur la propriété Manager du script.
3. Faites glisser le GameObject Projector sur la propriété Projector du script.
4. Renseignez le chemin du fichier LCC dans la propriété File Path du script, et faites glisser l'image de la texture du décalque sur la propriété Decal Texture.
5. Les autres paramètres de propriété peuvent être ajustés selon les besoins ; la signification de chaque propriété est indiquée dans le tableau ci-dessous.

Paramètres des propriétés de l'Inspecteur pour le script Decal

Étape 5 : Exécuter et observer l'effet

Cliquez sur le bouton Play dans Unity. Après la fin du chargement de la scène, le décalque s'active automatiquement. Lorsque Update Every Frame est coché, vous pouvez directement faire glisser l'objet projecteur dans la vue Scène pendant l'exécution et voir le décalque se déplacer sur la surface 3DGS en temps réel ; l'ajustement de paramètres tels que Opacity et Edge Fade prend également effet immédiatement. Le menu contextuel du composant de script fournit également quatre raccourcis — Décalque activé/désactivé et Occlusion activée/désactivée — pour vérifier commodément l'effet d'activation/désactivation séparément.

Décalque projeté sur la surface 3DGS après l'exécution (projection de base, pénétration radiographique)

Après l'activation de l'occlusion culling, seule la surface avant faisant face au projecteur est colorée (effet projecteur de diapositives)

FAQ : Désactiver le mode de compatibilité

Si la fenêtre Console de Unity signale des erreurs et qu'aucun effet de décalque n'apparaît, désactivez le mode de compatibilité : ouvrez le panneau des paramètres via Édition → Paramètres du projet → Graphismes, sélectionnez l'onglet URP, et ne cochez pas la case après Render Graph → Compatibility Mode (Render Graph Disabled).

Ne pas cocher le mode de compatibilité Render Graph (Render Graph Disabled)

Occlusion culling et réglage

L'occlusion culling doit être activée après la configuration du projecteur. L'exemple appelle d'abord SetDecalProjection dans le callback de fin de chargement de la scène, puis appelle SetDecalOcclusionSettings et SetDecalOcclusion, pour garantir que la carte de profondeur d'occlusion obtienne une matrice vue-projection de projecteur valide. À l'exécution, activez la case Occlusion dans l'Inspecteur pour voir les blocs pénétrés être éliminés et seule la surface avant faisant face au projecteur être conservée.

Prérequis :

Avant d'activer l'occlusion culling, la Decal Depth Feature doit déjà être enregistrée dans l'URP Renderer Asset (dans ce projet, elle a été écrite dans URP_Renderer.asset en tant que sous-asset). Si elle n'est pas enregistrée, la carte de profondeur d'occlusion ne sera pas générée et l'occlusion ne prendra pas effet.

La qualité de l'occlusion est contrôlée par quatre paramètres, livrés en une seule fois via une struct. Les quatre sont mutuellement orthogonaux ; réglez-les selon le tableau ci-dessous :

Étapes clés

Les étapes clés pour implémenter le décalque projeté :

1. Créez l'objet vide Projector dans la scène comme projecteur ; son axe +Z est la direction de projection.
2. Si l'occlusion culling est nécessaire, assurez-vous que la Decal Depth Feature a été ajoutée au Renderer URP.
3. Après la fin du chargement de la scène LCC, définissez la texture du décalque, l'apparence et la pose du projecteur dans l'ordre, puis activez le décalque (SetDecalEnabled(true)).
4. Les API d'occlusion culling SetDecalOcclusionSettings / SetDecalOcclusion doivent être appelées après SetDecalProjection.

API liées au décalque

Les méthodes suivantes se trouvent toutes sur la classe façade LCCManager et ne prennent effet que sur PC / Mac (pipeline URP) ; les appels sur mobile / VR sont ignorés et un avertissement est affiché.

SetDecalEnabled

// Valeur de retour : void
public void SetDecalEnabled(bool enable)

Active/désactive la projection de décalque. Lorsqu'elle est activée, les paramètres d'opacité / de fondu de bord actuellement mis en cache sont poussés vers le GPU et le mot-clé de shader _DECAL est activé. Le décalque est un état global fixé dans le monde, cohérent pour toutes les caméras. Vous devez également appeler SetDecalTexture et SetDecalProjection pour définir le contenu et la pose du projecteur.

Exemple d'utilisation :

m_manager.SetDecalEnabled(true);
m_manager.SetDecalTexture(decalTex);
m_manager.SetDecalProjection(projectorPos, projectorRot, 60f, 1.778f, 0.1f, 20f);

Remarques :

• Lorsqu'il est désactivé, seul le mot-clé _DECAL est désactivé ; la texture / les paramètres mis en cache ne sont pas effacés.

SetDecalTexture

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

Définit la texture du décalque. RGB est la couleur et A est le masque propre du décalque, qui est multiplié avec l'opacité globale et le fondu de bord.

Exemple d'utilisation :

m_manager.SetDecalTexture(logoTex);

Remarques :

• Passer null efface la référence de texture globale.

SetDecalProjection

// Valeur de retour : void
public void SetDecalProjection(Vector3 pos, Quaternion rot, float fov, float aspect, float near, float far)

Définit la pose et les paramètres de perspective du projecteur de décalque. Le projecteur projette le long de sa direction avant (+Z), et les points à l'intérieur du frustum sont recouverts par le décalque.

Exemple d'utilisation :

m_manager.SetDecalProjection(new Vector3(0, 10, 0), Quaternion.Euler(90, 0, 0), 60f, 1.778f, 0.1f, 20f);

Remarques :

• Si SetDecalOcclusion(true) est déjà activé, cette méthode transmet de manière synchrone la nouvelle VP / vue à la Decal Depth Feature.

SetDecalOpacity

// Valeur de retour : void
public void SetDecalOpacity(float opacity)

Définit l'opacité globale du décalque, en la poussant immédiatement vers le GPU et en la mettant en cache pour la réutiliser la prochaine fois que SetDecalEnabled(true) est appelé.

Exemple d'utilisation :

m_manager.SetDecalOpacity(0.8f);

Remarques :

• Plage [0, 1] ; les valeurs hors plage sont automatiquement bornées.

SetDecalEdgeFade

// Valeur de retour : void
public void SetDecalEdgeFade(float edgeFade)

Définit la largeur du fondu de bord du décalque. 0 est un bord dur, et plus la valeur est grande, plus la transition de bord est douce.

Exemple d'utilisation :

m_manager.SetDecalEdgeFade(0.1f);

Remarques :

• Plage [0, 0.5) ; les valeurs hors plage sont automatiquement bornées.

SetDecalOcclusion

// Valeur de retour : void
public void SetDecalOcclusion(bool enable)

Active/désactive l'occlusion culling du décalque (basée sur la carte de profondeur du projecteur), qui est orthogonale à la fonctionnalité d'ombre et indépendamment activée/désactivée. SetDecalProjection doit avoir été appelé pour définir le projecteur avant l'activation, sinon la carte de profondeur n'a pas de VP valide.

Exemple d'utilisation :

m_manager.SetDecalOcclusion(true);

Remarques :

• Pris en charge uniquement sur URP (les appels sur le pipeline Built-in sont sans effet et affichent un journal).
• Nécessite que la Decal Depth Feature soit enregistrée dans l'URP Renderer Asset.
• Dépend des paramètres de qualité configurés par SetDecalOcclusionSettings.

SetDecalOcclusionSettings

// Valeur de retour : void
public void SetDecalOcclusionSettings(DecalOcclusionSettings settings)

Définit tous les paramètres de qualité de l'occlusion culling du décalque en une seule fois (voir la struct ci-dessous et le tableau « Occlusion culling et réglage » pour la signification des quatre éléments).

Exemple d'utilisation :

m_manager.SetDecalOcclusionSettings(DecalOcclusionSettings.Default);
m_manager.SetDecalOcclusionSettings(new DecalOcclusionSettings {
    opacityCutoff = 0.1f,
    depthBias = 0.05f,
    footprintMaxPx = 2,
    resolution = 1024
});

Remarques :

• Peut être ajusté à tout moment ; les paramètres sont immédiatement poussés vers le GPU et la Decal Depth Feature.
• La modification de resolution déclenche une reconstruction du RT de la carte de profondeur.

Structures de données associées

DecalOcclusionSettings

public struct DecalOcclusionSettings {
    public float opacityCutoff;   // [0,1] opacité minimale pour qu'un splat participe à la carte de profondeur, défaut 0 (tous participent)
    public float depthBias;       // ratio de tolérance de profondeur relative, défaut 0.05
    public int   footprintMaxPx;  // plafond de rayon d'empreinte carrée (px), 0~16, défaut 2
    public int   resolution;      // résolution de la carte de profondeur (px, puissance de deux, 256~4096), défaut 1024

    public static DecalOcclusionSettings Default { get; } // cutoff=0, bias=0.05, footprint=2, resolution=1024
}

Utilisé par SetDecalOcclusionSettings() ; la valeur par défaut peut être obtenue via DecalOcclusionSettings.Default.

Remarques

• Efficace uniquement sur PC / Mac. Les appels aux interfaces liées au décalque sur les plateformes mobiles et VR sont ignorés et affichent un avertissement. Vous n'avez pas besoin d'effectuer de vérifications de plateforme côté métier, mais ne vous attendez pas à voir l'effet sur ces plateformes.
• Il est recommandé de définir le décalque après la fin du chargement de la scène. Le décalque est un état d'ombrage global ; l'exemple place SetDecalTexture / SetDecalProjection / SetDecalEnabled dans le callback de fin de Load pour éviter de les définir avant que le nuage de points ne soit prêt.
• L'occlusion culling dépend de deux prérequis. Premièrement, l'URP Renderer Asset a enregistré la Decal Depth Feature ; deuxièmement, SetDecalProjection a été appelé pour définir le projecteur. L'occlusion ne prend pas effet si l'un des deux manque.
• La projection statique n'a presque aucun surcoût supplémentaire. La carte de profondeur d'occlusion n'est recalculée que lorsque la pose du projecteur ou le nuage de points change ; lorsque le projecteur est stationnaire, il n'y a aucun calcul supplémentaire par image.