Entwicklungsanleitung für projizierte Decals

Funktionsübersicht

Die Decal-Projektion (Decal Projector) projiziert ein 2D-Bild wie ein Diaprojektor auf die 3DGS-Punktwolkenoberfläche. Der Projektor ist ein fester perspektivischer Frustum im Weltraum; die Punktwolke innerhalb des Frustums wird von der Decal-Farbe bedeckt, und die Punktwolke außerhalb des Frustums bleibt unbeeinflusst. Das Decal ist ein globaler Schattierungszustand, der auf die gesamte 3DGS-Szene eine einheitliche Schattierungswirkung hat.

Zusätzlich zur Basisprojektion kann optional Verdeckungs-Culling aktiviert werden. Standardmäßig ist das Decal röntgenartig: Da 3DGS selbst keinen Flächenbegriff hat, dringt das Decal bis zu den von vorderen Objekten verdeckten Rückseiten durch und durchdringt die gesamte 3DGS-Szene. Nach dem Aktivieren des Verdeckungs-Cullings wird nur die dem Projektor zugewandte Vorderfläche eingefärbt, während die verdeckten Rückseiten und verdeckten Szenen nicht mehr eingefärbt werden, was einen realistischen Diaprojektor-Effekt erzeugt.

Hinweis:

Decal und Verdeckungs-Culling wirken nur auf PC / Mac (URP-Pipeline). Der Aufruf der zugehörigen Schnittstellen auf Mobil- oder VR-Plattformen wird vom SDK ignoriert, das eine Warnung protokolliert. Sie müssen auf der Geschäftsseite keine Plattformprüfungen durchführen, sollten aber auf diesen Plattformen keinen Effekt erwarten.

Schritt 1: Die Szene und die GameObjects erstellen

Erstellen Sie in Unity eine brandneue Szene. Unity erstellt standardmäßig die Hauptkamera und das Richtungslicht.

Hauptkamera einrichten

Wählen Sie die Hauptkamera im Fenster Hierarchie aus und legen Sie deren Eigenschaften im Fenster Inspektor wie unten dargestellt fest.

Die Eigenschaften der Hauptkamera festlegen

LCCManager erstellen

Klicken Sie mit der rechten Maustaste in einen leeren Bereich des Fensters Hierarchie, wählen Sie im Popup-Menü Leeres GameObject erstellen, um ein leeres GameObject zu erstellen, benennen Sie es LCCManager, normalisieren Sie dessen Transform und fügen Sie über Komponente hinzufügen das Skript LCCManager hinzu.

Das GameObject LCCManager erstellen und das Skript LCCManager hinzufügen

LCCRenderer erstellen

Klicken Sie mit der rechten Maustaste in einen leeren Bereich des Fensters Hierarchie, wählen Sie Leeres GameObject erstellen, um ein leeres GameObject zu erstellen, benennen Sie es LCCRenderer und setzen Sie dessen Transform auf Rotation.x = -90 und Scale.x = -1.

LCCRenderer erstellen und dessen Transform festlegen (Rotation.x = -90, Scale.x = -1)

Hinweis:

Die Transform-Einstellungen des GameObject LCCRenderer (Rotation.x = -90, Scale.x = -1) richten es am LCC-Daten-Koordinatensystem aus. Details zur Ausrichtung am Koordinatensystem finden Sie unter „LCC-Daten-Koordinatensystem“ in Einführung in das Unity SDK.

Projektor erstellen

Klicken Sie mit der rechten Maustaste in einen leeren Bereich des Fensters Hierarchie, wählen Sie Leeres GameObject erstellen, um ein leeres GameObject namens Projektor zu erstellen. Der Zweck dieses leeren Objekts besteht darin, seine Transform-Komponente zur Steuerung von Position und Ausrichtung des Projektors zu verwenden; nach der Zuordnung zum Skript-Code können Sie die Projektor-Eigenschaften zur Laufzeit anpassen. Der Projektor projiziert entlang seiner +Z-Richtung, und seine Eigenschaften können nach Bedarf festgelegt werden.

Das leere GameObject Projektor als Projektor erstellen (+Z ist die Projektionsrichtung)

Schritt 2: Ein Render Feature hinzufügen

1. Wählen Sie in der Unity-Menüleiste Datei → Projekteinstellungen, wählen Sie links Grafik und bestätigen Sie das aktuelle Standard-Render-Pipeline-Asset. Dieses Beispiel verwendet URP (Universal Render Pipeline Asset).

