Ontwikkelgids voor realtime knippen

De LCC Unity SDK ondersteunt bewerkingsbewerkingen zoals markeren en knippen op 3DGS-scènes. Deze gids behandelt realtime knipbewerkingen: het selecteren van een gebied via 2D-geprojecteerde texturen, 3D-geometrie of een combinatie van beide, het uit de scène knippen van het geselecteerde gebied, met ondersteuning voor normale selectie en omgekeerde selectie.

Opmerking:
De huidige knipfunctie is slechts een runtime-weergave-effect; het wijzigt het oorspronkelijke gegevensbestand op geen enkele manier en ondersteunt het opslaan of exporteren van het bewerkingsresultaat niet. Gebruik de XGRIDS LCC Editor-softwaretool als je kleuraanpassing, knippen en opslaan van gegevens nodig hebt.
Als je de gegevens niet wilt wijzigen, kun je de bewerkingen ook opnemen en ze de volgende keer na het laden van de gegevens opnieuw afspelen.

Vereisten

Het knippen van een scène via de SDK vereist de volgende voorwaarden:

Ga vóór het laden van de gegevens naar de bewerkstatus. De SDK bevindt zich standaard in de browse-status (View), die de beste prestaties biedt en wordt aanbevolen voor normaal browsen. Schakel voor bewerkingsbewerkingen zoals knippen via SetEditorMode(true) naar de bewerkstatus voordat je Load aanroept. Deze methode werkt alleen als deze wordt aangeroepen vóór het laden van alle gegevens.
Voer de knipbewerking uit nadat de gegevens zijn geladen. De knipinterface moet worden aangeroepen nadat de scènegegevens volledig zijn geladen.

Stap 1: De scène opzetten

Bereid de GameObjects voor die nodig zijn voor knippen in de scène, zoals hieronder wordt weergegeven.

Scènehiërarchiestructuur voor het knipvoorbeeld

Main Camera: de scènecamera; 2D-knippen gebruikt de view- en projectiematrices ervan.
LCCManager: een leeg GameObject met een genormaliseerde Transform, waaraan het LCCManager-script is toegevoegd.
LCCRenderer: een leeg GameObject met de Transform ingesteld op Rotation.x = -90, Scale.x = -1 (uitgelijnd met het coördinatensysteem van de LCC-gegevens), gebruikt om het later te schrijven Clip-script aan toe te voegen.
3D-selectiegeometrie: hulpobjecten voor 3D-knippen. Het voorbeeld bevat 3 Cubes (Box1, Box2, Box3) en 1 Sphere (Clipsphere); door deze objecten te verplaatsen en te schalen, wordt de positie en grootte van de knipselectie bepaald.

Opmerking:
Raadpleeg voor instellingen met betrekking tot de rendercamera, LCCManager en LCCRenderer-GameObjects de relevante secties van Snelstartgids voor pc en Optimalisatiegids voor projectinstellingen.

Selectiegeometrie die wordt gebruikt voor 3D-knippen (Box1 / Box2 / Box3 / Clipsphere)

Stap 2: De gegevensstructuren begrijpen

Bij knippen zijn drie bewerkingsmethoden betrokken — 2D, 3D en 2D/3D gemengd. De gebruikte enums en structs zijn als volgt.

public enum SelectMode    { normal, invert, clip }  // normale selectie, inverteren, realtime knippen
public enum OperationMode { normal, erase }         // normale selectie, selectie wissen
public enum ShapeType     { box, sphere }           // 3D Box-selectie, 3D Sphere-selectie
public enum EditType      { Edit2D, Edit3D }        // 2D-bewerking, 3D-bewerking

// 2D-textuurselectie
public struct Data2D
{
    public Texture2D texture;   // 2D-maskertextuur
    public Matrix4x4 mv;        // cameraviewmatrix
    public Matrix4x4 mvp;       // cameraview-projectiematrix
    public SelectMode mode;     // selectiemodus
}

// 3D-geometrieselectie
public struct Data3D
{
    public ShapeType type;          // geometrietype (box / sphere)
    public Matrix4x4 invMat;        // world-to-local (inverse) matrix van de geometrie
    public OperationMode operation; // bewerkingstype (normale vereniging / wissen verschil)
    public SelectMode mode;         // selectiemodus
}

