HTML JPG PDF XML USDZ

USDZ

Extraer activos de USDZ a través de C#

Cree sus propias aplicaciones .NET para extraer recursos de archivos USDZ mediante las API del lado del servidor.

Cómo extraer activos del archivo USDZ usando C#

Para extraer activos del archivo USDZ, usaremos

Aspose.3D for .NET

API, que es una plataforma API para C# rica en funciones, potente y fácil de usar para usar con recursos de extracción. Abierto

NuGet

administrador de paquetes, busque Aspose.3D e instalar También puede usar el siguiente comando desde la Consola del administrador de paquetes.

Comando de la consola del Administrador de paquetes
PM> Install-Package Aspose.3D

Pasos para extraer activos de USDZ a través de C#

Aspose.3D facilita a los desarrolladores la extracción de activos del archivo USDZ con solo unas pocas líneas de código.

Cargue el archivo USDZ a través del constructor de la clase Escena- Crear objeto de formato de archivo zip como formato de archivo de salida- Crear clase de archivo y manejar la clase de activo de extracción- Llame al método Extract y guarde el archivo

Requisitos del sistema

Aspose.3D for .NET es compatible con todos los principales sistemas operativos. Solo asegúrese de tener los siguientes requisitos previos.

Microsoft Windows o un sistema operativo compatible con .NET Framework, .NET Core, Mono- Entorno de desarrollo como Microsoft Visual Studio- Aspose.3D for .NET referenciado en su proyecto

Código C# para extraer recursos de USDZ
//Archivos de origen que necesitan extraer activos
string file = "template.usdz";
Scene scene = new Scene(file);  

//La salida está en un formato de archivo comprimido y Directorio representa el nombre de una carpeta existente
var zipOutput = Path.Combine("Directory", "OutputFile.zip");
using var output = new FileStream(zipOutput, FileMode.Create);
using var za = new Zip(output);

//Llame al método Extract para realizar operaciones de extracción de activos
Extract(scene,za,true);

//Método de extracción invocable, la textura del parámetro indica: si se extrae la textura
private void Extract(Scene scene, Zip za,bool texture)
{
    var extractor = new Extractor(za,texture);
    extractor.Extract(scene);
}

//Crear una clase de procesamiento de archivos comprimidos
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;
        }
    }
}

//Crear una clase de procesamiento de extracción de activos
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);
    }
}

Acerca de Aspose.3D for .NET API

Aspose.3D es un CAD y Gameware API para cargar, modificar y convertir archivos 3D. API es independiente y no requiere ningún 3D software de modelado o renderizado. Uno puede usar fácilmente API para Discreet3DS, WavefrontOBJ, STL (ASCII, binario), Universal3D, FBX (ASCII, binario), Collada, glTF, PLY, GLB, DirectX y más formatos.

Aplicación gratuita para extraer activos de USDZ

Consulte nuestras demostraciones en vivo para Extractor USDZ con los siguientes beneficios.

No es necesario descargar ni configurar nada

No es necesario escribir o compilar código

Simplemente cargue el archivo USDZ y presione el botón "Extraer"

Descargue el archivo USDZ desde el enlace, si es necesario

USDZ Qué es USDZ Formato de archivo

Un archivo con .usdz es un archivo ZIP para el formato de archivo USD (Descripción de escena universal) que contiene y representa archivos de otros formatos incrustados en el archivo.

Otra aplicación compatible para extraer activos de formatos

Con C#, también se pueden extraer activos de muchos otros formatos de archivo, incluidos.

3MF (3D formato de fabricación)

AMF (Formato de fabricación aditiva)

ASE (Archivo de animación 2D)

DAE (Intercambio de activos digitales)

DXF (Formato de intercambio de dibujos)

DRC (Google Draco)

FBX (3D Formato)

GLB (3D Representación binaria de archivos)

GLTF (Formato de transmisión GL)

JT (Archivo de teselado de Júpiter)

OBJ (3D formato de archivo)

PLY (Formato de archivo de polígono)

PDF (3D PDF)

RVM (Modelo de diseño de planta de AVEVA)

STL (Geometría de superficie intercambiable 3D)

U3D (Universal 3D)

VRML (Lenguaje de modelado de realidad virtual)

X (Imagen del modelo de DirectX)

USD (Descripción de la escena universal)

3DS (3D Formato de archivo de malla de Studio)