Das Standard-Render-Pipeline-Asset in den Grafikeinstellungen bestätigen

2. Klicken Sie auf dieses Asset, lokalisieren Sie die entsprechende Asset-Datei im Fenster Projekt und suchen Sie den zugehörigen Renderer (URP_Renderer.asset in diesem Beispiel).

3. Wählen Sie diese Renderer-Asset-Datei aus, klicken Sie im Fenster Inspektor auf Renderer-Feature hinzufügen und fügen Sie das Decal Depth Feature hinzu.

Das Decal Depth Feature zum URP-Renderer hinzufügen

Hinweis:

Decal Depth Feature ist eine Voraussetzung für das Verdeckungs-Culling. Wenn Sie nur die Basisprojektion (röntgenartiges Decal) verwenden, müssen Sie es nicht hinzufügen; um das Verdeckungs-Culling zu aktivieren, müssen Sie dieses Feature jedoch zuerst im URP-Renderer-Asset registrieren, andernfalls wird die Verdeckungs-Tiefenkarte nicht erzeugt und die Verdeckung wird nicht wirksam.

Schritt 3: Das Skript schreiben

Erstellen Sie ein neues C#-Skript namens Decal.cs. Der folgende vollständige Code simuliert die Perspektive des Integrators und deckt alle 7 decal-bezogenen Methoden ab (5 für die Basisprojektion + 2 für das Verdeckungs-Culling); er kann direkt in Ihr Projekt kopiert werden.

using LCCCore;
using UnityEngine;

/// <summary>
/// Decal-Projektion — minimales Verwendungsbeispiel für Entwickler.
///
/// Dieses Skript simuliert ein „Integrator-Skript“: Es ruft nur die öffentlichen APIs von LCCManager auf und greift nicht auf SDK-Interna zu.
/// Deckt alle 7 Decal-APIs ab:
///   Basisprojektion (5): SetDecalEnabled / SetDecalTexture / SetDecalProjection / SetDecalOpacity / SetDecalEdgeFade
///   Verdeckungs-Culling (2): SetDecalOcclusion / SetDecalOcclusionSettings
///
/// Verwendungsschritte:
///   1) Ein leeres GameObject erstellen und dieses Skript anhängen;
///   2) Im Inspektor den LCCManager der Szene auf m_manager ziehen;
///   3) m_filePath auf einen gültigen LCC-Szenenpfad setzen;
///   4) Das zu projizierende Bild auf m_decalTexture ziehen (empfohlen, Read/Write in den Importeinstellungen zu aktivieren);
///   5) Ein leeres Objekt auf m_projector als Projektor ziehen (leer lassen, um dieses Objekt zu verwenden); seine +Z-Achse ist die Projektionsrichtung;
///   6) Play drücken. Nach Abschluss des Szenenladens schaltet sich das Decal automatisch ein; ziehen Sie den Projektor, um das Decal in Echtzeit auf der Punktwolke zu sehen.
///
/// Plattformhinweis: Decal und Verdeckungs-Culling wirken nur auf PC/Mac (URP). Aufrufe auf Mobil/VR werden vom SDK ignoriert und als Warnungen protokolliert.
/// </summary>
public class Decal : MonoBehaviour
{
    [Header("Erforderlich")]
    [Tooltip("Die LCCManager-Instanz in der Szene")]
    public LCCManager m_manager;
    [Tooltip("Ein gültiger LCC-Szenenpfad")]
    public string m_filePath;
    [Tooltip("Das zu projizierende Decal-Bild. RGB=Farbe, A=Maske des Decals")]
    public Texture2D m_decalTexture;

    [Header("Projektor (projiziert entlang +Z)")]
    [Tooltip("Projektor-Pose. Leer lassen, um die Transform dieses Objekts zu verwenden")]
    public Transform m_projector;
    [Range(1f, 179f)] public float m_fov = 60f;
    [Tooltip("Seitenverhältnis der Projektion; <=0 verwendet automatisch das Seitenverhältnis des Decal-Bildes")]
    public float m_aspect = 0f;
    public float m_near = 0.1f;
    public float m_far = 100f;

    [Header("Decal-Erscheinungsbild")]
    [Range(0f, 1f)] public float m_opacity = 1.0f;
    [Range(0f, 0.5f)][Tooltip("Breite der Kantenüberblendung (UV-Verhältnis). 0 = harte Kante")]
    public float m_edgeFade = 0.1f;
    [Tooltip("Projektion in jedem Frame aktualisieren, damit Sie den Projektor ziehen / Parameter zur Laufzeit anpassen können")]
    public bool m_updateEveryFrame = true;

