Partilhar via

Modelos

  • Artigo

Um modelo na Renderização Remota do Azure refere-se a uma representação completa de objeto, composta por entidades e componentes. Os modelos são a principal maneira de obter dados personalizados no serviço de renderização remota.

Estrutura do modelo

Um modelo tem exatamente uma entidade como seu nó raiz. Abaixo disso, pode ter uma hierarquia arbitrária de entidades filhas. Ao carregar um modelo, uma referência a essa entidade raiz é retornada.

Cada entidade pode ter componentes associados. No caso mais comum, as entidades têm MeshComponents, que fazem referência a recursos de malha.

Criação de modelos

A criação de modelos para tempo de execução é obtida através da conversão de modelos de entrada de formatos de arquivo como FBX, GLTF ou E57. O processo de conversão extrai todos os recursos, como texturas, materiais e malhas, e os converte em formatos de tempo de execução otimizados. Também extrairá a informação estrutural e convertê-la-á na estrutura gráfica da entidade/componente do ARR.

Importante

A conversão de modelos é a única maneira de criar malhas. Embora as malhas possam ser compartilhadas entre entidades em tempo de execução, não há outra maneira de obter uma malha no tempo de execução, além de carregar um modelo.

Carregando modelos

Depois que um modelo é convertido, ele pode ser carregado do armazenamento de blob do Azure para o tempo de execução.

Há duas funções de carregamento distintas que diferem pela maneira como o ativo é abordado no armazenamento de blob:

  • O modelo pode ser abordado por parâmetros de armazenamento de blob diretamente, caso o armazenamento de blob esteja vinculado à conta. Função de carregamento relevante neste caso é LoadModelAsync com parâmetro LoadModelOptions.
  • O modelo pode ser abordado pelo seu URI SAS. Função de carregamento relevante é LoadModelFromSasAsync com parâmetro LoadModelFromSasOptions. Use esta variante também ao carregar modelos integrados.

Os trechos de código a seguir mostram como carregar modelos com qualquer uma das funções. Para carregar um modelo usando seus parâmetros de armazenamento de blob, use um código como o abaixo:

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

Se você quiser carregar um modelo usando um token SAS, use um código semelhante ao seguinte trecho:

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

Depois, você pode percorrer a hierarquia de entidades e modificar as entidades e componentes. Carregar o mesmo modelo várias vezes cria várias instâncias, cada uma com sua própria cópia da estrutura da entidade/componente. Como malhas, materiais e texturas são recursos compartilhados, seus dados não serão carregados novamente. Portanto, instanciar um modelo mais de uma vez incorre em relativamente pouca sobrecarga de memória.

Documentação da API

Próximos passos