VertexElement

VertexElement — Aspose.3D Python API Reference

Pachet: aspose.threed.entities (aspose-3d-foss 26.1.0)

VertexElement este clasa de bază abstractă pentru toate straturile de date per-vertex care pot fi atașate la un Geometry obiect. Fiecare strat conține un tablou de valori de date împreună cu mapping_mode și reference_mode metadate care descriu cum se mapă datele pe geometria de bază. Subclasele sunt specializate pentru normale, coordonate UV, culori de vârf, tangente, binormale și grupuri de netezire.

from aspose.threed.entities import VertexElement

VertexElement


`vertex_element_type`	`VertexElementType`	citire	Tip semantic al acestui strat (de exemplu,., `NORMAL`, `UV`, `VERTEX_COLOR`).
`name`	`str`	citire/scriere	Nume opțional pentru acest strat.
`mapping_mode`	`MappingMode`	citire/scriere	Controlează care primitivă geometrică este asociată fiecărei valori de date.
`reference_mode`	`ReferenceMode`	citire/scriere	Controlează dacă valorile sunt adresate direct sau printr-un tablou de indici.
`indices`	`list[int]`	citire	Tablou de indici utilizat când `reference_mode` este `INDEX_TO_DIRECT`.
`data`	`list[FVector4]`	citire	Valorile brute de date stocate ca `FVector4` intrări (disponibile pe `VertexElementFVector` subclase).


`set_data(data)`	`None`	Înlocuiește tabloul de date. Acceptă `list[FVector2]`, `list[FVector3]`, sau `list[FVector4]`; valorile sunt normalizate la `FVector4` intern.
`set_indices(data)`	`None`	Înlocuiți matricea de indici cu o listă de numere întregi.
`clear()`	`None`	Eliminați toate valorile de date și indicii din strat.
`copy_to(target)`	`None`	Copiați datele și indicii către altă `VertexElementFVector` instanță.

VertexElementNormal

Stochează vectorii normali ai suprafeței. Datele de normale sunt de obicei utilizate de renderere pentru calculele de iluminare.

from aspose.threed.entities import VertexElementNormal

VertexElement → VertexElementFVector → VertexElementNormal

VertexElementNormal(name="", mapping_mode=None, reference_mode=None)

vertex_element_type este fixat la VertexElementType.NORMAL.

VertexElementUV

Stochează coordonatele texturii UV. O mesh poate conține mai multe straturi UV pentru diferite canale de textură.

from aspose.threed.entities import VertexElementUV

VertexElement → VertexElementFVector → VertexElementUV

VertexElementUV(texture_mapping=None, name="", mapping_mode=None, reference_mode=None)


`texture_mapping`	`TextureMapping`	Canalul de textură pe care îl servește acest strat UV. Implicit este `TextureMapping.DIFFUSE`.

Proprietate suplimentară


`texture_mapping`	`TextureMapping`	citește	Canalul de textură cu care este asociat acest strat UV.

`add_data(data)`

Adaugă datele de coordonate UV. Acceptă list[Vector2], list[Vector3], list[FVector2], list[FVector3], sau list[FVector4]. Toate valorile sunt stocate intern ca FVector4 cu componentele neutilizate setate la 0.0.

VertexElementVertexColor

Stochează valori de culoare RGBA per-vertex în intervalul 0–1.

from aspose.threed.entities import VertexElementVertexColor

VertexElement → VertexElementFVector → VertexElementVertexColor

VertexElementVertexColor(name="", mapping_mode=None, reference_mode=None)

vertex_element_type este fixat la VertexElementType.VERTEX_COLOR.

VertexElementTangent

Stochează vectori tangent per-vertex sau per-corner, folosiți pentru redarea hărților de normală.

from aspose.threed.entities import VertexElementTangent

VertexElement → VertexElementFVector → VertexElementTangent

vertex_element_type este fixat la VertexElementType.TANGENT.

VertexElementBinormal

Stochează vectori binormali (bitangente) per-vertex sau per-corner, completând VertexElementTangent pentru maparea normală în spațiul tangent.

from aspose.threed.entities import VertexElementBinormal

VertexElement → VertexElementFVector → VertexElementBinormal

vertex_element_type este fixat la VertexElementType.BINORMAL.