// 2D / 3D gemengde selectie
public struct DataMix
{
    public EditType editType;       // bewerkingstype (vereist; bepaalt of 2D- of 3D-velden worden gebruikt)
    public Texture2D texture;       // 2D-maskertextuur (gebruikt door Edit2D)
    public Matrix4x4 mv;            // cameraviewmatrix (gebruikt door Edit2D)
    public Matrix4x4 mvp;           // cameraview-projectiematrix (gebruikt door Edit2D)
    public ShapeType type;          // geometrietype (gebruikt door Edit3D)
    public Matrix4x4 invMat;        // inverse matrix van de geometrie (gebruikt door Edit3D)
    public OperationMode operation; // bewerkingstype (gebruikt door Edit3D)
    public SelectMode mode;         // selectiemodus (vereist)
}

Er zijn drie punten om op te letten bij de selectielijst:

De lijst is geordend. Of het nu 2D of 3D is, items in de lijst worden op volgorde van kracht; zorg ervoor dat de volgorde van toevoegen overeenkomt met je verwachting.
Inverteren is een bewerkingsopdracht en hoeft niet te worden gekoppeld aan specifieke selectiegegevens. Voeg eenvoudig een item toe met mode = SelectMode.invert om het momenteel geselecteerde gebied te inverteren.
Het maximumaantal items in één lijst is 255. Bij overschrijding wordt een foutcode geretourneerd.

Stap 3: De knip-API's begrijpen

Alle knipgerelateerde interfaces worden geleverd door LCCManager, waaronder drie SetClip-overloads en één afsluitmethode.

SetClip (2D-textuurknippen)

// Retourwaarde: int
// 0: succes
// 1: lijst is null of heeft 0 elementen
// 2: lijstelementen overschrijden het maximum van 255
public int SetClip(List<Data2D> _2Ds)

Knipt de scène met behulp van een 2D-geprojecteerd textuurmasker; het gemarkeerde gebied wordt uit de scène geknipt.

SetClip (3D-geometrieknippen)

// Retourwaarde: int
// 0: succes
// 1: lijst is null of heeft 0 elementen
// 2: lijstelementen overschrijden het maximum van 255
// 3: het aantal selectiegeometrieën is 0
public int SetClip(List<Data3D> _3Ds)

Definieert het knipgebied met behulp van 3D-geometrie (balk, kubus, bol), met ondersteuning voor combinaties van vereniging en verschil. Er is ten minste één geometrie met operation == OperationMode.normal vereist.

SetClip (gemengde-modusknippen)

// Retourwaarde: int
// 0: succes
// 1: lijst is null of heeft 0 elementen
// 2: lijstelementen overschrijden het maximum van 255
public int SetClip(List<DataMix> _Mix)

Definieert het knipgebied met behulp van 2D-texturen en 3D-geometrie tegelijk; elk item bepaalt via editType of het als 2D of 3D wordt verwerkt.

QuitClipMode

// Retourwaarde: void
public void QuitClipMode()

Sluit de knipmodus af en herstelt de volledige scèneweergave.

Tip:
De drie SetClip-overloads sluiten elkaar uit. Roep bij het wisselen van knipmethode of het wissen van de huidige knipbewerking eerst QuitClipMode() aan en stel vervolgens de nieuwe knipbewerking in.

Stap 4: Specificatie van de 2D-maskertextuur

2D-knippen beschrijft de selectie via een maskertextuur en ondersteunt diverse selectiemethoden zoals vierhoeken, driehoeken, penselen en lasso's — markeer eenvoudig de overeenkomstige pixels in de textuur met de knipwaarde. Bij 2D-bewerkingen moet de camera worden vergrendeld en moet de textuur vanuit een vast gezichtspunt worden gemarkeerd. De textuur- en pixelwaarden volgen deze conventies:

De textuur is vast op 1024 × 1024, R8 enkel kanaal, geen Mipmap, puntfiltering (FilterMode.Point) en geklemde sampling (TextureWrapMode.Clamp).
Conventies voor pixelwaarden:

Pixelwaarde	Betekenis
`128`	Standaard (behouden)
`240`	Geselecteerd
`180`	Deselecteren (het al geselecteerde gebied wissen)
`0`	Knippen

In een knipscenario worden doorgaans alleen de twee waarden 128 (standaard behouden) en 0 (knippen) gebruikt.

Stap 5: Het script schrijven

Maak een nieuw C#-script aan met de naam Clip.cs. Voltooi eerst het basisskelet: ga in Start naar de bewerkstatus en laad de gegevens; stel na het laden de laadmarkering in zodat de latere knipmethoden deze kunnen controleren.

