HTML JPG PDF XML U3D
Aspose.3D  for .NET
U3D

Extraia ativos de U3D via C#

Crie seus próprios aplicativos .NET para extrair ativos de arquivos U3D usando APIs do lado do servidor.

Como extrair ativos do arquivo U3D usando C#

Para extrair recursos do arquivo U3D, usaremos

Aspose.3D for .NET

API que é uma plataforma rica em recursos, poderosa e fácil de usar API para C# a ser usada com recursos de extração. Aberto

NuGetName

gerenciador de pacotes, procure Aspose.3D e instalar. Você também pode usar o seguinte comando do Console do Gerenciador de Pacotes.

Comando do console do gerenciador de pacotes


PM> Install-Package Aspose.3D

Etapas para extrair ativos de U3D via C#

Aspose.3D facilita para os desenvolvedores extrair recursos do arquivo U3D com apenas algumas linhas de código.

  • Carregar arquivo U3D por meio do construtor da classe Scene- Criar objeto de formato de arquivo zip como formato de arquivo de saída- Criar classe de arquivo e lidar com classe de recurso de extração- Chame o método Extract e salve o arquivo

Requisitos de sistema

Aspose.3D for .NET é compatível com todos os principais sistemas operacionais. Apenas certifique-se de ter os seguintes pré-requisitos.

  • Microsoft Windows ou um sistema operacional compatível com .NET Framework, .NET Core, Mono- Ambiente de desenvolvimento como o Microsoft Visual Studio- Aspose.3D for .NET referenciado em seu projeto
 

C# código para extrair ativos de U3D


//Arquivos de origem que precisam extrair ativos
string file = "template.u3d";
Scene scene = new Scene(file);  

//A saída está em um formato de arquivo compactado e o Diretório representa o nome de uma pasta existente
var zipOutput = Path.Combine("Directory", "OutputFile.zip");
using var output = new FileStream(zipOutput, FileMode.Create);
using var za = new Zip(output);

//Chame o método Extract para realizar operações de extração de ativos
Extract(scene,za,true);

//Callable Extract method, O parâmetro texture indica: se deve extrair a textura
private void Extract(Scene scene, Zip za,bool texture)
{
    var extractor = new Extractor(za,texture);
    extractor.Extract(scene);
}

//Criar uma classe de processamento de arquivo compactado
class Zip : IDisposable
{
    private ZipArchive archive;
    private HashSet<string> entries = new HashSet<string>();

    public Zip(Stream stream)
    {
        archive = new ZipArchive(stream, ZipArchiveMode.Create);
    }
    public void Dispose()
    {
        archive.Dispose();
    }

    public void Add(string fileName, byte[] content, bool enableCompression)
    {
        var entryName = PickName(fileName);
        var compressionLevel = enableCompression ? CompressionLevel.Fastest : CompressionLevel.NoCompression;
        var entry = archive.CreateEntry(entryName, compressionLevel);
        using var stream = entry.Open();
        stream.Write(content, 0, content.Length);
    }
    
    private string PickName(string fileName)
    {
        if (!entries.Contains(fileName))
        {
            entries.Add(fileName);
            return fileName;
        }
        var baseName = Path.GetFileNameWithoutExtension(fileName);
        var ext = Path.GetExtension(fileName);
        for (var idx = 2; ; idx++)
        {
            var newName = baseName + "_" + idx;
            if (!string.IsNullOrEmpty(ext))
                newName += ext;
            if (entries.Contains(newName))
                continue;
            entries.Add(newName);
            return newName;
        }
    }
}

//Criar uma classe de processamento de extração de ativos
class Extractor
{
    private Zip zip;
    private bool texture;
    HashSet<A3DObject> visited = new HashSet<A3DObject>();
    public Extractor(Zip zip,bool texture)
    {
        this.zip = zip;
        this.texture = texture;
    }

