Przewodnik dekala projekcyjnego

Przegląd funkcji

Rzutowanie dekala (Decal Projector) rzutuje obraz 2D na powierzchnię chmury punktów 3DGS jak rzutnik slajdów. Projektor to stałe frustum perspektywiczne w przestrzeni świata; chmura punktów wewnątrz frustum jest pokrywana kolorem dekala, a chmura punktów poza frustum pozostaje nienaruszona. Dekal to globalny stan cieniowania, który ma spójny efekt cieniowania na całej scenie 3DGS.

Oprócz podstawowego rzutowania można opcjonalnie włączyć odcinanie okluzji. Domyślnie dekal działa jak prześwietlenie rentgenowskie: ponieważ sam 3DGS nie ma pojęcia powierzchni, dekal przenika do tylnych ścian zasłoniętych przez obiekty przednie i przechodzi przez całą scenę 3DGS. Po włączeniu odcinania okluzji kolorowana jest tylko przednia powierzchnia zwrócona do projektora, a zasłonięte tylne ściany i zasłonięte sceny nie są już kolorowane, dając realistyczny efekt rzutnika slajdów.

Uwaga:

Dekal i odcinanie okluzji działają tylko na PC / Mac (potok URP). Wywoływanie powiązanych interfejsów na platformach mobilnych lub VR jest ignorowane przez SDK, które wyświetla dziennik ostrzeżeń. Nie musisz wykonywać kontroli platformy po stronie biznesowej, ale nie oczekuj zobaczenia efektu na tych platformach.

Krok 1: Utwórz scenę i GameObjects

Utwórz zupełnie nową scenę w Unity. Unity domyślnie tworzy Kamerę główną i Światło kierunkowe.

Skonfiguruj Kamerę główną

Wybierz Kamerę główną w oknie Hierarchia i ustaw jej właściwości w oknie Inspektor, jak pokazano poniżej.

Ustaw właściwości Kamery głównej

Utwórz LCCManager

Kliknij prawym przyciskiem myszy pusty obszar w oknie Hierarchia, wybierz Utwórz pusty z menu podręcznego, aby utworzyć pusty GameObject, nazwij go LCCManager, znormalizuj jego Transform i dodaj do niego skrypt LCCManager przez Dodaj komponent.

Utwórz GameObject LCCManager i dodaj skrypt LCCManager

Utwórz LCCRenderer

Kliknij prawym przyciskiem myszy pusty obszar w oknie Hierarchia, wybierz Utwórz pusty, aby utworzyć pusty GameObject, nazwij go LCCRenderer i ustaw jego Transform na Rotation.x = -90 i Scale.x = -1.

Utwórz LCCRenderer i ustaw jego Transform (Rotation.x = -90, Scale.x = -1)

Uwaga:

Ustawienia Transform GameObject LCCRenderer (Rotation.x = -90, Scale.x = -1) wyrównują go z układem współrzędnych danych LCC. Szczegóły wyrównania układu współrzędnych znajdziesz w sekcji „Układ współrzędnych danych LCC" w Wprowadzenie do Unity SDK.

Utwórz Projektor

Kliknij prawym przyciskiem myszy pusty obszar w oknie Hierarchia, wybierz Utwórz pusty, aby utworzyć pusty GameObject o nazwie Projector. Celem utworzenia tego pustego obiektu jest użycie jego komponentu Transform do sterowania pozycją i orientacją projektora; po powiązaniu go z kodem skryptu możesz dostosowywać właściwości projektora w czasie działania. Projektor rzutuje wzdłuż swojego kierunku +Z, a jego właściwości można ustawić w razie potrzeby.

Utwórz pusty GameObject Projector jako projektor (+Z to kierunek rzutowania)

Krok 2: Dodaj Render Feature

1. Na pasku menu Unity wybierz Plik → Ustawienia projektu, po lewej stronie wybierz Grafika i potwierdź bieżący Domyślny zasób potoku renderowania. Ten przykład używa URP (Universal Render Pipeline Asset).

Potwierdź Domyślny zasób potoku renderowania w ustawieniach Grafiki