using LCCCore;
using System.Collections.Generic;
using UnityEngine;

public class Clip : MonoBehaviour
{
    public LCCManager m_manager;
    public string m_FilePath;
    public GameObject m_Box1;
    public GameObject m_Box2;
    public GameObject m_Box3;
    public GameObject m_Clipsphere;

    private LCCCore.Renderer m_renderer;
    private Camera m_camera;
    private bool m_isLoaded = false;

    void Start()
    {
        m_camera = Camera.main;
        m_manager.SetPlatformType(PlatformType.PC);

        // Ga naar de bewerkmodus; moet vóór Load worden aangeroepen
        m_manager.SetEditorMode(true);

        m_renderer = m_manager.GetRender(this.transform);
        if (m_renderer == null)
            Debug.LogError("GetRender mislukt, controleer of de manager correct is ingesteld en of het bestandspad geldig is.");

        m_renderer.Load(m_FilePath, onLoadProgress, onLoadCallback);
    }

    private void onLoadProgress(float value)
    {
        Debug.Log($"laadvoortgang: {value}");
    }

    private void onLoadCallback()
    {
        Debug.Log("gegevens geladen !!!");
        m_isLoaded = true;

        // Schakel de rendering van de omgeving (lage-precisie puntenwolk in het verre veld) uit om het knipresultaat beter te kunnen observeren
        m_renderer.SetEnvironment(false);
    }

    // 2D / 3D / gemengde knipmethoden hieronder
}

Opmerking:
SetEditorMode(true) moet vóór Load worden aangeroepen om van kracht te worden; en SetClip moet worden aangeroepen nadat de gegevens zijn geladen (nadat de onLoadCallback-callback is geactiveerd). SetEnvironment(false) schakelt de omgevingspuntenwolk in het verre veld uit om het knipresultaat duidelijker te maken; bepaal zelf of je dit aanroept.

Stap 6: Het script toevoegen en eigenschappen instellen

Voeg het Clip.cs-script toe aan het LCCRenderer-GameObject.
Sleep in het Inspector-venster het LCCManager-GameObject naar de eigenschap Manager van het script.
Vul het LCC-bestandspad in bij de eigenschap File Path.
Sleep Box1, Box2, Box3 en Clipsphere in de scène respectievelijk naar de bijbehorende eigenschappen van het script.

Stel de eigenschappen van het Clip-script in de Inspector in

Stap 7: Voorbeelden van knipbewerkingen

Voeg de onderstaande methoden toe aan de klasse Clip en roep de bijbehorende methode na het uitvoeren en na het laden van de gegevens aan.

2D-textuurknippen

Maak twee R8-maskertexturen, markeer de te knippen pixels als 0 en de rest van het behouden gebied als 128, maak vervolgens Data2D met de cameramatrices en voeg deze toe aan de lijst.

public void on2DClip()
{
    // Textuurgrootte is vast op 1024*1024; houd de overige eigenschappen gelijk aan het voorbeeld
    Texture2D _texture = new Texture2D(1024, 1024, TextureFormat.R8, false);
    _texture.filterMode = FilterMode.Point;
    _texture.wrapMode = TextureWrapMode.Clamp;

    int _count = 1024 * 1024;
    int _half = _count / 2;
    byte[] _values = new byte[_count];
    for (int i = 0; i < _count; i++)
    {
        if (i < _half)
            _values[i] = 0;      // 0 betekent knippen, 128 betekent standaard, 240 betekent geselecteerd
        else
            _values[i] = 128;
    }
    _texture.SetPixelData(_values, 0);

    Texture2D _texture2 = new Texture2D(1024, 1024, TextureFormat.R8, false);
    _texture2.filterMode = FilterMode.Point;
    _texture2.wrapMode = TextureWrapMode.Clamp;
    byte[] _values2 = new byte[_count];
    for (int i = 0; i < _count; i++)
    {
        if (i > _count * 0.75 && i < _count * 0.9)
            _values2[i] = 0;
        else
            _values2[i] = 128;
    }
    _texture2.SetPixelData(_values2, 0);

    List<Data2D> _2Ds = new List<Data2D>();
    Data2D _2d01 = new Data2D();
    _2d01.mv = m_camera.worldToCameraMatrix;
    _2d01.texture = _texture;
    _2d01.mode = SelectMode.normal;
    _2d01.mvp = GL.GetGPUProjectionMatrix(m_camera.projectionMatrix, true) * m_camera.worldToCameraMatrix;
    _2Ds.Add(_2d01);

    Data2D _2d02 = new Data2D();
    _2d02.mv = m_camera.worldToCameraMatrix;
    _2d02.texture = _texture2;
    _2d02.mode = SelectMode.normal;
    _2d02.mvp = GL.GetGPUProjectionMatrix(m_camera.projectionMatrix, true) * m_camera.worldToCameraMatrix;
    _2Ds.Add(_2d02);

    m_manager.SetClip(_2Ds);
}

