Modeller

  • Artikel

En modell i Azure Remote Rendering refererar till en fullständig objektrepresentation som består av entiteter och komponenter. Modeller är det huvudsakliga sättet att hämta anpassade data till fjärrrenderingstjänsten.

Modellstruktur

En modell har exakt en entitet som rotnod. Nedan kan den ha en godtycklig hierarki med underordnade entiteter. När du läser in en modell returneras en referens till den här rotentiteten.

Varje entitet kan ha komponenter kopplade. I det vanligaste fallet har entiteterna MeshComponents, som refererar till mesh-resurser.

Skapa modeller

Att skapa modeller för körning uppnås genom att konvertera indatamodeller från filformat som FBX, GLTF eller E57. Konverteringsprocessen extraherar alla resurser, till exempel texturer, material och nät, och konverterar dem till optimerade körningsformat. Den extraherar också den strukturella informationen och konverterar den till ARR:s entitets-/komponentgrafstruktur.

Viktigt!

Modellkonvertering är det enda sättet att skapa nät. Även om nät kan delas mellan entiteter vid körning finns det inget annat sätt att hämta ett nät i körningen, förutom att läsa in en modell.

Läsa in modeller

När en modell har konverterats kan den läsas in från Azure Blob Storage till körningen.

Det finns två distinkta inläsningsfunktioner som skiljer sig åt beroende på hur tillgången hanteras i Blob Storage:

  • Modellen kan hanteras av bloblagringsparametrar direkt, om bloblagringen är länkad till kontot. Relevant inläsningsfunktion i det här fallet är LoadModelAsync med parametern LoadModelOptions.
  • Modellen kan hanteras av dess SAS-URI. Relevant inläsningsfunktion är LoadModelFromSasAsync med parametern LoadModelFromSasOptions. Använd även den här varianten när du läser in inbyggda modeller.

Följande kodfragment visar hur du läser in modeller med någon av funktionerna. Om du vill läsa in en modell med dess bloblagringsparametrar använder du kod som den nedan:

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);
        }
    );
}

Om du vill läsa in en modell med hjälp av en SAS-token använder du kod som liknar följande kodfragment:

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);
        }
    );
}

Därefter kan du gå igenom entitetshierarkin och ändra entiteterna och komponenterna. Om samma modell läses in flera gånger skapas flera instanser, var och en med en egen kopia av entiteten/komponentstrukturen. Eftersom nät, material och texturer är delade resurser läses deras data dock inte in igen. Därför medför instansiering av en modell mer än en gång relativt lite minnesomkostnader.

API-dokumentation

Nästa steg