2. Kliknij ten zasób, zlokalizuj odpowiedni plik zasobu w oknie Projekt i znajdź jego powiązany Renderer (URP_Renderer.asset w tym przykładzie).

3. Wybierz ten plik zasobu Renderer, kliknij Dodaj Render Feature w oknie Inspektor i dodaj Decal Depth Feature.

Dodaj funkcję Decal Depth Feature do renderera URP

Uwaga:

Decal Depth Feature jest warunkiem wstępnym odcinania okluzji. Jeśli używasz tylko podstawowego rzutowania (dekal rentgenowski), nie musisz jej dodawać; ale aby włączyć odcinanie okluzji, musisz najpierw zarejestrować tę funkcję w zasobie renderera URP, w przeciwnym razie mapa głębi okluzji nie zostanie wygenerowana i okluzja nie zadziała.

Krok 3: Napisz skrypt

Utwórz nowy skrypt C# o nazwie Decal.cs. Poniższy kompletny kod symuluje perspektywę integratora i obejmuje wszystkie 7 metod powiązanych z dekalem (5 dla podstawowego rzutowania + 2 dla odcinania okluzji); można go skopiować bezpośrednio do projektu.

using LCCCore;
using UnityEngine;

/// <summary>
/// Rzutowanie dekala — minimalny przykład użycia dla dewelopera.
///
/// Ten skrypt symuluje „skrypt integratora": wywołuje tylko publiczne API LCCManager i nie dotyka wewnętrznych części SDK.
/// Obejmuje wszystkie 7 API dekala:
///   Rzut podstawowy (5): SetDecalEnabled / SetDecalTexture / SetDecalProjection / SetDecalOpacity / SetDecalEdgeFade
///   Odcinanie okluzji (2): SetDecalOcclusion / SetDecalOcclusionSettings
///
/// Kroki użycia:
///   1) Utwórz pusty GameObject i dołącz ten skrypt;
///   2) W Inspektorze przeciągnij LCCManager ze sceny do m_manager;
///   3) Ustaw m_filePath na prawidłową ścieżkę sceny LCC;
///   4) Przeciągnij obraz do rzutowania do m_decalTexture (zalecane włączenie Read/Write w ustawieniach importu);
///   5) Przeciągnij pusty obiekt do m_projector jako projektor (pozostaw puste, aby użyć tego obiektu); jego oś +Z to kierunek rzutowania;
///   6) Uruchom. Po zakończeniu ładowania sceny dekal włącza się automatycznie; przeciągnij projektor, aby zobaczyć dekal na chmurze punktów w czasie rzeczywistym.
///
/// Uwaga platformowa: dekal i odcinanie okluzji działają tylko na PC/Mac (URP). Wywołania na mobilnych/VR są ignorowane przez SDK i rejestrowane jako ostrzeżenia.
/// </summary>
public class Decal : MonoBehaviour
{
    [Header("Wymagane")]
    [Tooltip("Instancja LCCManager w scenie")]
    public LCCManager m_manager;
    [Tooltip("Prawidłowa ścieżka sceny LCC")]
    public string m_filePath;
    [Tooltip("Obraz dekala do rzutowania. RGB=kolor, A=własna maska dekala")]
    public Texture2D m_decalTexture;

    [Header("Projektor (rzutuje wzdłuż +Z)")]
    [Tooltip("Poza projektora. Pozostaw puste, aby użyć transformu tego obiektu")]
    public Transform m_projector;
    [Range(1f, 179f)] public float m_fov = 60f;
    [Tooltip("Współczynnik proporcji rzutu; <=0 używa automatycznie proporcji obrazu dekala")]
    public float m_aspect = 0f;
    public float m_near = 0.1f;
    public float m_far = 100f;

    [Header("Wygląd dekala")]
    [Range(0f, 1f)] public float m_opacity = 1.0f;
    [Range(0f, 0.5f)][Tooltip("Szerokość zanikania krawędzi (współczynnik UV). 0 = twarda krawędź")]
    public float m_edgeFade = 0.1f;
    [Tooltip("Odświeżaj rzut co klatkę, aby móc przeciągać projektor / dostrajać parametry w czasie działania")]
    public bool m_updateEveryFrame = true;

