Modeller

  • Artikel
  • 3 minuter för att läsa

En modell i Azure Remote rendering refererar till en fullständig objekt representation, som består av entiteter och komponenter. Modeller är det huvudsakliga sättet att hämta anpassade data till tjänsten Remote rendering.

Modellstruktur

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

Varje entitet kan ha komponenter kopplade. I det vanligaste fallet har entiteterna MeshComponents, som refererar till nät resurserna.

Skapa modeller

Att skapa modeller för körning uppnås genom att konvertera inmatade modeller från fil format som FBX och GLTF. Konverterings processen extraherar alla resurser, till exempel texturer, material och maskor, och konverterar dem till optimerade körnings format. Den kommer också att extrahera struktur information och omvandla den till ARR: s entitet/komponent diagram struktur.

Viktigt

Modell konvertering är det enda sättet att skapa nät. Även om maskor kan delas mellan entiteter vid körning, finns det inte något annat sätt att få ett nät i körningen, förutom att läsa in en modell.

Läser in modeller

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

Det finns två distinkta inläsnings funktioner som skiljer sig åt av sättet till gången i Blob Storage:

  • Modellen kan åtgärdas av Blob Storage-parametrar direkt, om Blob Storage är länkat till kontot. Relevant inläsnings funktion i det här fallet är LoadModelAsync med-parameter LoadModelOptions .
  • Modellen kan åtgärdas med hjälp av SAS-URI: n. Relevant inläsnings funktion är LoadModelFromSasAsync med-parameter LoadModelFromSasOptions . Använd även den här varianten vid inläsning av 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 Blob Storage-parametrar 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 = 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);
        }
    );
}

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

Sedan kan du bläddra i organisationshierarkin och ändra entiteter och komponenter. Att läsa in samma modell flera gånger skapar flera instanser, var och en med en egen kopia av entiteten/komponent strukturen. Eftersom nät, material och texturer är delade resurserkommer deras data inte att läsas in igen, trots. Därför instansierar en modell mer än en gång, vilket innebär relativt lite minnes belastning.

API-dokumentation

Nästa steg