    private bool CanVisit(A3DObject obj)
    {
        if (visited.Contains(obj))
            return false;
        visited.Add(obj);
        return true;
    }
    public void Extract(Scene scene)
    {
        if (scene.Library != null && scene.Library.Count > 0)
        {
            foreach (var obj in scene.Library)
            {
                Visit(obj);
            }
        }
        VisitNode(scene.RootNode);
    }
    private void VisitNode(Node node)
    {
        if (!CanVisit(node))
            return;
        if (texture)
        {
            foreach (var mat in node.Materials)
            {
                VisitMaterial(mat);
            }
        }

        foreach (var entity in node.Entities)
        {
            if (entity is Mesh)
                Save((Mesh)entity, node.Name);
        }
        
        foreach (var child in node.ChildNodes)
        {
            VisitNode(child);
        }
    }
    private void VisitMaterial(Material mat)
    {
        if (!CanVisit(mat))
            return;
        if (!texture)
            return;
        foreach (var tslot in mat)
        {
            if (tslot.Texture is Texture)
            {
                Save((Texture)tslot.Texture);
            }
        }
    }
    private void Visit(A3DObject obj)
    {
        if (texture && obj is Texture)
        {
            Save((Texture)obj);
        }
        else if (obj is Mesh)
        {
            Save((Mesh)obj, null);
        }
        else if (obj is Node)
        {
            VisitNode((Node)obj);
        }
    }
    private void Save(Mesh mesh, string? nodeName)
    {
        if (!CanVisit(mesh))
            return;
        Scene scene = new Scene(mesh);
        using (var ms = new MemoryStream())
        {
            scene.Save(ms, FileFormat.FBX7400ASCII);
            var name = nodeName;
            if (string.IsNullOrEmpty(name))
                name = mesh.Name;
            if (string.IsNullOrEmpty(name))
                name = "mesh";
            var ext = ".fbx";
            zip.Add(name + ext, ms.ToArray(), true);
        }
    }
    private void Save(Texture tex)
    {
        if (tex.Content == null || !CanVisit(tex))
            return;
        var fileName = tex.FileName != null ? Path.GetFileName(tex.FileName) : null;
        zip.Add(fileName, tex.Content, false);
    }
}
 
  • Sobre Aspose.3D for .NET API

    Aspose.3D é um CAD e Gameware API para carregar, modificar e converter arquivos 3D. API é independente e não requer nenhum software de modelagem ou renderização de 3D. Pode-se facilmente usar API para Discreet3DS, WavefrontOBJ, STL (ASCII, Binário), Universal3D, FBX (ASCII, Binário), Collada, glTF, PLY, GLB, DirectX e mais formatos.

    Aplicativo gratuito para extrair ativos de U3D

    Confira nossas demonstrações ao vivo para Extrator U3D com os seguintes benefícios.

      Não há necessidade de baixar ou configurar nada
      Não há necessidade de escrever ou compilar código
      Basta fazer o upload do arquivo U3D e clicar no botão "Extrair"
      Baixe o arquivo U3D do link, se necessário

    U3D O que é U3D Formato de Arquivo

    U3D (Universal 3D) é um formato de arquivo compactado e estrutura de dados para gráficos de computador 3D. Ele contém 3D informações do modelo, como malhas de triângulos, iluminação, sombreamento, dados de movimento, linhas e pontos com cor e estrutura. O formato foi aceito como padrão ECMA-363 em agosto de 2005. 3D PDF documentos suportam a incorporação de U3D objetos e podem ser visualizados no Adobe Reader (versão 7 em diante).

    Leia mais

    Outro aplicativo compatível para extrair ativos de formatos

    Usando C#, também é possível extrair ativos de muitos outros formatos de arquivo, incluindo.

    3MF (3D Formato de fabricação)
    AMF (Formato de Manufatura Aditiva)
    ASE (Arquivo de animação 2D)
    DAE (Troca de ativos digitais)
    DXF (Formato de intercâmbio de desenho)
    DRC (Google Draco)
    FBX (3D Formato)
    GLB (3D Representação Binária de Arquivo)
    GLTF (Formato de transmissão GL)
    JT (Arquivo de Tesselação de Júpiter)
    OBJ (3D Formato de arquivo)
    PLY (Formato de arquivo de polígono)
    PDF (3D PDF)
    RVM (Modelo de Projeto de Planta AVEVA)
    STL (Geometria de superfície 3D intercambiável)
    3DS (3D Formato de arquivo de malha do Studio)
    VRML (Linguagem de modelagem de realidade virtual)
    X (Imagem do modelo DirectX)
    USD (Descrição da cena universal)
    USDZ (Arquivo Zip de Descrição de Cena Universal)