    [Header("Odcinanie okluzji (tylko PC/Mac)")]
    [Tooltip("Gdy włączone, punkty odwrócone tyłem/zasłonięte za geometrią przednią nie są już kolorowane przez dekal (efekt rzutnika slajdów); gdy wyłączone, jest to prześwietlenie rentgenowskie")]
    public bool m_occlusion = false;
    [Range(0f, 1f)][Tooltip("Próg nieprzezroczystości: tylko splaty o nieprzezroczystości >= tej wartości wnoszą wkład do mapy głębi, filtrując punkty unoszące się/zamglone. 0 = wszystkie uczestniczą")]
    public float m_occlusionCutoff = 0f;
    [Range(0f, 0.5f)][Tooltip("Względna tolerancja głębi. Zbyt mała -> samo-okluzja przy powierzchni; zbyt duża -> przeciekające kolorowanie rentgenowskie. Domyślnie 0.05")]
    public float m_occlusionBias = 0.05f;
    [Range(0, 16)][Tooltip("Górny limit promienia kwadratowego śladu (px), główne pokrętło do usuwania przebijania rentgenowskiego. 0 = pojedynczy teksel, domyślnie 2")]
    public int m_occlusionFootprint = 2;
    [Tooltip("Rozdzielczość mapy głębi (px, potęga dwójki 256~4096). Zmniejsz ją, aby wypełnić dziury przy kątach stycznych. Domyślnie 1024")]
    public int m_occlusionResolution = 1024;

    // -- Stan w czasie działania --
    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 lub m_filePath nie jest przypisany.");
            enabled = false;
            return;
        }

        // 1) Zainicjalizuj potok renderowania do trybu edytora pojedynczej sceny PC
        m_manager.SetPlatformType(PlatformType.PC);
        m_manager.SwitchRenderPass(ActiveRenderMode.SingleRender);
        m_manager.SetEditorMode(true);

        // 2) Załaduj scenę chmury punktów, a następnie włącz dekal po zakończeniu (dekal jest stanem globalnym; najbezpieczniej ustawić go, gdy scena jest gotowa)
        var renderer = m_manager.GetRender(this.transform);
        Debug.Log($"[DecalDemo] Rozpoczynanie ładowania: {m_filePath}");
        renderer.Load(m_filePath,
            _ => { /* wywołanie zwrotne postępu, nieużywane w przykładzie */ },
            OnSceneLoaded);
    }

    private void OnSceneLoaded()
    {
        Debug.Log("[DecalDemo] Ładowanie zakończone, włączanie rzutowania dekala.");

        // -- Rzut podstawowy: 5 API --
        m_manager.SetDecalTexture(m_decalTexture);   // zawartość dekala
        m_manager.SetDecalOpacity(m_opacity);        // ogólna nieprzezroczystość
        m_manager.SetDecalEdgeFade(m_edgeFade);      // zanikanie krawędzi
        ApplyProjection();                           // poza projektora (wewnętrznie wywołuje SetDecalProjection)
        m_manager.SetDecalEnabled(true);             // włącz dekal (słowo kluczowe _DECAL)

        // -- Odcinanie okluzji: 2 API -- muszą być po ApplyProjection (mapa głębi potrzebuje prawidłowej macierzy VP projektora)
        m_manager.SetDecalOcclusionSettings(BuildOcclusionSettings());
        m_manager.SetDecalOcclusion(m_occlusion);
        CacheOcclusionState();

        m_loaded = true;
    }

    /// <summary>
    /// Tylko do demonstracji. W rzeczywistych projektach dla lepszej wydajności nie musisz wywoływać
    /// SetDecalProjection / SetDecalOpacity / SetDecalEdgeFade co klatkę w Update();
    /// wywołaj odpowiednie API tylko wtedy, gdy parametr się zmieni.
    /// </summary>
    void Update()
    {
        if (!m_loaded) return;

        // przełącz okluzję w czasie działania
        if (m_occlusion != m_lastOcclusion)
        {
            m_manager.SetDecalOcclusion(m_occlusion);
            m_lastOcclusion = m_occlusion;
        }

        // zmiana dowolnego parametru jakości okluzji -> wyślij strukturę raz
        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();
        }

        // odświeżaj projektor / wygląd co klatkę dla wygodnego debugowania w czasie rzeczywistym
        if (!m_updateEveryFrame) return;
        m_manager.SetDecalOpacity(m_opacity);
        m_manager.SetDecalEdgeFade(m_edgeFade);
        ApplyProjection();
    }

    /// <summary>Zbuduj macierz rzutowania z bieżącej pozy projektora i parametrów perspektywy.</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>Zbierz 4 parametry okluzji do struktury.</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;
    }

    // -- Wygodne punkty wejścia debugowania (kliknięcie prawym przyciskiem w Inspektorze) --
    [ContextMenu("Dekal włączony")]  private void DecalOn()  { m_manager?.SetDecalEnabled(true); }
    [ContextMenu("Dekal wyłączony")] private void DecalOff() { m_manager?.SetDecalEnabled(false); }
    [ContextMenu("Okluzja włączona")]  private void OcclusionOn()  { m_occlusion = true;  m_manager?.SetDecalOcclusion(true);  m_lastOcclusion = true; }
    [ContextMenu("Okluzja wyłączona")] private void OcclusionOff() { m_occlusion = false; m_manager?.SetDecalOcclusion(false); m_lastOcclusion = false; }
}