    [Header("Verdeckungs-Culling (nur PC/Mac)")]
    [Tooltip("Wenn aktiviert, werden rückwärtige/verdeckte Punkte hinter der vorderen Geometrie nicht mehr vom Decal eingefärbt (Diaprojektor-Effekt); wenn deaktiviert, ist es röntgenartig")]
    public bool m_occlusion = false;
    [Range(0f, 1f)][Tooltip("Deckkraft-Schwellenwert: Nur Splats mit einer Deckkraft >= diesem Wert tragen zur Tiefenkarte bei, wodurch schwebende/nebelartige Punkte herausgefiltert werden. 0 = alle nehmen teil")]
    public float m_occlusionCutoff = 0f;
    [Range(0f, 0.5f)][Tooltip("Relative Tiefentoleranz. Zu klein -> Selbstverdeckung an der nahen Oberfläche; zu groß -> durchgesickerte röntgenartige Einfärbung. Standard 0.05")]
    public float m_occlusionBias = 0.05f;
    [Range(0, 16)][Tooltip("Maximaler quadratischer Footprint-Radius (px), der Hauptregler zum Entfernen von röntgenartigem Durchscheinen. 0 = einzelnes Texel, Standard 2")]
    public int m_occlusionFootprint = 2;
    [Tooltip("Auflösung der Tiefenkarte (px, Zweierpotenz 256~4096). Verringern, um Löcher bei flachen Winkeln zu füllen. Standard 1024")]
    public int m_occlusionResolution = 1024;

    // -- Laufzeit-Zustand --
    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 oder m_filePath ist nicht zugewiesen.");
            enabled = false;
            return;
        }

        // 1) Die Render-Pipeline auf den PC-Einzel-Szenen-Editor-Modus initialisieren
        m_manager.SetPlatformType(PlatformType.PC);
        m_manager.SwitchRenderPass(ActiveRenderMode.SingleRender);
        m_manager.SetEditorMode(true);

        // 2) Die Punktwolken-Szene laden und das Decal nach Abschluss aktivieren (das Decal ist ein globaler Zustand; es nach der Bereitschaft der Szene zu setzen ist am sichersten)
        var renderer = m_manager.GetRender(this.transform);
        Debug.Log($"[DecalDemo] Ladevorgang wird gestartet: {m_filePath}");
        renderer.Load(m_filePath,
            _ => { /* Fortschritts-Callback, im Beispiel ungenutzt */ },
            OnSceneLoaded);
    }

    private void OnSceneLoaded()
    {
        Debug.Log("[DecalDemo] Laden abgeschlossen, Decal-Projektion wird aktiviert.");

        // -- Basisprojektion: 5 APIs --
        m_manager.SetDecalTexture(m_decalTexture);   // Decal-Inhalt
        m_manager.SetDecalOpacity(m_opacity);        // Gesamt-Deckkraft
        m_manager.SetDecalEdgeFade(m_edgeFade);      // Kantenüberblendung
        ApplyProjection();                           // Projektor-Pose (ruft intern SetDecalProjection auf)
        m_manager.SetDecalEnabled(true);             // Decal aktivieren (_DECAL-Keyword)

        // -- Verdeckungs-Culling: 2 APIs -- muss nach ApplyProjection erfolgen (die Tiefenkarte benötigt eine gültige Projektor-VP-Matrix)
        m_manager.SetDecalOcclusionSettings(BuildOcclusionSettings());
        m_manager.SetDecalOcclusion(m_occlusion);
        CacheOcclusionState();

        m_loaded = true;
    }

    /// <summary>
    /// Nur zur Veranschaulichung. In realen Projekten müssen Sie für bessere Leistung
    /// SetDecalProjection / SetDecalOpacity / SetDecalEdgeFade nicht in jedem Frame in Update() aufrufen;
    /// rufen Sie die entsprechende API nur auf, wenn sich der Parameter ändert.
    /// </summary>
    void Update()
    {
        if (!m_loaded) return;

        // Verdeckung zur Laufzeit umschalten
        if (m_occlusion != m_lastOcclusion)
        {
            m_manager.SetDecalOcclusion(m_occlusion);
            m_lastOcclusion = m_occlusion;
        }

        // Wenn sich ein Qualitätsparameter der Verdeckung geändert hat -> die Struktur einmal übergeben
        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();
        }

        // Projektor / Erscheinungsbild in jedem Frame aktualisieren, für bequemes Debuggen in Echtzeit
        if (!m_updateEveryFrame) return;
        m_manager.SetDecalOpacity(m_opacity);
        m_manager.SetDecalEdgeFade(m_edgeFade);
        ApplyProjection();
    }

    /// <summary>Die Projektionsmatrix aus der aktuellen Projektor-Pose und den Perspektivparametern aufbauen.</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>Die 4 Verdeckungsparameter in einer Struktur zusammenführen.</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;
    }

    // -- Bequeme Debug-Einstiegspunkte (Rechtsklick im Inspektor) --
    [ContextMenu("Decal an")]  private void DecalOn()  { m_manager?.SetDecalEnabled(true); }
    [ContextMenu("Decal aus")] private void DecalOff() { m_manager?.SetDecalEnabled(false); }
    [ContextMenu("Verdeckung an")]  private void OcclusionOn()  { m_occlusion = true;  m_manager?.SetDecalOcclusion(true);  m_lastOcclusion = true; }
    [ContextMenu("Verdeckung aus")] private void OcclusionOff() { m_occlusion = false; m_manager?.SetDecalOcclusion(false); m_lastOcclusion = false; }
}

