Ontwikkelgids voor geprojecteerde decal

Functieoverzicht

Decal-projectie (Decal Projector) projecteert een 2D-afbeelding zoals een diaprojector op het oppervlak van de 3DGS-puntenwolk. De projector is een vast perspectieffrustum in wereldruimte; de puntenwolk binnen het frustum wordt bedekt door de decal-kleur en de puntenwolk buiten het frustum wordt niet beïnvloed. De decal is een globale shading-status die een consistent shading-effect heeft op de hele 3DGS-scène.

Bovenop de basisprojectie kan optioneel occlusie-culling worden ingeschakeld. Standaard is de decal röntgenachtig: omdat 3DGS zelf geen concept van een oppervlak heeft, dringt de decal door tot de achtervlakken die door voorste objecten worden afgeschermd en gaat hij door de hele 3DGS-scène. Nadat occlusie-culling is ingeschakeld, wordt alleen het voorste oppervlak dat naar de projector is gericht gekleurd, terwijl de afgeschermde achtervlakken en afgeschermde scènes niet langer worden gekleurd, wat een realistisch diaprojector-effect oplevert.

Opmerking:

Decal en occlusie-culling zijn alleen effectief op pc / Mac (URP-pipeline). Het aanroepen van de gerelateerde interfaces op mobiele of VR-platformen wordt door de SDK genegeerd, die een waarschuwingslog afdrukt. Je hoeft aan de bedrijfszijde geen platformcontroles uit te voeren, maar verwacht het effect op die platformen niet te zien.

Stap 1: De scène en GameObjects aanmaken

Maak een gloednieuwe scène aan in Unity. Unity maakt standaard Main Camera en Directional Light aan.

Main Camera instellen

Selecteer Main Camera in het Hiërarchie-venster en stel de eigenschappen in het Inspector-venster in zoals hieronder wordt weergegeven.

Stel de eigenschappen van Main Camera in

LCCManager aanmaken

Klik met de rechtermuisknop op een leeg gebied in het Hiërarchie-venster, selecteer Create Empty in het pop-upmenu om een leeg GameObject aan te maken, geef het de naam LCCManager, normaliseer de Transform en voeg het LCCManager-script eraan toe via Component toevoegen.

Maak het LCCManager-GameObject aan en voeg het LCCManager-script toe

LCCRenderer aanmaken

Klik met de rechtermuisknop op een leeg gebied in het Hiërarchie-venster, selecteer Create Empty om een leeg GameObject aan te maken, geef het de naam LCCRenderer en stel de Transform in op Rotation.x = -90 en Scale.x = -1.

Maak LCCRenderer aan en stel de Transform in (Rotation.x = -90, Scale.x = -1)

Opmerking:

De Transform-instellingen van het LCCRenderer-GameObject (Rotation.x = -90, Scale.x = -1) lijnen het uit met het coördinatensysteem van de LCC-gegevens. Zie "Coördinatensysteem van LCC-gegevens" in LCC Unity SDK Introductie voor meer informatie over de uitlijning van het coördinatensysteem.

Projector aanmaken

Klik met de rechtermuisknop op een leeg gebied in het Hiërarchie-venster, selecteer Create Empty om een leeg GameObject met de naam Projector aan te maken. Het doel van het aanmaken van dit lege object is om de Transform-component te gebruiken om de positie en oriëntatie van de projector te bepalen; nadat je het aan de scriptcode hebt gekoppeld, kun je de projectoreigenschappen tijdens runtime aanpassen. De projector projecteert langs de +Z-richting en de eigenschappen kunnen naar behoefte worden ingesteld.

Maak het lege Projector-GameObject als projector aan (+Z is de projectierichting)

Stap 2: Een Render Feature toevoegen

1. Selecteer in de Unity-menubalk Bestand → Projectinstellingen, kies links Grafisch en controleer de huidige Default Render Pipeline Asset. Dit voorbeeld gebruikt URP (Universal Render Pipeline Asset).

Controleer de Default Render Pipeline Asset in de grafische instellingen