Uwaga:

Dekal to globalny stan cieniowania i musi być ustawiony po zakończeniu ładowania sceny LCC (czyli w wywołaniu zwrotnym onComplete).

Przykład umieszcza SetDecalTexture / SetDecalProjection / SetDecalEnabled w wywołaniu zwrotnym zakończenia Load (OnSceneLoaded), aby uniknąć ustawiania ich przed przygotowaniem chmury punktów.

Powiązane z odcinaniem okluzji SetDecalOcclusionSettings / SetDecalOcclusion muszą być wywołane po ApplyProjection (czyli SetDecalProjection), ponieważ mapa głębi okluzji potrzebuje prawidłowej macierzy widokowo-rzutowej projektora.

Krok 4: Dołącz skrypt i skonfiguruj właściwości

1. Dołącz skrypt Decal.cs do GameObject LCCRenderer w oknie Hierarchia.
2. W oknie Inspektor przeciągnij GameObject LCCManager na właściwość Manager skryptu.
3. Przeciągnij GameObject Projector na właściwość Projector skryptu.
4. Wpisz ścieżkę pliku LCC we właściwości File Path skryptu i przeciągnij obraz tekstury dekala na właściwość Decal Texture.
5. Pozostałe parametry można dostosować w razie potrzeby; znaczenie każdej właściwości pokazano w tabeli poniżej.

Ustawienia właściwości w Inspektorze dla skryptu Decal

Krok 5: Uruchom i obserwuj efekt

Kliknij przycisk Odtwórz w Unity. Po zakończeniu ładowania sceny dekal włącza się automatycznie. Gdy Update Every Frame jest zaznaczone, możesz bezpośrednio przeciągać obiekt projektora w widoku Scena w czasie działania i widzieć, jak dekal przesuwa się po powierzchni 3DGS w czasie rzeczywistym; dostosowywanie parametrów takich jak Opacity i Edge Fade również działa natychmiast. Menu podręczne komponentu skryptu udostępnia również cztery skróty — Dekal włączony/wyłączony i Okluzja włączona/wyłączona — do wygodnego oddzielnego sprawdzania efektu włączania/wyłączania.

Dekal rzutowany na powierzchnię 3DGS po uruchomieniu (rzut podstawowy, przenikanie rentgenowskie)

Po włączeniu odcinania okluzji kolorowana jest tylko przednia powierzchnia zwrócona do projektora (efekt rzutnika slajdów)

FAQ: Wyłącz tryb zgodności

Jeśli okno Konsola w Unity zgłasza błędy i nie pojawia się efekt dekala, wyłącz tryb zgodności: otwórz panel ustawień przez Edycja → Ustawienia projektu → Grafika, wybierz kartę URP i nie zaznaczaj pola wyboru po Render Graph → Tryb zgodności (Render Graph wyłączony).