Code-uitleg: er worden twee maskertexturen opgebouwd. Het eerste masker knipt de onderste helft van het scherm (de schermoorsprong is de linkerbenedenhoek) en het tweede masker knipt het 0.75 tot 0.9-gebied van de bovenste helft van het scherm. Het voorbeeldeffect is als volgt.

In de praktijk kun je verschillende selectietools zoals rechthoeken, driehoeken, penselen en lasso's gebruiken om de overeenkomstige posities op het masker te selecteren.

Effect van 2D-textuurknippen

3D-geometrieknippen

Gebruik de worldToLocalMatrix van de geometrie als de selectie-inversematrix, combineer vereniging (normal) en verschil (erase) via operation, en implementeer omgekeerde selectie via een item met mode = SelectMode.invert.

public void on3DClip()
{
    List<Data3D> _3Ds = new List<Data3D>();
    var _mat1 = m_Box1.transform.worldToLocalMatrix;
    var _mat2 = m_Box2.transform.worldToLocalMatrix;
    var _mat3 = m_Box3.transform.worldToLocalMatrix;
    var _mat4 = m_Clipsphere.transform.worldToLocalMatrix;

    // Box-selectie
    Data3D _3d01 = new Data3D();
    _3d01.type = ShapeType.box;
    _3d01.operation = OperationMode.normal;
    _3d01.mode = SelectMode.normal;
    _3d01.invMat = _mat1;
    _3Ds.Add(_3d01);

    Data3D _3d02 = new Data3D();
    _3d02.type = ShapeType.box;
    _3d02.operation = OperationMode.normal;
    _3d02.mode = SelectMode.normal;
    _3d02.invMat = _mat2;
    _3Ds.Add(_3d02);

    // Sphere-selectie
    Data3D _3d04 = new Data3D();
    _3d04.type = ShapeType.sphere;
    _3d04.operation = OperationMode.normal;
    _3d04.mode = SelectMode.normal;
    _3d04.invMat = _mat4;
    _3Ds.Add(_3d04);

    // Box/Sphere wissen (verschil)
    Data3D _3d03 = new Data3D();
    _3d03.type = ShapeType.box;
    _3d03.operation = OperationMode.erase;
    _3d03.mode = SelectMode.normal;
    _3d03.invMat = _mat3;
    _3Ds.Add(_3d03);

    // Inverteren
    //Data3D _3d05 = new Data3D();
    //_3d05.mode = SelectMode.invert;
    //_3Ds.Add(_3d05);

    m_manager.SetClip(_3Ds);
}

Code-uitleg: er worden 4 geometrieën gebruikt, waarbij Box1, Box2 en Sphere normale selecties zijn en Box3 een wisselectie is, dat wil zeggen het wissen van het eerder geselecteerde gebied. Met de inverteren-gerelateerde code uitgecommentarieerd is het voorbeeldeffect als volgt:

Effect van 3D-geometrieknippen

Haal het commentaar van de inverteren-code weg zodat inverteren van kracht wordt; het voorbeeldeffect is als volgt. Inverteren draait het eerder geselecteerde gebied om; het is een opdracht en hoeft niet te worden gekoppeld aan bewerkingsgegevens.

Let er vooral op dat de lijst geordend is; verschillende bewerkingsstappen produceren verschillende eindeffecten.

Effect van 3D-geometrie + inverteren knippen

Gemengde-modusknippen

Meng 2D-textuur- en 3D-geometrie-items in dezelfde lijst; elk item geeft via editType zijn verwerkingsmethode op.