Hinweis:

Das Decal ist ein globaler Schattierungszustand und muss nach Abschluss des Ladens der LCC-Szene (d. h. im Callback onComplete) gesetzt werden.

Das Beispiel legt SetDecalTexture / SetDecalProjection / SetDecalEnabled in den Abschluss-Callback von Load (OnSceneLoaded), um zu vermeiden, dass sie vor der Bereitschaft der Punktwolke gesetzt werden.

Die verdeckungsbezogenen SetDecalOcclusionSettings / SetDecalOcclusion müssen nach ApplyProjection (also SetDecalProjection) aufgerufen werden, da die Verdeckungs-Tiefenkarte eine gültige Projektor-View-Projection-Matrix benötigt.

Schritt 4: Das Skript anhängen und die Eigenschaften konfigurieren

1. Hängen Sie das Skript Decal.cs im Fenster Hierarchie an das GameObject LCCRenderer.
2. Ziehen Sie im Fenster Inspektor das GameObject LCCManager auf die Eigenschaft Manager des Skripts.
3. Ziehen Sie das GameObject Projektor auf die Eigenschaft Projector des Skripts.
4. Tragen Sie den LCC-Dateipfad in die Eigenschaft File Path des Skripts ein und ziehen Sie das Decal-Texturbild auf die Eigenschaft Decal Texture.
5. Die übrigen Eigenschaften können nach Bedarf angepasst werden; die Bedeutung der einzelnen Eigenschaften ist in der folgenden Tabelle dargestellt.

Eigenschaftseinstellungen im Inspektor für das Decal-Skript

Schritt 5: Ausführen und den Effekt beobachten

Klicken Sie in Unity auf die Schaltfläche Play. Nach Abschluss des Szenenladens schaltet sich das Decal automatisch ein. Wenn Update Every Frame aktiviert ist, können Sie das Projektor-Objekt während der Laufzeit direkt in der Ansicht Szene ziehen und sehen, wie sich das Decal in Echtzeit auf der 3DGS-Oberfläche bewegt; das Anpassen von Parametern wie Opacity und Edge Fade wird ebenfalls sofort wirksam. Das Rechtsklick-Menü der Skriptkomponente stellt außerdem vier Verknüpfungen bereit — Decal an/aus und Verdeckung an/aus — um den An-/Aus-Effekt bequem separat zu überprüfen.

Nach dem Ausführen auf die 3DGS-Oberfläche projiziertes Decal (Basisprojektion, Röntgen-Durchdringung)

Nach dem Aktivieren des Verdeckungs-Cullings wird nur die dem Projektor zugewandte Vorderfläche eingefärbt (Diaprojektor-Effekt)

FAQ: Kompatibilitätsmodus deaktivieren

Wenn das Unity-Fenster Konsole Fehler meldet und kein Decal-Effekt erscheint, deaktivieren Sie den Kompatibilitätsmodus: Öffnen Sie das Einstellungsfenster über Bearbeiten → Projekteinstellungen → Grafik, wählen Sie den Tab URP und aktivieren Sie das Kontrollkästchen hinter Render Graph → Compatibility Mode (Render Graph Disabled) nicht.