Nie zaznaczaj trybu zgodności Render Graph (Render Graph wyłączony)

Odcinanie okluzji i dostrajanie

Odcinanie okluzji musi być włączone po skonfigurowaniu projektora. Przykład wywołuje najpierw SetDecalProjection w wywołaniu zwrotnym zakończenia ładowania sceny, a następnie SetDecalOcclusionSettings i SetDecalOcclusion, aby zapewnić mapie głębi okluzji prawidłową macierz widokowo-rzutową projektora. W czasie działania zaznacz pole Occlusion w Inspektorze, aby zobaczyć, jak przenikające bloki są odcinane i zachowana zostaje tylko przednia powierzchnia zwrócona do projektora.

Warunek wstępny:

Przed włączeniem odcinania okluzji Decal Depth Feature musi być już zarejestrowana w zasobie renderera URP (w tym projekcie została zapisana w URP_Renderer.asset jako pod-zasób). Jeśli nie jest zarejestrowana, mapa głębi okluzji nie zostanie wygenerowana i okluzja nie zadziała.

Jakość okluzji jest kontrolowana przez cztery parametry, dostarczane wszystkie naraz przez strukturę. Cztery są wzajemnie ortogonalne; dostrój je zgodnie z tabelą poniżej:

Kluczowe kroki

Kluczowe kroki implementacji dekala projekcyjnego:

1. Utwórz pusty obiekt Projector w scenie jako projektor; jego oś +Z to kierunek rzutowania.
2. Jeśli potrzebne jest odcinanie okluzji, upewnij się, że Decal Depth Feature została dodana do renderera URP.
3. Po zakończeniu ładowania sceny LCC ustaw kolejno teksturę dekala, wygląd i pozę projektora, a następnie włącz dekal (SetDecalEnabled(true)).
4. Odcinanie okluzji SetDecalOcclusionSettings / SetDecalOcclusion musi być wywołane po SetDecalProjection.

API powiązane z dekalem

Poniższe metody znajdują się wszystkie w klasie fasadowej LCCManager i działają tylko na PC / Mac (potok URP); wywołania na mobilnych / VR są ignorowane i wyświetlane jest ostrzeżenie.

SetDecalEnabled

// Wartość zwracana: void
public void SetDecalEnabled(bool enable)

Przełącza rzutowanie dekala. Po włączeniu aktualnie buforowane parametry nieprzezroczystości / zanikania krawędzi są przesyłane do GPU i włączane jest słowo kluczowe shadera _DECAL. Dekal to stały w świecie stan globalny, spójny dla wszystkich kamer. Musisz również wywołać SetDecalTexture i SetDecalProjection, aby ustawić zawartość i pozę projektora.

Przykład użycia:

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

Uwagi:

• Po wyłączeniu wyłączane jest tylko słowo kluczowe _DECAL; buforowana tekstura / parametry nie są czyszczone.

SetDecalTexture

// Wartość zwracana: void
public void SetDecalTexture(Texture2D tex)

Ustawia teksturę dekala. RGB to kolor, a A to własna maska dekala, która jest mnożona z globalną nieprzezroczystością i zanikaniem krawędzi.

Przykład użycia:

m_manager.SetDecalTexture(logoTex);

Uwagi:

• Przekazanie null czyści globalne odniesienie do tekstury.

SetDecalProjection

// Wartość zwracana: void
public void SetDecalProjection(Vector3 pos, Quaternion rot, float fov, float aspect, float near, float far)

Ustawia pozę projektora dekala i parametry perspektywy. Projektor rzutuje wzdłuż swojego kierunku do przodu (+Z), a punkty wewnątrz frustum są pokrywane przez dekal.

Przykład użycia:

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

Uwagi:

• Jeśli SetDecalOcclusion(true) jest już włączone, ta metoda synchronicznie przekazuje nowe VP / widok do Decal Depth Feature.

SetDecalOpacity

// Wartość zwracana: void
public void SetDecalOpacity(float opacity)

Ustawia ogólną nieprzezroczystość dekala, natychmiast przesyłając ją do GPU i buforując do ponownego użycia przy następnym wywołaniu SetDecalEnabled(true).