2. Klik op dat Asset, zoek het bijbehorende assetbestand in het Project-venster en zoek de bijbehorende Renderer (in dit voorbeeld URP_Renderer.asset).

3. Selecteer dat Renderer-assetbestand, klik in het Inspector-venster op Add Renderer Feature en voeg de Decal Depth Feature toe.

Voeg de Decal Depth Feature toe aan de URP Renderer

Opmerking:

De Decal Depth Feature is een vereiste voor occlusie-culling. Als je alleen de basisprojectie (röntgendecal) gebruikt, hoef je deze niet toe te voegen; maar om occlusie-culling in te schakelen, moet je deze Feature eerst registreren in de URP Renderer Asset, anders wordt de occlusiedieptekaart niet gegenereerd en is occlusie niet van kracht.

Stap 3: Het script schrijven

Maak een nieuw C#-script aan met de naam Decal.cs. De onderstaande volledige code simuleert het perspectief van de integrator en behandelt alle 7 decal-gerelateerde methoden (5 voor basisprojectie + 2 voor occlusie-culling); het kan rechtstreeks in je project worden gekopieerd.

using LCCCore;
using UnityEngine;

/// <summary>
/// Decal-projectie — minimaal gebruiksvoorbeeld voor ontwikkelaars.
///
/// Dit script simuleert een "integratorscript": het roept alleen openbare LCCManager-API's aan en raakt de SDK-interne werking niet aan.
/// Behandelt alle 7 decal-API's:
///   Basisprojectie (5): SetDecalEnabled / SetDecalTexture / SetDecalProjection / SetDecalOpacity / SetDecalEdgeFade
///   Occlusie-culling (2): SetDecalOcclusion / SetDecalOcclusionSettings
///
/// Gebruiksstappen:
///   1) Maak een leeg GameObject aan en voeg dit script toe;
///   2) Sleep in de Inspector de LCCManager in de scène naar m_manager;
///   3) Stel m_filePath in op een geldig LCC-scènepad;
///   4) Sleep de te projecteren afbeelding naar m_decalTexture (aanbevolen om Read/Write in de importinstellingen in te schakelen);
///   5) Sleep een leeg object naar m_projector als projector (laat leeg om dit object te gebruiken); de +Z-as is de projectierichting;
///   6) Play. Nadat de scène is geladen, wordt de decal automatisch ingeschakeld; sleep de projector om de decal in realtime op de puntenwolk te zien.
///
/// Platformopmerking: decal en occlusie-culling zijn alleen effectief op pc/Mac (URP). Aanroepen op mobiel/VR worden door de SDK genegeerd en als waarschuwing gelogd.
/// </summary>
public class Decal : MonoBehaviour
{
    [Header("Vereist")]
    [Tooltip("De LCCManager-instantie in de scène")]
    public LCCManager m_manager;
    [Tooltip("Een geldig LCC-scènepad")]
    public string m_filePath;
    [Tooltip("De te projecteren decal-afbeelding. RGB=kleur, A=eigen masker van de decal")]
    public Texture2D m_decalTexture;

    [Header("Projector (projecteert langs +Z)")]
    [Tooltip("Projectorpose. Laat leeg om de transform van dit object te gebruiken")]
    public Transform m_projector;
    [Range(1f, 179f)] public float m_fov = 60f;
    [Tooltip("Projectie-beeldverhouding; <=0 gebruikt automatisch de beeldverhouding van de decal-afbeelding")]
    public float m_aspect = 0f;
    public float m_near = 0.1f;
    public float m_far = 100f;

    [Header("Decal-uiterlijk")]
    [Range(0f, 1f)] public float m_opacity = 1.0f;
    [Range(0f, 0.5f)][Tooltip("Breedte van de randfade (UV-verhouding). 0 = harde rand")]
    public float m_edgeFade = 0.1f;
    [Tooltip("Ververs de projectie elke frame, zodat je de projector kunt slepen / parameters tijdens runtime kunt aanpassen")]
    public bool m_updateEveryFrame = true;

