Modellen

  • Artikel

Een model in Azure Remote Rendering verwijst naar een volledige objectweergave, samengesteld uit entiteiten en onderdelen. Modellen zijn de belangrijkste manier om aangepaste gegevens op te halen in de remote rendering-service.

Modelstructuur

Een model heeft precies één entiteit als hoofdknooppunt. Daaronder kan het een willekeurige hiërarchie van onderliggende entiteiten hebben. Bij het laden van een model wordt een verwijzing naar deze hoofdentiteit geretourneerd.

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

Modellen maken

Het maken van modellen voor runtime wordt bereikt door invoermodellen te converteren vanuit bestandsindelingen zoals FBX, GLTF of E57. Het conversieproces extraheert alle resources, zoals patronen, materialen en meshes, en converteert ze naar geoptimaliseerde runtime-indelingen. Ook worden de structurele gegevens geëxtraheerd en geconverteerd naar de structuur van de entiteit/componentgrafiek van ARR.

Belangrijk

Modelconversie is de enige manier om meshes te maken. Hoewel meshes tijdens runtime tussen entiteiten kunnen worden gedeeld, is er geen andere manier om een mesh in de runtime te krijgen, behalve het laden van een model.

Modellen laden

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

Er zijn twee verschillende laadfuncties die verschillen op de manier waarop de asset wordt behandeld in blobopslag:

  • Het model kan rechtstreeks worden verholpen door blobopslagparameters, voor het geval de blobopslag is gekoppeld aan het account. De relevante laadfunctie in dit geval is LoadModelAsync met de parameter LoadModelOptions.
  • Het model kan worden geadresseerd door de SAS-URI. De relevante laadfunctie is LoadModelFromSasAsync met parameter LoadModelFromSasOptions. Gebruik deze variant ook bij het laden van ingebouwde modellen.

In de volgende codefragmenten ziet u hoe u modellen laadt met een van beide functies. Als u een model wilt laden met behulp van de blob-opslagparameters, gebruikt u code zoals hieronder:

async void LoadModel(RenderingSession session, Entity modelParent, string storageAccount, string containerName, string assetFilePath)
{
    // load a model that will be parented to modelParent
    var modelOptions = LoadModelOptions.CreateForBlobStorage(
        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 codefragment:

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 entiteitshiërarchie doorlopen en de entiteiten en onderdelen wijzigen. Als u hetzelfde model meerdere keren laadt, worden er meerdere exemplaren gemaakt, elk met een eigen kopie van de entiteits-/onderdeelstructuur. Omdat meshes, materialen en patronen gedeelde resources zijn, worden hun gegevens echter niet opnieuw geladen. Het instantiëren van een model leidt daarom meer dan één keer tot relatief weinig geheugenoverhead.

API-documentatie

Volgende stappen