VertexElementSmoothingGroup

Stochează ID-uri întregi de grupuri de netezire per-poligon. Încărcate din fișiere OBJ care conțin s declarații.

from aspose.threed.entities import VertexElementSmoothingGroup

VertexElement → VertexElementIntsTemplate → VertexElementSmoothingGroup

vertex_element_type este fixat la VertexElementType.SMOOTHING_GROUP.

Enumerarea VertexElementType

Identifică rolul semantic al unui strat de element de vârf.

from aspose.threed.entities import VertexElementType


`NORMAL`	Vectori normali ai suprafeței.
`UV`	Coordonate UV ale texturii.
`VERTEX_COLOR`	Culoare RGBA pe fiecare vârf.
`TANGENT`	Vectori tangent pentru maparea normală.
`BINORMAL`	Vectori binormali (bitangent).
`SMOOTHING_GROUP`	ID-uri întregi ale grupului de netezire per poligon.
`MATERIAL`	Index de material per poligon.
`POLYGON_GROUP`	Index de grupare a poligoanelor.
`VERTEX_CREASE`	Greutăți de plișare ale vârfurilor în subdiviziune.
`EDGE_CREASE`	Greutăți de plișare ale muchiilor în subdiviziune.
`USER_DATA`	Date arbitrare definite de utilizator.
`VISIBILITY`	Indicatori de vizibilitate per-element.
`SPECULAR`	Culoare sau intensitate speculară.
`WEIGHT`	Greutăți de amestec pentru skinning.
`HOLE`	Indicatori de găuri în poligon.

Enumerarea MappingMode

Controlează cu ce primitive geometrică este asociată fiecare valoare a elementului de vârf.

from aspose.threed.entities import MappingMode


`CONTROL_POINT`	O valoare per punct de control (vârf).
`POLYGON_VERTEX`	O valoare per colț de poligon (față‑vârf).
`POLYGON`	O valoare per poligon.
`EDGE`	O valoare per muchie.
`ALL_SAME`	O singură valoare se aplică întregului mesh.

Enumerarea ReferenceMode

Controlează modul în care este indexat taboul de date.

from aspose.threed.entities import ReferenceMode


`DIRECT`	Datele sunt accesate secvențial, fără un tablou separat de indici.
`INDEX`	Datele sunt accesate printr-un indices array separat.
`INDEX_TO_DIRECT`	Un indices array mapează fiecare primitiv de mapare la o poziție în data array.

Atașează un strat de normale la o plasă (mapare DIRECTĂ):

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

mesh = Mesh()
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))
mesh.create_polygon(0, 1, 2)

normals: VertexElementNormal = mesh.create_element(
    VertexElementType.NORMAL,
    MappingMode.CONTROL_POINT,
    ReferenceMode.DIRECT,
)
normals.set_data([
    FVector4(0.0, 0.0, 1.0, 0.0),
    FVector4(0.0, 0.0, 1.0, 0.0),
    FVector4(0.0, 0.0, 1.0, 0.0),
])

scene = Scene()
scene.root_node.create_child_node("tri", mesh)
scene.save("triangle_normals.glb")

Atașați coordonatele UV (mapare INDEX_TO_DIRECT):

from aspose.threed import Scene
from aspose.threed.entities import Mesh, TextureMapping, MappingMode, ReferenceMode
from aspose.threed.utilities import Vector4, FVector4

mesh = Mesh()
for x, z in [(0, 0), (1, 0), (1, 1), (0, 1)]:
    mesh.control_points.append(Vector4(float(x), 0.0, float(z), 1.0))
mesh.create_polygon(0, 1, 2, 3)

uv = mesh.create_element_uv(
    TextureMapping.DIFFUSE,
    MappingMode.POLYGON_VERTEX,
    ReferenceMode.INDEX_TO_DIRECT,
)
uv.set_data([
    FVector4(0.0, 0.0, 0.0, 0.0),
    FVector4(1.0, 0.0, 0.0, 0.0),
    FVector4(1.0, 1.0, 0.0, 0.0),
    FVector4(0.0, 1.0, 0.0, 0.0),
])
uv.set_indices([0, 1, 2, 3])

scene = Scene()
scene.root_node.create_child_node("quad", mesh)
scene.save("quad_uv.glb")