    [Header("Occlusie-culling (alleen pc/Mac)")]
    [Tooltip("Wanneer aan, worden naar achteren gerichte/afgeschermde punten achter de voorste geometrie niet langer door de decal gekleurd (diaprojector-effect); wanneer uit, is het röntgenachtig")]
    public bool m_occlusion = false;
    [Range(0f, 1f)][Tooltip("Dekkingsdrempel: alleen splats met een dekking >= deze waarde dragen bij aan de dieptekaart, waardoor zwevende/mistige punten worden weggefilterd. 0 = alles doet mee")]
    public float m_occlusionCutoff = 0f;
    [Range(0f, 0.5f)][Tooltip("Relatieve dieptetolerantie. Te klein -> zelfocclusie nabij het oppervlak; te groot -> gelekt röntgenkleuren. Standaard 0.05")]
    public float m_occlusionBias = 0.05f;
    [Range(0, 16)][Tooltip("Vierkante footprint-straalcap (px), de belangrijkste knop voor het verwijderen van röntgen-doorlekken. 0 = enkele texel, standaard 2")]
    public int m_occlusionFootprint = 2;
    [Tooltip("Resolutie van de dieptekaart (px, macht van twee 256~4096). Verlaag deze om gaten onder scheerhoeken op te vullen. Standaard 1024")]
    public int m_occlusionResolution = 1024;

    // -- Runtimestatus --
    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 of m_filePath is niet toegewezen.");
            enabled = false;
            return;
        }

        // 1) Initialiseer de renderpipeline naar de pc-editormodus voor één scène
        m_manager.SetPlatformType(PlatformType.PC);
        m_manager.SwitchRenderPass(ActiveRenderMode.SingleRender);
        m_manager.SetEditorMode(true);

        // 2) Laad de puntenwolkscène en schakel de decal na voltooiing in (decal is een globale status; instellen nadat de scène gereed is, is het veiligst)
        var renderer = m_manager.GetRender(this.transform);
        Debug.Log($"[DecalDemo] Start met laden: {m_filePath}");
        renderer.Load(m_filePath,
            _ => { /* voortgangscallback, ongebruikt in het voorbeeld */ },
            OnSceneLoaded);
    }

    private void OnSceneLoaded()
    {
        Debug.Log("[DecalDemo] Laden voltooid, decal-projectie wordt ingeschakeld.");

        // -- Basisprojectie: 5 API's --
        m_manager.SetDecalTexture(m_decalTexture);   // decal-inhoud
        m_manager.SetDecalOpacity(m_opacity);        // algehele dekking
        m_manager.SetDecalEdgeFade(m_edgeFade);      // randfade
        ApplyProjection();                           // projectorpose (roept intern SetDecalProjection aan)
        m_manager.SetDecalEnabled(true);             // decal inschakelen (_DECAL-keyword)

        // -- Occlusie-culling: 2 API's -- moet na ApplyProjection (de dieptekaart heeft een geldige projector-VP nodig)
        m_manager.SetDecalOcclusionSettings(BuildOcclusionSettings());
        m_manager.SetDecalOcclusion(m_occlusion);
        CacheOcclusionState();

        m_loaded = true;
    }

    /// <summary>
    /// Alleen ter demonstratie. In echte projecten hoef je voor betere prestaties
    /// SetDecalProjection / SetDecalOpacity / SetDecalEdgeFade niet elke frame in Update() aan te roepen;
    /// roep alleen de bijbehorende API aan wanneer de parameter verandert.
    /// </summary>
    void Update()
    {
        if (!m_loaded) return;

        // occlusie tijdens runtime in-/uitschakelen
        if (m_occlusion != m_lastOcclusion)
        {
            m_manager.SetDecalOcclusion(m_occlusion);
            m_lastOcclusion = m_occlusion;
        }

        // een occlusiekwaliteitsparameter is gewijzigd -> de struct één keer doorsturen
        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();
        }

        // ververs projector / uiterlijk elke frame voor handig realtime debuggen
        if (!m_updateEveryFrame) return;
        m_manager.SetDecalOpacity(m_opacity);
        m_manager.SetDecalEdgeFade(m_edgeFade);
        ApplyProjection();
    }

    /// <summary>Bouw de projectiematrix op basis van de huidige projectorpose en perspectiefparameters.</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>Verzamel de 4 occlusieparameters in een 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;
    }

    // -- Handige debug-ingangspunten (rechtermuisklik in Inspector) --
    [ContextMenu("Decal aan")]  private void DecalOn()  { m_manager?.SetDecalEnabled(true); }
    [ContextMenu("Decal uit")] private void DecalOff() { m_manager?.SetDecalEnabled(false); }
    [ContextMenu("Occlusie aan")]  private void OcclusionOn()  { m_occlusion = true;  m_manager?.SetDecalOcclusion(true);  m_lastOcclusion = true; }
    [ContextMenu("Occlusie uit")] private void OcclusionOff() { m_occlusion = false; m_manager?.SetDecalOcclusion(false); m_lastOcclusion = false; }
}

