Entiteiten

Een entiteit vertegenwoordigt een verplaatsbaar object in de ruimte en is de fundamentele bouwsteen van extern gerenderde inhoud.

Entiteitseigenschappen

Entiteiten hebben een transformatie gedefinieerd door een positie, rotatie en schaal. Zelf hebben entiteiten geen waarneembare functionaliteit. In plaats daarvan wordt gedrag toegevoegd via onderdelen die zijn gekoppeld aan entiteiten. Als u bijvoorbeeld een CutPlaneComponent koppelt, wordt er een snijvlak gemaakt op de positie van de entiteit.

Het belangrijkste aspect van de entiteit zelf is de hiërarchie en de resulterende hiërarchische transformatie. Wanneer bijvoorbeeld meerdere entiteiten zijn gekoppeld als onderliggende elementen aan een gedeelde bovenliggende entiteit, kunnen al deze entiteiten worden verplaatst, gedraaid en geschaald in één entiteit door de transformatie van de bovenliggende entiteit te wijzigen. Daarnaast kan de status van enabled de entiteit worden gebruikt om zichtbaarheid en antwoorden op raycasts uit te schakelen voor een volledige subgrafiek in de hiërarchie.

Een entiteit is uniek eigendom van de bovenliggende entiteit, wat betekent dat wanneer het bovenliggende element wordt vernietigd, Entity.Destroy()dus de onderliggende elementen en alle verbonden onderdelen. Het verwijderen van een model uit de scène wordt dus bereikt door het hoofdknooppunt van een model aan te roepen Destroy , geretourneerd door RenderingSession.Connection.LoadModelAsync() of de SAS-variant RenderingSession.Connection.LoadModelFromSasAsync().

Entiteiten worden gemaakt wanneer de server inhoud laadt of wanneer de gebruiker een object aan de scène wil toevoegen. Als een gebruiker bijvoorbeeld een snijvlak wil toevoegen om het interieur van een mesh te visualiseren, kan de gebruiker een entiteit maken waarin het vliegtuig moet bestaan en vervolgens het knipvlakonderdeel eraan toevoegen.

Een entiteit maken

Als u een nieuwe entiteit wilt toevoegen aan de scène, bijvoorbeeld om deze als hoofdobject door te geven voor het laden van modellen of om onderdelen eraan te koppelen, gebruikt u de volgende code:

Entity CreateNewEntity(RenderingSession session)
{
    Entity entity = session.Connection.CreateEntity();
    entity.Position = new LocalPosition(1, 2, 3);
    return entity;
}
ApiHandle<Entity> CreateNewEntity(ApiHandle<RenderingSession> session)
{
    ApiHandle<Entity> entity(nullptr);
    if (auto entityRes = session->Connection()->CreateEntity())
    {
        entity = entityRes.value();
        entity->SetPosition(Double3{ 1, 2, 3 });
        return entity;
    }
    return entity;
}

Queryfuncties

Er zijn twee typen queryfuncties voor entiteiten: synchrone en asynchrone aanroepen. Synchrone query's kunnen alleen worden gebruikt voor gegevens die aanwezig zijn op de client en er zijn niet veel berekeningen nodig. Voorbeelden zijn het uitvoeren van query's op onderdelen, relatieve objecttransformaties of bovenliggende/onderliggende relaties. Asynchrone query's worden gebruikt voor gegevens die zich alleen op de server bevinden of extra berekeningen omvat die te duur zijn om op de client uit te voeren. Voorbeelden zijn query's met ruimtelijke grenzen of metagegevensquery's.

Query's uitvoeren op onderdelen

Als u een onderdeel van een specifiek type wilt zoeken, gebruikt u FindComponentOfType:

CutPlaneComponent cutplane = (CutPlaneComponent)entity.FindComponentOfType(ObjectType.CutPlaneComponent);

// or alternatively:
CutPlaneComponent cutplane = entity.FindComponentOfType<CutPlaneComponent>();
ApiHandle<CutPlaneComponent> cutplane = entity->FindComponentOfType(ObjectType::CutPlaneComponent)->as<CutPlaneComponent>();

// or alternatively:
ApiHandle<CutPlaneComponent> cutplane = entity->FindComponentOfType<CutPlaneComponent>();

Transformaties opvragen

Transformatiequery's zijn synchrone aanroepen van het object. Het is belangrijk te weten dat transformaties die via de API worden opgevraagd, lokale ruimtetransformaties zijn ten opzichte van het bovenliggende object. Uitzonderingen zijn hoofdobjecten, waarvoor lokale ruimte en wereldruimte identiek zijn.

Notitie

Er is geen toegewezen API om query's uit te voeren op de wereldruimtetransformatie van willekeurige objecten.

// local space transform of the entity
Double3 translation = entity.Position;
Quaternion rotation = entity.Rotation;
// local space transform of the entity
Double3 translation = entity->GetPosition();
Quaternion rotation = entity->GetRotation();

Query's uitvoeren op ruimtelijke grenzen

Afhankelijke query's zijn asynchrone aanroepen die worden uitgevoerd op een volledige objecthiërarchie, waarbij één entiteit als hoofdobject wordt gebruikt. Zie het toegewezen hoofdstuk over objectgrenzen.

Query's uitvoeren op metagegevens

Metagegevens zijn aanvullende gegevens die zijn opgeslagen op objecten, die door de server worden genegeerd. Objectmetagegevens zijn in wezen een set paren (naam, waarde), waarbij de waarde van numeriek, booleaans of tekenreekstype kan zijn. Metagegevens kunnen worden geëxporteerd met het model.

Metagegevensquery's zijn asynchrone aanroepen voor een specifieke entiteit. De query retourneert alleen de metagegevens van één entiteit, niet de samengevoegde gegevens van een subgrafiek.

Task<ObjectMetadata> metaDataQuery = entity.QueryMetadataAsync();
ObjectMetadata metaData = await metaDataQuery;
ObjectMetadataEntry entry = metaData.GetMetadataByName("MyInt64Value");
System.Int64 intValue = entry.AsInt64;
// ...
entity->QueryMetadataAsync([](Status status, ApiHandle<ObjectMetadata> metaData) 
{
    if (status == Status::OK)
    {
        ApiHandle<ObjectMetadataEntry> entry = *metaData->GetMetadataByName("MyInt64Value");
        int64_t intValue = *entry->GetAsInt64();

        // ...
    }
});

De query slaagt zelfs als het object geen metagegevens bevat.

API-documentatie

Volgende stappen