Den Render-Graph-Kompatibilitätsmodus nicht aktivieren (Render Graph Disabled)

Verdeckungs-Culling und Abstimmung

Das Verdeckungs-Culling muss aktiviert werden, nachdem der Projektor eingerichtet wurde. Das Beispiel ruft im Abschluss-Callback des Szenenladens zuerst SetDecalProjection auf und anschließend SetDecalOcclusionSettings und SetDecalOcclusion, um sicherzustellen, dass die Verdeckungs-Tiefenkarte eine gültige Projektor-View-Projection-Matrix erhält. Aktivieren Sie zur Laufzeit das Kontrollkästchen Occlusion im Inspektor, um zu sehen, wie die durchdrungenen Blöcke ausgeblendet werden und nur die dem Projektor zugewandte Vorderfläche erhalten bleibt.

Voraussetzung:

Vor dem Aktivieren des Verdeckungs-Cullings muss das Decal Depth Feature bereits im URP-Renderer-Asset registriert sein (in diesem Projekt wurde es als Sub-Asset in URP_Renderer.asset geschrieben). Wenn es nicht registriert ist, wird die Verdeckungs-Tiefenkarte nicht erzeugt und die Verdeckung wird nicht wirksam.

Die Verdeckungsqualität wird über vier Parameter gesteuert, die alle auf einmal über eine Struktur übergeben werden. Die vier sind zueinander orthogonal; stimmen Sie sie gemäß der folgenden Tabelle ab:

Schlüsselschritte

Die Schlüsselschritte zur Implementierung projizierter Decals:

1. Das leere Objekt Projektor in der Szene als Projektor erstellen; seine +Z-Achse ist die Projektionsrichtung.
2. Wenn Verdeckungs-Culling benötigt wird, sicherstellen, dass das Decal Depth Feature zum URP-Renderer hinzugefügt wurde.
3. Nach Abschluss des Ladens der LCC-Szene nacheinander Decal-Textur, Erscheinungsbild und Projektor-Pose festlegen und anschließend das Decal aktivieren (SetDecalEnabled(true)).
4. Die Verdeckungs-Culling-Aufrufe SetDecalOcclusionSettings / SetDecalOcclusion müssen nach SetDecalProjection erfolgen.

Decal-bezogene APIs

Die folgenden Methoden befinden sich alle auf der Fassadenklasse LCCManager und wirken nur auf PC / Mac (URP-Pipeline); Aufrufe auf Mobil/VR werden ignoriert und eine Warnung wird ausgegeben.

SetDecalEnabled

// Rückgabewert: void
public void SetDecalEnabled(bool enable)

Schaltet die Decal-Projektion um. Wenn aktiviert, werden die aktuell zwischengespeicherten Deckkraft-/Kantenüberblendungsparameter an die GPU übergeben und das Shader-Keyword _DECAL aktiviert. Das Decal ist ein weltfester globaler Zustand, der für alle Kameras konsistent ist. Sie müssen außerdem SetDecalTexture und SetDecalProjection aufrufen, um den Inhalt und die Projektor-Pose festzulegen.

Verwendungsbeispiel:

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

Hinweise:

• Wenn deaktiviert, wird nur das Keyword _DECAL deaktiviert; die zwischengespeicherte Textur / die Parameter werden nicht gelöscht.

SetDecalTexture

// Rückgabewert: void
public void SetDecalTexture(Texture2D tex)

Legt die Decal-Textur fest. RGB ist Farbe und A ist die Maske des Decals, die mit der globalen Deckkraft und der Kantenüberblendung multipliziert wird.

Verwendungsbeispiel:

m_manager.SetDecalTexture(logoTex);

Hinweise:

• Die Übergabe von null löscht die globale Textur-Referenz.

SetDecalProjection

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

Legt Pose und Perspektivparameter des Decal-Projektors fest. Der Projektor projiziert entlang seiner Vorwärtsrichtung (+Z), und Punkte innerhalb des Frustums werden vom Decal bedeckt.

Verwendungsbeispiel:

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

Hinweise:

• Wenn SetDecalOcclusion(true) bereits aktiviert ist, leitet diese Methode die neue VP-/Ansichtsmatrix synchron an das Decal Depth Feature weiter.

SetDecalOpacity

// Rückgabewert: void
public void SetDecalOpacity(float opacity)

Legt die Gesamt-Deckkraft des Decals fest und übergibt sie sofort an die GPU; sie wird für die Wiederverwendung beim nächsten Aufruf von SetDecalEnabled(true) zwischengespeichert.