Opmerking:

De decal is een globale shading-status en moet worden ingesteld nadat de LCC-scène is geladen (dat wil zeggen in de onComplete-callback).

Het voorbeeld plaatst SetDecalTexture / SetDecalProjection / SetDecalEnabled in de voltooiingscallback van Load (OnSceneLoaded) om te voorkomen dat ze worden ingesteld voordat de puntenwolk gereed is.

De occlusie-culling-gerelateerde SetDecalOcclusionSettings / SetDecalOcclusion moeten na ApplyProjection (dat wil zeggen SetDecalProjection) worden aangeroepen, omdat de occlusiedieptekaart een geldige view-projectiematrix van de projector nodig heeft.

Stap 4: Het script toevoegen en eigenschappen configureren

1. Voeg het Decal.cs-script toe aan het LCCRenderer-GameObject in het Hiërarchie-venster.
2. Sleep in het Inspector-venster het LCCManager-GameObject naar de eigenschap Manager van het script.
3. Sleep het Projector-GameObject naar de eigenschap Projector van het script.
4. Vul het LCC-bestandspad in bij de eigenschap File Path van het script en sleep de decal-textuurafbeelding naar de eigenschap Decal Texture.
5. Andere eigenschapsparameters kunnen naar behoefte worden aangepast; de betekenis van elke eigenschap wordt in de onderstaande tabel weergegeven.

Inspector-eigenschapinstellingen voor het Decal-script

Stap 5: Uitvoeren en het effect observeren

Klik op de knop Play in Unity. Nadat de scène is geladen, wordt de decal automatisch ingeschakeld. Wanneer Update Every Frame is aangevinkt, kun je het projectorobject tijdens runtime rechtstreeks in de Scene-weergave slepen en zie je de decal in realtime over het 3DGS-oppervlak bewegen; het aanpassen van parameters zoals Opacity en Edge Fade wordt ook onmiddellijk van kracht. Het rechtermuisknopmenu van de scriptcomponent biedt ook vier snelkoppelingen — Decal aan/uit en Occlusie aan/uit — om het aan/uit-effect afzonderlijk handig te verifiëren.

Decal geprojecteerd op het 3DGS-oppervlak na het uitvoeren (basisprojectie, röntgendoorstraling)

Na het inschakelen van occlusie-culling wordt alleen het voorste oppervlak dat naar de projector is gericht gekleurd (diaprojector-effect)

Veelgestelde vraag: Compatibiliteitsmodus uitschakelen

Als het Console-venster van Unity fouten meldt en er geen decal-effect verschijnt, schakel dan de compatibiliteitsmodus uit: open het instellingenpaneel via Bewerken → Projectinstellingen → Grafisch, selecteer het tabblad URP en vink niet het selectievakje aan na Render Graph → Compatibility Mode (Render Graph Disabled).

Vink de compatibiliteitsmodus van Render Graph niet aan (Render Graph Disabled)

Occlusie-culling en afstellen