Przykład użycia:

m_manager.SetDecalOpacity(0.8f);

Uwagi:

• Zakres [0, 1]; wartości spoza zakresu są automatycznie przycinane.

SetDecalEdgeFade

// Wartość zwracana: void
public void SetDecalEdgeFade(float edgeFade)

Ustawia szerokość zanikania krawędzi dekala. 0 to twarda krawędź, a im większa wartość, tym miększe przejście krawędzi.

Przykład użycia:

m_manager.SetDecalEdgeFade(0.1f);

Uwagi:

• Zakres [0, 0.5); wartości spoza zakresu są automatycznie przycinane.

SetDecalOcclusion

// Wartość zwracana: void
public void SetDecalOcclusion(bool enable)

Przełącza odcinanie okluzji dekala (oparte na mapie głębi projektora), które jest ortogonalne i niezależnie przełączane od funkcji cieni. Przed włączeniem powinno być wywołane SetDecalProjection, aby ustawić projektor, w przeciwnym razie mapa głębi nie ma prawidłowego VP.

Przykład użycia:

m_manager.SetDecalOcclusion(true);

Uwagi:

• Obsługiwane tylko na URP (wywołania na potoku Built-in są no-op i wyświetlają dziennik).
• Wymaga zarejestrowania Decal Depth Feature w zasobie renderera URP.
• Zależy od parametrów jakości skonfigurowanych przez SetDecalOcclusionSettings.

SetDecalOcclusionSettings

// Wartość zwracana: void
public void SetDecalOcclusionSettings(DecalOcclusionSettings settings)

Ustawia wszystkie parametry jakości odcinania okluzji dekala naraz (znaczenia czterech elementów znajdziesz w strukturze poniżej i w tabeli „Odcinanie okluzji i dostrajanie").

Przykład użycia:

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

Uwagi:

• Można dostosowywać w dowolnym momencie; parametry są natychmiast przesyłane do GPU i Decal Depth Feature.
• Zmiana resolution wywołuje przebudowę RT mapy głębi.

Powiązane struktury danych

DecalOcclusionSettings

public struct DecalOcclusionSettings {
    public float opacityCutoff;   // [0,1] minimalna nieprzezroczystość, aby splat uczestniczył w mapie głębi, domyślnie 0 (wszystkie uczestniczą)
    public float depthBias;       // względny współczynnik tolerancji głębi, domyślnie 0.05
    public int   footprintMaxPx;  // górny limit promienia kwadratowego śladu (px), 0~16, domyślnie 2
    public int   resolution;      // rozdzielczość mapy głębi (px, potęga dwójki, 256~4096), domyślnie 1024

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

Używana przez SetDecalOcclusionSettings(); wartość domyślną można uzyskać przez DecalOcclusionSettings.Default.

Uwagi

• Działa tylko na PC / Mac. Wywołania interfejsów powiązanych z dekalem na platformach mobilnych i VR są ignorowane i wyświetlają ostrzeżenie. Nie musisz wykonywać kontroli platformy po stronie biznesowej, ale nie oczekuj zobaczenia efektu na tych platformach.
• Zaleca się ustawienie dekala po zakończeniu ładowania sceny. Dekal to globalny stan cieniowania; przykład umieszcza SetDecalTexture / SetDecalProjection / SetDecalEnabled w wywołaniu zwrotnym zakończenia Load, aby uniknąć ustawiania ich przed przygotowaniem chmury punktów.
• Odcinanie okluzji zależy od dwóch warunków wstępnych. Po pierwsze, zasób renderera URP ma zarejestrowaną Decal Depth Feature; po drugie, zostało wywołane SetDecalProjection, aby ustawić projektor. Okluzja nie zadziała, jeśli brakuje któregokolwiek z nich.
• Statyczne rzutowanie ma prawie zerowy dodatkowy narzut. Mapa głębi okluzji jest ponownie obliczana tylko wtedy, gdy zmienia się poza projektora lub chmura punktów; gdy projektor jest nieruchomy, nie ma dodatkowych obliczeń co klatkę.