Verwendungsbeispiel:

m_manager.SetDecalOpacity(0.8f);

Hinweise:

• Bereich [0, 1]; Werte außerhalb des Bereichs werden automatisch begrenzt.

SetDecalEdgeFade

// Rückgabewert: void
public void SetDecalEdgeFade(float edgeFade)

Legt die Breite der Kantenüberblendung des Decals fest. 0 ist eine harte Kante, und je größer der Wert, desto weicher der Kantenübergang.

Verwendungsbeispiel:

m_manager.SetDecalEdgeFade(0.1f);

Hinweise:

• Bereich [0, 0.5); Werte außerhalb des Bereichs werden automatisch begrenzt.

SetDecalOcclusion

// Rückgabewert: void
public void SetDecalOcclusion(bool enable)

Schaltet das Decal-Verdeckungs-Culling um (basierend auf der Projektor-Tiefenkarte), das orthogonal zur Schattenfunktion ist und unabhängig von ihr umgeschaltet wird. SetDecalProjection sollte vor dem Aktivieren aufgerufen worden sein, um den Projektor festzulegen, andernfalls hat die Tiefenkarte keine gültige VP-Matrix.

Verwendungsbeispiel:

m_manager.SetDecalOcclusion(true);

Hinweise:

• Nur auf URP unterstützt (Aufrufe in der Built-in-Pipeline sind wirkungslos und geben eine Meldung aus).
• Erfordert, dass das Decal Depth Feature im URP-Renderer-Asset registriert ist.
• Hängt von den über SetDecalOcclusionSettings konfigurierten Qualitätsparametern ab.

SetDecalOcclusionSettings

// Rückgabewert: void
public void SetDecalOcclusionSettings(DecalOcclusionSettings settings)

Legt alle Qualitätsparameter des Decal-Verdeckungs-Cullings auf einmal fest (die Bedeutung der vier Elemente finden Sie in der Struktur unten und in der Tabelle „Verdeckungs-Culling und Abstimmung“).

Verwendungsbeispiel:

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

Hinweise:

• Kann jederzeit angepasst werden; die Parameter werden sofort an die GPU und das Decal Depth Feature übergeben.
• Das Ändern von resolution löst einen Neuaufbau der Tiefenkarten-RT aus.

Zugehörige Datenstrukturen

DecalOcclusionSettings

public struct DecalOcclusionSettings {
    public float opacityCutoff;   // [0,1] Mindestdeckkraft für die Teilnahme eines Splats an der Tiefenkarte, Standard 0 (alle nehmen teil)
    public float depthBias;       // relatives Tiefentoleranz-Verhältnis, Standard 0.05
    public int   footprintMaxPx;  // maximaler quadratischer Footprint-Radius (px), 0~16, Standard 2
    public int   resolution;      // Auflösung der Tiefenkarte (px, Zweierpotenz, 256~4096), Standard 1024

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

Wird von SetDecalOcclusionSettings() verwendet; der Standardwert kann über DecalOcclusionSettings.Default bezogen werden.

Hinweise

• Nur auf PC / Mac wirksam. Aufrufe decal-bezogener Schnittstellen auf Mobil- und VR-Plattformen werden ignoriert und geben eine Warnung aus. Sie müssen auf der Geschäftsseite keine Plattformprüfungen durchführen, sollten aber auf diesen Plattformen keinen Effekt erwarten.
• Es wird empfohlen, das Decal nach Abschluss des Szenenladens zu setzen. Das Decal ist ein globaler Schattierungszustand; das Beispiel legt SetDecalTexture / SetDecalProjection / SetDecalEnabled in den Abschluss-Callback von Load, um zu vermeiden, dass sie vor der Bereitschaft der Punktwolke gesetzt werden.
• Das Verdeckungs-Culling hängt von zwei Voraussetzungen ab. Erstens hat das URP-Renderer-Asset das Decal Depth Feature registriert; zweitens wurde SetDecalProjection aufgerufen, um den Projektor festzulegen. Fehlt eine der beiden, wird die Verdeckung nicht wirksam.
• Statische Projektion hat nahezu keinen zusätzlichen Aufwand. Die Verdeckungs-Tiefenkarte wird nur neu berechnet, wenn sich die Projektor-Pose oder die Punktwolke ändert; bei stationärem Projektor gibt es keine zusätzliche Berechnung pro Frame.