Occlusie-culling moet worden ingeschakeld nadat de projector is ingesteld. Het voorbeeld roept in de callback voor het laden van de scène eerst SetDecalProjection aan en vervolgens SetDecalOcclusionSettings en SetDecalOcclusion, om ervoor te zorgen dat de occlusiedieptekaart een geldige view-projectiematrix van de projector krijgt. Schakel tijdens runtime het selectievakje Occlusion in de Inspector in om te zien dat de doorgedrongen blokken worden verwijderd en alleen het voorste oppervlak dat naar de projector is gericht, behouden blijft.

Vereiste:

Voordat occlusie-culling wordt ingeschakeld, moet de Decal Depth Feature al zijn geregistreerd in de URP Renderer Asset (in dit project is deze als sub-asset in URP_Renderer.asset geschreven). Als deze niet is geregistreerd, wordt de occlusiedieptekaart niet gegenereerd en is occlusie niet van kracht.

De occlusiekwaliteit wordt bepaald door vier parameters, die in één keer via een struct worden doorgegeven. De vier zijn onderling orthogonaal; stel ze af volgens de onderstaande tabel:

Belangrijkste stappen

De belangrijkste stappen voor het implementeren van geprojecteerde decal:

1. Maak het lege Projector-object in de scène aan als projector; de +Z-as is de projectierichting.
2. Zorg ervoor dat, als occlusie-culling nodig is, de Decal Depth Feature is toegevoegd aan de URP Renderer.
3. Stel nadat de LCC-scène is geladen de decal-textuur, het uiterlijk en de projectorpose op volgorde in en schakel vervolgens de decal in (SetDecalEnabled(true)).
4. De occlusie-culling SetDecalOcclusionSettings / SetDecalOcclusion moet na SetDecalProjection worden aangeroepen.

Decal-gerelateerde API's

De volgende methoden bevinden zich allemaal op de facadeklasse LCCManager en zijn alleen effectief op pc / Mac (URP-pipeline); aanroepen op mobiel / VR worden genegeerd en er wordt een waarschuwing afgedrukt.

SetDecalEnabled

// Retourwaarde: void
public void SetDecalEnabled(bool enable)

Schakelt decal-projectie in of uit. Wanneer ingeschakeld, worden de momenteel gecachte dekking- / randfade-parameters naar de GPU gepusht en wordt het _DECAL-shader-keyword ingeschakeld. De decal is een wereldvast globale status, consistent voor alle camera's. Je moet ook SetDecalTexture en SetDecalProjection aanroepen om de inhoud en de projectorpose in te stellen.

Gebruiksvoorbeeld:

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

Opmerkingen:

• Wanneer uitgeschakeld, wordt alleen het _DECAL-keyword uitgeschakeld; de gecachte textuur / parameters worden niet gewist.

SetDecalTexture

// Retourwaarde: void
public void SetDecalTexture(Texture2D tex)

Stelt de decal-textuur in. RGB is kleur en A is het eigen masker van de decal, dat wordt vermenigvuldigd met de globale dekking en randfade.

Gebruiksvoorbeeld:

m_manager.SetDecalTexture(logoTex);

Opmerkingen:

• Het doorgeven van null wist de globale textuurverwijzing.

SetDecalProjection

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

Stelt de pose en perspectiefparameters van de decal-projector in. De projector projecteert langs de voorwaartse (+Z)-richting en punten binnen het frustum worden door de decal bedekt.

Gebruiksvoorbeeld:

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

Opmerkingen:

• Als SetDecalOcclusion(true) al is ingeschakeld, stuurt deze methode de nieuwe VP / view synchroon door naar de Decal Depth Feature.

SetDecalOpacity

// Retourwaarde: void
public void SetDecalOpacity(float opacity)

Stelt de algehele decal-dekking in, pusht deze onmiddellijk naar de GPU en cachet deze voor hergebruik de volgende keer dat SetDecalEnabled(true) wordt aangeroepen.

Gebruiksvoorbeeld:

