Blader door onze producten

Aspose.3D für Python über .NET 23.12 Versionshinweise

Verbesserungen und Änderungen

KeySummaryCategory
THREEDNET-1458Optimierung des Meshes ermöglichen, um duplizierte Kontrollpunkte zu entfernen.New Feature
THREEDNET-1468Spezifizierung des Achsensystems beim Exportieren von Modellen in STL/OBJ/PLY ermöglichenNew Feature
THREEDNET-222Unterstützung komplexer Boolescher Operationen auf Meshes hinzufügenNew Feature
THREEDNET-1441Boolesche Operation kann auf ordinale Meshes angewendet werdenImprovement
THREEDNET-1451OBJ-Export – falsche Texturen.Bug fixing
THREEDNET-1452Kann GPU-Gerätespeicher für Texturen mit einer Größe von 8192 * 8192 nicht zuweisenBug fixing
THREEDNET-1453GLTF-Export – falsche Texturen.Bug fixing
THREEDNET-1454FBX-Export – falsche Gruppierung von Modellen wird exportiertBug fixing
THREEDNET-1461Bindepunkte auf verschiedenen Objekten geben den gleichen Wert zurück, wenn die Eigenschaftsnamen gleich sind.Bug fixing
THREEDNET-1462Aspose.3D generiert inkompatible AnimationsdatenBug fixing

API-Änderungen

Hinzugefügte Klasse aspose.threed.AxisSystem

Bestimmte Dateiformate wie OBJ, STL und PLY ermöglichen es Ihnen, das Koordinatensystem, den Aufwärtsvektor und den Vorwärtsvektor während des Exportprozesses zu definieren. Sie können diese Klasse verwenden, um diese Informationen bereitzustellen und zu konfigurieren.

Umbenannte Klasse aspose.threed.CoordinatedSystem in aspose.threed.CoordinateSystem

Hinzugefügte Mitglieder zur Klasse aspose.threed.Animation.AnimationNode:

        def find_bind_point(self, target : "A3DObject", name : str) -> "BindPoint":
                """
                Findet den Bindepunkt nach Ziel und Name.

                :param target: Ziel des zu findenden Bindepunkts.
                :param name: Name des zu findenden Bindepunkts.
                :return: Der Bindepunkt.
                """

Die aktualisierten Overloads ermöglichen es Ihnen jetzt, sowohl das Ziel als auch den Namen anzugeben, während die vorherige Implementierung nur eine Suche basierend auf dem angegebenen Namen durchführte.

Hinzugefügte Mitglieder zur Klasse aspose.threed.AssetInfo:

    @property
    def front_vector(self) -> Optional[Axis]:
        """
        Ruft den im Asset verwendeten Vorwärtsvektor ab.
        """
    
    @front_vector.setter
    def front_vector(self, value: Optional[Axis]) -> None:
        """
        Setzt den im Asset verwendeten Vorwärtsvektor.
        """

    @property
    def axis_system(self) -> AxisSystem:
        """
        Ruft das Koordinatensystem/den Aufwärtsvektor/den Vorwärtsvektor der Asset-Informationen ab.
        """
    
    @axis_system.setter
    def axis_system(self, value: AxisSystem) -> None:
        """
        Setzt das Koordinatensystem/den Aufwärtsvektor/den Vorwärtsvektor der Asset-Informationen.
        """

Einige Formate wie FBX können einen benutzerdefinierten Vorwärtsvektor innerhalb der FBX-Datei definieren.

Hinzugefügte Mitglieder zur Klasse aspose.threed.Axis:

        # Die -X-Achse.
        NEGATIVE_X_AXIS

        # Die -Y-Achse.
        NEGATIVE_Y_AXIS

        # Die -Z-Achse.
        NEGATIVE_Z_AXIS

Die zusätzlichen Enum-Werte bieten jetzt eine präzisere Spezifikation der Richtung für die Achsen beim Konstruieren eines Achsensystems.

Hinzugefügte Klasse aspose.threed.deformers.BoneLinkMode

Hinzugefügte Mitglieder zur Klasse aspose.threed.deformers.Bone:

    @property
    def link_mode(self) -> "BoneLinkMode":
        """
        Der Link-Modus eines Knochens bezieht sich auf die Art und Weise, wie ein Knochen mit seinem Elternknochen innerhalb einer hierarchischen Struktur verbunden oder verknüpft ist.
        """
    
    @link_mode.setter
    def link_mode(self, value: "BoneLinkMode") -> None:
        """
        Setter-Methode für den Link-Modus des Knochens.
        """

Das LinkMode-Feature bietet FBX-kompatible Link-Modi für Knochen im Kontext der Anwendung.

Beispielcode

        from aspose.threed.deformers import Bone

        boneToLimbNode1 = Bone("")
        boneToLimbNode1.node = limbNode1
        boneToLimbNode1.link_mode = BoneLinkMode.TOTAL_ONE

Hinzugefügte Mitglieder zur Klasse aspose.threed.Transform:

    @property
    def scaling(self) -> Vector3:
        """
        Ruft die Skalierung ab oder setzt sie.
        """

    @scaling.setter
    def scaling(self, value: Vector3) -> None:
        """
        Setzt die Skalierung.
        """

    @property
    def scaling_offset(self) -> Vector3:
        """
        Ruft den Skalierungsoffset ab oder setzt ihn.
        """

    @scaling_offset.setter
    def scaling_offset(self, value: Vector3) -> None:
        """
        Setzt den Skalierungsoffset.
        """

    @property
    def scaling_pivot(self) -> Vector3:
        """
        Ruft den Skalierungspunkt ab oder setzt ihn.
        """

    @scaling_pivot.setter
    def scaling_pivot(self, value: Vector3) -> None:
        """
        Setzt den Skalierungspunkt.
        """

    @property
    def rotation_offset(self) -> Vector3:
        """
        Ruft den Drehungsoffset ab oder setzt ihn.
        """

    @rotation_offset.setter
    def rotation_offset(self, value: Vector3) -> None:
        """
        Setzt den Drehungsoffset.
        """

    @property
    def rotation_pivot(self) -> Vector3:
        """
        Ruft den Drehungspunkt ab oder setzt ihn.
        """

    @rotation_pivot.setter
    def rotation_pivot(self, value: Vector3) -> None:
        """
        Setzt den Drehungspunkt.
        """

Die Eigenschaften scaling_offset, scaling_pivot, rotation_offset und rotation_pivot ermöglichen eine präzisere Definition von Drehung und Skalierung und gewährleisten die Kompatibilität mit Maya/3ds Max-Standards.

 
 Deutsch