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

GLTF से C# के माध्यम से संपत्तियां निकालें

सर्वर-साइड API का उपयोग करके GLTF फ़ाइलों से एसेट निकालने के लिए अपने स्वयं के .NET ऐप्स बनाएं।

GLTF फ़ाइल का उपयोग करके C# से एसेट कैसे निकालें

GLTF फ़ाइल से एसेट निकालने के लिए, हम उपयोग करेंगे

Aspose.3D for .NET

API जो एक सुविधा संपन्न, शक्तिशाली और उपयोग में आसान API है जो C# प्लेटफॉर्म के लिए एक्सट्रैक्ट एसेट के साथ उपयोग किया जाता है। खुला हुआ

नुगेट

पैकेज मैनेजर, खोजें


और स्थापित करें। आप पैकेज मैनेजर कंसोल से निम्न कमांड का भी उपयोग कर सकते हैं।

पैकेज मैनेजर कंसोल कमांड


PM> Install-Package Aspose.3D

GLTF से C# के माध्यम से संपत्ति निकालने के चरण

Aspose.3D केवल कोड की कुछ पंक्तियों के साथ GLTF फ़ाइल से एसेट निकालना डेवलपर के लिए आसान बनाता है.

  • सीन क्लास के कंस्ट्रक्टर के माध्यम से लोड करें GLTF फ़ाइल- आउटपुट फ़ाइल स्वरूप के रूप में ज़िप फ़ाइल स्वरूप वस्तु बनाएँ- आर्काइव क्लास बनाएं और एक्सट्रैक्ट एसेट क्लास को हैंडल करें- एक्सट्रैक्ट मेथड को कॉल करें और फाइल को सेव करें

सिस्टम आवश्यकताएं

Aspose.3D for .NET सभी प्रमुख ऑपरेटिंग सिस्टम पर समर्थित है। बस सुनिश्चित करें कि आपके पास निम्नलिखित पूर्वापेक्षाएँ हैं।

  • Microsoft Windows या .NET Framework, .NET Core, Mono के साथ संगत OS- माइक्रोसॉफ्ट विजुअल स्टूडियो जैसे विकास का माहौल- Aspose.3D for .NET आपके प्रोजेक्ट में संदर्भित
 

C# कोड GLTF से संपत्ति निकालने के लिए


//स्रोत फ़ाइलें जिन्हें संपत्ति निकालने की आवश्यकता होती है
string file = "template.gltf";
Scene scene = new Scene(file);  

//आउटपुट एक संपीड़ित फ़ाइल स्वरूप में है, और निर्देशिका मौजूदा फ़ोल्डर के नाम का प्रतिनिधित्व करती है
var zipOutput = Path.Combine("Directory", "OutputFile.zip");
using var output = new FileStream(zipOutput, FileMode.Create);
using var za = new Zip(output);

//एसेट एक्सट्रैक्शन ऑपरेशन करने के लिए एक्सट्रैक्ट मेथड को कॉल करें
Extract(scene,za,true);

//कॉल करने योग्य निकालने की विधि,पैरामीटर बनावट इंगित करती है: क्या बनावट को निकालना है
private void Extract(Scene scene, Zip za,bool texture)
{
    var extractor = new Extractor(za,texture);
    extractor.Extract(scene);
}

//एक संपीड़ित फ़ाइल प्रसंस्करण वर्ग बनाएँ
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;
        }
    }
}

//एसेट एक्सट्रैक्शन प्रोसेसिंग क्लास बनाएं
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);
    }
}
 
  • लगभग Aspose.3D for .NET API

    Aspose.3D एक CAD और गेमवेयर API है जो 3D फाइलों को लोड, संशोधित और परिवर्तित करता है। API एक स्टैंडअलोन है और इसके लिए किसी भी 3D मॉडलिंग या रेंडरिंग सॉफ़्टवेयर की आवश्यकता नहीं है। Discreet3DS, WavefrontOBJ, STL (ASCII, बाइनरी), Universal3D, FBX (ASCII, बाइनरी), Collada, glTF, PLY, के लिए कोई आसानी से API का उपयोग कर सकता है। GLB, DirectX और अधिक प्रारूप।

    GLTF से संपत्ति निकालने के लिए निःशुल्क ऐप

    हमारे लाइव डेमो की जांच करें निकालने वाला GLTF निम्नलिखित लाभों के साथ।

      कुछ भी डाउनलोड या सेटअप करने की आवश्यकता नहीं है
      कोड लिखने या संकलित करने की आवश्यकता नहीं है
      बस GLTF फ़ाइल अपलोड करें और "निकालें" बटन दबाएं
      यदि आवश्यक हो, तो लिंक से GLTF फ़ाइल डाउनलोड करें

    GLTF क्या है GLTF फ़ाइल प्रारूप

    glTF (जीएल ट्रांसमिशन प्रारूप) एक 3D फ़ाइल स्वरूप है जो JSON प्रारूप में 3D मॉडल जानकारी संग्रहीत करता है। JSON का उपयोग 3D संपत्तियों के आकार और उन संपत्तियों को अनपैक करने और उपयोग करने के लिए आवश्यक रनटाइम प्रोसेसिंग दोनों को कम करता है। इसे अनुप्रयोगों द्वारा 3D दृश्यों और मॉडलों के कुशल संचरण और लोडिंग के लिए अपनाया गया था।

    पढ़ने अधिक

    प्रारूपों से संपत्ति निकालने के लिए अन्य समर्थित ऐप

    C# का उपयोग करके, कोई भी व्यक्ति सहित कई अन्य फ़ाइल स्वरूपों से संपत्तियां निकाल सकता है।

    3MF (3D निर्माण प्रारूप)
    AMF (योजक विनिर्माण प्रारूप)
    ASE (2डी एनिमेशन फाइल)
    DAE (डिजिटल एसेट एक्सचेंज)
    DXF (ड्राइंग इंटरचेंज प्रारूप)
    DRC (Google Draco)
    FBX (3D प्रारूप)
    GLB (3D फ़ाइल बाइनरी प्रतिनिधित्व)
    3DS (3D स्टूडियो मेश फ़ाइल स्वरूप)
    JT (बृहस्पति टेसेलेशन फ़ाइल)
    OBJ (3D फ़ाइल स्वरूप)
    PLY (बहुभुज फ़ाइल स्वरूप)
    PDF (3D PDF)
    RVM (अवेवा प्लांट डिजाइन मॉडल)
    STL (विनिमेय 3D भूतल ज्यामिति)
    U3D (Universal 3D)
    VRML (आभासी वास्तविकता मॉडलिंग भाषा)
    एक्स (DirectX मॉडल छवि)
    USD (यूनिवर्सल सीन विवरण)
    USDZ (यूनिवर्सल सीन विवरण जिप आर्काइव)