public void onMixClip()
{
    // --- Voorbereiding van 2D-selectie ---
    // Textuurgrootte is vast op 1024*1024; houd de overige eigenschappen gelijk aan het voorbeeld
    Texture2D _texture = new Texture2D(1024, 1024, TextureFormat.R8, false);
    _texture.filterMode = FilterMode.Point;
    _texture.wrapMode = TextureWrapMode.Clamp;

    int _count = 1024 * 1024;
    int _half = _count / 2;
    byte[] _values = new byte[_count];
    for (int i = 0; i < _count; i++)
    {
        if (i < _half)
            _values[i] = 128;    // 128 betekent standaard, 240 betekent geselecteerd, 0 betekent knippen
        else
            _values[i] = 0;
    }
    _texture.SetPixelData(_values, 0);

    List<DataMix> _Mixs = new List<DataMix>();
    DataMix _mix01 = new DataMix();
    _mix01.editType = EditType.Edit2D;
    _mix01.mv = m_camera.worldToCameraMatrix;
    _mix01.texture = _texture;
    _mix01.mode = SelectMode.normal;
    _mix01.mvp = GL.GetGPUProjectionMatrix(m_camera.projectionMatrix, true) * m_camera.worldToCameraMatrix;
    _Mixs.Add(_mix01);

    // --- Voorbereiding van 3D-selectie ---
    var _mat1 = m_Box1.transform.worldToLocalMatrix;
    var _mat2 = m_Box2.transform.worldToLocalMatrix;
    var _mat3 = m_Box3.transform.worldToLocalMatrix;
    var _mat4 = m_Clipsphere.transform.worldToLocalMatrix;

    // Box-selectie
    DataMix _mix02 = new DataMix();
    _mix02.editType = EditType.Edit3D;
    _mix02.type = ShapeType.box;
    _mix02.operation = OperationMode.normal;
    _mix02.mode = SelectMode.normal;
    _mix02.invMat = _mat1;
    _Mixs.Add(_mix02);

    DataMix _mix03 = new DataMix();
    _mix03.editType = EditType.Edit3D;
    _mix03.type = ShapeType.box;
    _mix03.operation = OperationMode.normal;
    _mix03.mode = SelectMode.normal;
    _mix03.invMat = _mat2;
    _Mixs.Add(_mix03);

    // Sphere-selectie
    DataMix _mix04 = new DataMix();
    _mix04.editType = EditType.Edit3D;
    _mix04.type = ShapeType.sphere;
    _mix04.operation = OperationMode.normal;
    _mix04.mode = SelectMode.normal;
    _mix04.invMat = _mat4;
    _Mixs.Add(_mix04);

    // Box/Sphere wissen (verschil)
    DataMix _mix05 = new DataMix();
    _mix05.editType = EditType.Edit3D;
    _mix05.type = ShapeType.box;
    _mix05.operation = OperationMode.erase;
    _mix05.mode = SelectMode.normal;
    _mix05.invMat = _mat3;
    _Mixs.Add(_mix05);

    // Inverteren (naar behoefte inschakelen)
    DataMix _mix06 = new DataMix();
    _mix06.editType = EditType.Edit3D;
    _mix06.type = ShapeType.box;
    _mix06.mode = SelectMode.invert;
    //_Mixs.Add(_mix06);

    m_manager.SetClip(_Mixs);
}

Code-uitleg: er worden 4 geometrieën en 1 2D-textuur gebruikt, waarmee 2D- en 3D-gemengde verwerking mogelijk is. Het voorbeeldeffect is als volgt:

Effect van gemengde-modusknippen

Stap 8: Knippen afsluiten

Roep QuitClipMode() aan om de huidige knipbewerking te wissen en de volledige scèneweergave te herstellen.

public void onClearClip()
{
    m_manager.QuitClipMode();
}

Belangrijkste stappen

De belangrijkste stappen voor het realtime knippen van een 3DGS-scène:

Roep SetEditorMode(true) vóór het laden van de gegevens aan om naar de bewerkstatus te gaan.
Roep SetClip nadat de gegevens zijn geladen aan (nadat de onLoadCallback-callback is geactiveerd, of geactiveerd via een knop/gebeurtenis).
Kies naar behoefte 2D-textuur, 3D-geometrie of gemengde modus en zorg ervoor dat de volgorde van toevoegen van de selectielijst overeenkomt met je verwachting.
De 2D-maskertextuur is vast op 1024 × 1024, R8 enkel kanaal; vul de pixelwaarden volgens conventie in (128 standaard behouden, 0 knippen).
Roep bij het wissen of wisselen van knipbewerkingen eerst QuitClipMode() aan.