Modellen

  • Artikel
  • 3 minuten om te lezen

Een model in azure rendering op afstand verwijst naar een volledige object weergave, samengesteld uit entiteiten en onderdelen. Modellen vormen de belangrijkste manier om aangepaste gegevens op te halen in de externe rendering-service.

Modelstructuur

Een model heeft precies één entiteit als het hoofd knooppunt. Hieronder ziet u mogelijk een wille keurige hiërarchie van onderliggende entiteiten. Bij het laden van een model wordt een verwijzing naar deze hoofd entiteit geretourneerd.

Aan elke entiteit kunnen onderdelen zijn gekoppeld. In het meest voorkomende geval hebben de entiteiten MeshComponents, die verwijzen naar netresources.

Modellen maken

Het maken van modellen voor runtime wordt bereikt door het converteren van invoer modellen van bestands indelingen, zoals FBX en GLTF. Het conversie proces extraheert alle resources, zoals bitmappatronen, materialen en netten, en converteert deze naar geoptimaliseerde runtime-indelingen. Ook wordt de structuur informatie geëxtraheerd en wordt deze geconverteerd naar de grafiek structuur van de entiteit/het onderdeel van ARR.

Belangrijk

Model conversie is de enige manier om nettente maken. Hoewel netten kunnen worden gedeeld tussen entiteiten tijdens runtime, is er geen andere manier om een net in de runtime op te halen, met uitzonde ring van het laden van een model.

Modellen laden

Zodra een model is geconverteerd, kan het worden geladen vanuit Azure Blob-opslag in de runtime.

Er zijn twee verschillende laad functies die verschillen van de manier waarop de Asset wordt opgelost in Blob Storage:

  • Het model kan rechtstreeks worden aangepakt door de Blob Storage-para meters, als de Blob-opslag aan het account is gekoppeld. Relevante laad functie in dit geval is een LoadModelAsync para meter LoadModelOptions .
  • Het model kan worden aangepakt door de SAS-URI. Relevante laad functie is LoadModelFromSasAsync met para meter LoadModelFromSasOptions . Gebruik deze variant ook bij het laden van ingebouwde modellen.

De volgende code fragmenten laten zien hoe u modellen met beide functies kunt laden. Als u een model wilt laden met behulp van de Blob Storage-para meters, gebruikt u de code zoals hieronder wordt beschreven:

async void LoadModel(RenderingSession session, Entity modelParent, string storageAccount, string containerName, string assetFilePath)
{
    // load a model that will be parented to modelParent
    var modelOptions = new LoadModelOptions(
        storageAccount, // storage account name + '.blob.core.windows.net', e.g., 'mystorageaccount.blob.core.windows.net'
        containerName,  // name of the container in your storage account, e.g., 'mytestcontainer'
        assetFilePath,  // the file path to the asset within the container, e.g., 'path/to/file/myAsset.arrAsset'
        modelParent
    );

    var loadOp = session.Connection.LoadModelAsync(modelOptions, (float progress) =>
    {
        Debug.WriteLine($"Loading: {progress * 100.0f}%");
    });

    await loadOp;
}

void LoadModel(ApiHandle<RenderingSession> session, ApiHandle<Entity> modelParent, std::string storageAccount, std::string containerName, std::string assetFilePath)
{
    LoadModelOptions modelOptions;
    modelOptions.Parent = modelParent;
    modelOptions.Blob.StorageAccountName = std::move(storageAccount);
    modelOptions.Blob.BlobContainerName = std::move(containerName);
    modelOptions.Blob.AssetPath = std::move(assetFilePath);

    ApiHandle<LoadModelResult> result;
    session->Connection()->LoadModelAsync(modelOptions,
        // completion callback
        [](Status status, ApiHandle<LoadModelResult> result)
        {
            printf("Loading: finished.");
        },
        // progress callback
        [](float progress)
        {
            printf("Loading: %.1f%%", progress * 100.f);
        }
    );
}

Als u een model wilt laden met behulp van een SAS-token, gebruikt u code die vergelijkbaar is met het volgende fragment:

async void LoadModel(RenderingSession session, Entity modelParent, string modelUri)
{
    // load a model that will be parented to modelParent
    var modelOptions = new LoadModelFromSasOptions(modelUri, modelParent);

    var loadOp = session.Connection.LoadModelFromSasAsync(modelOptions, (float progress) =>
    {
        Debug.WriteLine($"Loading: {progress * 100.0f}%");
    });

    await loadOp;
}

void LoadModel(ApiHandle<RenderingSession> session, ApiHandle<Entity> modelParent, std::string modelUri)
{
    LoadModelFromSasOptions modelOptions;
    modelOptions.ModelUri = modelUri;
    modelOptions.Parent = modelParent;

    ApiHandle<LoadModelResult> result;
    session->Connection()->LoadModelFromSasAsync(modelOptions,
        // completion callback
        [](Status status, ApiHandle<LoadModelResult> result)
        {
            printf("Loading: finished.");
        },
        // progress callback
        [](float progress)
        {
            printf("Loading: %.1f%%", progress * 100.f);
        }
    );
}

Daarna kunt u de entiteits hiërarchie door lopen en de entiteiten en onderdelen wijzigen. Als hetzelfde model meerdere keren wordt geladen, worden meerdere exemplaren gemaakt, elk met een eigen kopie van de entiteit/onderdeel structuur. Omdat mazen, materialen en bitmappatronen gedeelde resourceszijn, worden hun gegevens niet opnieuw geladen. Daarom kan een model meer dan één keer worden gemodelleerd met relatief weinig geheugen overhead.

API-documentatie

Volgende stappen