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

Extraer activos de X a través de C#

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

Cómo extraer activos de un archivo X usando C#

Para extraer activos del archivo X, 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 X a través de C#

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

  • Cargue el archivo X 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# código para extraer activos de X


//Archivos de origen que necesitan extraer activos
string file = "template.x";
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 X

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

      No es necesario descargar ni configurar nada
      No es necesario escribir o compilar código
      Simplemente cargue el archivo X y presione el botón "Extraer"
      Descargue el archivo X desde el enlace, si es necesario

    X Qué es X Formato de archivo

    X es un archivo de imagen de modelo de DirectX utilizado por la tecnología DirectX que sirve para 3D renderizar gráficos en juegos. El formato de archivo especifica 3D estructuras de objetos para mallas, texturas, animaciones y objetos.

    Leer más

    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)
    3DS (3D Formato de archivo de malla de Studio)
    USD (Descripción de la escena universal)
    USDZ (Universal Escena Descripción Zip Archivo)