m_manager.SetDecalOpacity(0.8f);

Opmerkingen:

• Bereik [0, 1]; waarden buiten het bereik worden automatisch afgekapt.

SetDecalEdgeFade

// Retourwaarde: void
public void SetDecalEdgeFade(float edgeFade)

Stelt de breedte van de decal-randfade in. 0 is een harde rand en hoe groter de waarde, hoe zachter de randovergang.

Gebruiksvoorbeeld:

m_manager.SetDecalEdgeFade(0.1f);

Opmerkingen:

• Bereik [0, 0.5); waarden buiten het bereik worden automatisch afgekapt.

SetDecalOcclusion

// Retourwaarde: void
public void SetDecalOcclusion(bool enable)

Schakelt decal-occlusie-culling in of uit (gebaseerd op de dieptekaart van de projector), die orthogonaal is aan en onafhankelijk wordt in-/uitgeschakeld van de schaduwfunctie. SetDecalProjection moet zijn aangeroepen om de projector in te stellen voordat deze wordt ingeschakeld, anders heeft de dieptekaart geen geldige VP.

Gebruiksvoorbeeld:

m_manager.SetDecalOcclusion(true);

Opmerkingen:

• Alleen ondersteund op URP (aanroepen op de Built-in-pipeline zijn een no-op en drukken een log af).
• Vereist dat de Decal Depth Feature is geregistreerd in de URP Renderer Asset.
• Afhankelijk van de kwaliteitsparameters die zijn geconfigureerd door SetDecalOcclusionSettings.

SetDecalOcclusionSettings

// Retourwaarde: void
public void SetDecalOcclusionSettings(DecalOcclusionSettings settings)

Stelt alle kwaliteitsparameters van de decal-occlusie-culling in één keer in (zie de onderstaande struct en de tabel "Occlusie-culling en afstellen" voor de betekenis van de vier items).

Gebruiksvoorbeeld:

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

Opmerkingen:

• Kan op elk moment worden aangepast; parameters worden onmiddellijk naar de GPU en de Decal Depth Feature gepusht.
• Het wijzigen van resolution activeert een herbouw van de dieptekaart-RT.

Gerelateerde gegevensstructuren

DecalOcclusionSettings

public struct DecalOcclusionSettings {
    public float opacityCutoff;   // [0,1] minimale dekking voor een splat om deel te nemen aan de dieptekaart, standaard 0 (alles doet mee)
    public float depthBias;       // relatieve dieptetolerantieverhouding, standaard 0.05
    public int   footprintMaxPx;  // vierkante footprint-straalcap (px), 0~16, standaard 2
    public int   resolution;      // resolutie van de dieptekaart (px, macht van twee, 256~4096), standaard 1024

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

Gebruikt door SetDecalOcclusionSettings(); de standaardwaarde kan worden verkregen via DecalOcclusionSettings.Default.

Opmerkingen

• Alleen effectief op pc / Mac. Aanroepen van decal-gerelateerde interfaces op mobiele en VR-platformen worden genegeerd en drukken een waarschuwing af. Je hoeft aan de bedrijfszijde geen platformcontroles uit te voeren, maar verwacht het effect op die platformen niet te zien.
• Het wordt aanbevolen om de decal in te stellen nadat de scène is geladen. De decal is een globale shading-status; het voorbeeld plaatst SetDecalTexture / SetDecalProjection / SetDecalEnabled in de voltooiingscallback van Load om te voorkomen dat ze worden ingesteld voordat de puntenwolk gereed is.
• Occlusie-culling hangt af van twee vereisten. Ten eerste heeft de URP Renderer Asset de Decal Depth Feature geregistreerd; ten tweede is SetDecalProjection aangeroepen om de projector in te stellen. Occlusie is niet van kracht als een van beide ontbreekt.
• Statische projectie heeft vrijwel geen extra overhead. De occlusiedieptekaart wordt alleen opnieuw berekend wanneer de projectorpose of de puntenwolk verandert; wanneer de projector stilstaat, is er geen extra per-frame berekening.