Wie man ein 3D-Mesh mit Aspose.3D in Python erstellt

Schritt 1: Installieren des Pakets

Installieren Sie Aspose.3D FOSS von PyPI. Keine nativen Erweiterungen oder Compiler-Toolchain erforderlich.

asposefoss/3d is not yet published — build from source until it ships. See the project README for build instructions.

Die Installation überprüfen:

from aspose.threed import Scene
print("Aspose.3D FOSS ready")

Unterstützte Python-Versionen: 3.7, 3.8, 3.9, 3.10, 3.11, 3.12.

Schritt 2: Erstellen Sie eine Szene und einen Knoten

Jedes Netz muss in einem Szenengraph leben. Scene und fügen Sie einen benannten Node zur Aufbewahrung des Maschens:

from aspose.threed import Scene

scene = Scene()
node = scene.root_node.create_child_node("triangle")

Der Knotenname wird in der exportierten Datei erhalten und ist nützlich für das Debuggen und spätere Abrufen über: node.get_child("triangle").

Schritt 3: Erstellen eines Mesh-Objekts

Instanzieren Sie eine Mesh mit einer optional beschreibenden Bezeichnung:

from aspose.threed.entities import Mesh

mesh = Mesh("triangle")

Das Netz ist zunächst leer: keine Werte, keine Polygone. Sie füllen es in den folgenden Schritten aus.

Schritt 4: Steuerelemente (Werte) hinzufügen

Die Kontrollpunkte sind die Punktstellen. Jeder Punkt wird als eine Vector4(x, y, z, w) wo: w=1 zeigt einen Punkt im 3D-Raum an:

from aspose.threed.utilities import Vector4

##Vertex 0: origin
# Note: control_points returns a copy of the internal vertex list.
# Appending to the returned copy discards the vertex silently.
# Use _control_points to mutate the backing list directly.
# This is a known library limitation — a public add_control_point() API is not yet available.
mesh._control_points.append(Vector4(0.0, 0.0, 0.0, 1.0))

##Vertex 1: 1 unit along X
mesh._control_points.append(Vector4(1.0, 0.0, 0.0, 1.0))

##Vertex 2: apex
mesh._control_points.append(Vector4(0.5, 1.0, 0.0, 1.0))

print(f"Vertices added: {len(mesh.control_points)}")

Wichtig: Diemesh.control_points gibt a zurück. Kopie der Liste der internen Werte (der Getter führt die list(self._control_points)) Anrufen mesh.control_points.append(v) Die Veröffentlichung der ersten Version ist nicht auf die Kopie, sondern auf das Netz angebracht. mesh._control_points.append(v) Zugriff auf private Staat über _control_points ist eine bekannte Lösung; die Schnittstelle kann sich in einer zukünftigen Version der Bibliothek ändern.

Schritt 5: Erstellen von Polygonen

Definieren Sie die Oberflächentopologie mit Vertex-Indexen. Übergeben Sie Verx-Indizes an create_polygon().Drei Indizes bilden ein Dreieck , vier Quadrat .:

##Triangle: connect vertices 0 → 1 → 2
mesh.create_polygon(0, 1, 2)

print(f"Polygon count: {mesh.polygon_count}")

Für ein Quadmesch würden Sie vier Indizes geben: mesh.create_polygon(0, 1, 2, 3).

Die Indizes müssen gültige Positionen in den folgenden Punkten darstellen: control_points Die Wickelreihenfolge ist gegen den Uhrzeigersinn für nach außen gerichtete Normale.

Schritt 6: Hinzufügen von Vertex-Normalen

Die normalen Höhen werden als ein VertexElement Anschluss an die Masche. mesh.create_element() mit: VertexElementType.NORMAL, MappingMode.CONTROL_POINT,und . ReferenceMode.DIRECT:

from aspose.threed.entities import VertexElementType, MappingMode, ReferenceMode, VertexElementNormal
from aspose.threed.utilities import Vector4, FVector4

##Create the normal element (returns VertexElementNormal, a VertexElementFVector subclass)
normals: VertexElementNormal = mesh.create_element(
    VertexElementType.NORMAL,
    MappingMode.CONTROL_POINT,
    ReferenceMode.DIRECT
)

##One normal per vertex: all pointing out of the XY plane (0, 0, 1)
normals.set_data([
    FVector4(0, 0, 1, 0),   # vertex 0
    FVector4(0, 0, 1, 0),   # vertex 1
    FVector4(0, 0, 1, 0),   # vertex 2
])

print("Normal layer attached.")

MappingMode.CONTROL_POINT bedeutet ein Normalpunkt pro Punkt. ReferenceMode.DIRECT bedeutet, dass die normalen Daten in derselben Reihenfolge wie die Kontrollpunkte gelesen werden (keine zusätzliche Indexpuffer).

Normalen Vektoren verwenden FVector4(x, y, z, w) mit: w=0 eine Richtung anstatt einer Position anzuzeigen. FVector4 ist ein Einzelpräzisions-Floatvektor; Vertexattributdaten in VertexElementFVector Unterklassen verwenden diesen Typ.

Schritt 7: Befestigen Sie das Netz an den Knoten und speichern

Fügen Sie das Netz zum Knoten hinzu, dann speichern Sie die Szene:

node.add_entity(mesh)

scene.save("triangle.gltf")
print("Saved triangle.gltf")

Das vollständige Arbeitsschriftstück (alle Schritte zusammen):

from aspose.threed import Scene
from aspose.threed.entities import Mesh, VertexElementType, MappingMode, ReferenceMode, VertexElementNormal
from aspose.threed.utilities import Vector3, Vector4, FVector4

scene = Scene()
node = scene.root_node.create_child_node("triangle")

mesh = Mesh("triangle")

##Add 3 vertices (x, y, z, w)
# Use _control_points to mutate the backing list directly (control_points returns a copy)
mesh._control_points.append(Vector4(0.0, 0.0, 0.0, 1.0))
mesh._control_points.append(Vector4(1.0, 0.0, 0.0, 1.0))
mesh._control_points.append(Vector4(0.5, 1.0, 0.0, 1.0))

##Create a triangle polygon
mesh.create_polygon(0, 1, 2)

##Add normals (create_element returns VertexElementNormal, a VertexElementFVector subclass)
normals: VertexElementNormal = mesh.create_element(VertexElementType.NORMAL, MappingMode.CONTROL_POINT, ReferenceMode.DIRECT)
normals.set_data([
    FVector4(0, 0, 1, 0),
    FVector4(0, 0, 1, 0),
    FVector4(0, 0, 1, 0),
])

node.add_entity(mesh)
scene.save("triangle.gltf")