VertexElement

VertexElement — Aspose.3D Python API Reference

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

VertexElement er den abstrakte grundklasse for alle per-vertex-datalag, der kan knyttes til en Geometry objekt. Hvert lag indeholder et array af dataværdier sammen med mapping_mode og reference_mode metadata, der beskriver, hvordan dataene kortlægges på den underliggende geometri. Underklasser er specialiseret til normaler, UV-koordinater, vertex-farver, tangenter, binormale og udjævningsgrupper.

from aspose.threed.entities import VertexElement

VertexElement


`vertex_element_type`	`VertexElementType`	læs	Semantisk type for dette lag (f.eks., `NORMAL`, `UV`, `VERTEX_COLOR`).
`name`	`str`	læs/skriv	Valgfrit navn for dette lag.
`mapping_mode`	`MappingMode`	læs/skriv	Styrer hvilken geometriprimitiv hver dataværdi er knyttet til.
`reference_mode`	`ReferenceMode`	læs/skriv	Styrer om værdier adresseres direkte eller via et indeksarray.
`indices`	`list[int]`	læs	Indeksarray brugt når `reference_mode` er `INDEX_TO_DIRECT`.
`data`	`list[FVector4]`	læst	Rådataværdier gemt som `FVector4` poster (tilgængelige på `VertexElementFVector` subklasser).


`set_data(data)`	`None`	Erstat dataarrayet. Accepterer `list[FVector2]`, `list[FVector3]`, eller `list[FVector4]`; værdier normaliseres til `FVector4` internt.
`set_indices(data)`	`None`	Erstat indeksarrayet med en liste af heltal.
`clear()`	`None`	Fjern alle dataværdier og indekser fra laget.
`copy_to(target)`	`None`	Kopier data og indekser til en anden `VertexElementFVector` instans.

VertexElementNormal

Gemmer overflade-normalvektorer. Normaldata bruges typisk af renderere til lysberegninger.

from aspose.threed.entities import VertexElementNormal

VertexElement → VertexElementFVector → VertexElementNormal

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

vertex_element_type er fastsat til VertexElementType.NORMAL.

VertexElementUV

Gemmer UV-teksturkoordinater. Et mesh kan indeholde flere UV-lag for forskellige teksturkanaler.

from aspose.threed.entities import VertexElementUV

VertexElement → VertexElementFVector → VertexElementUV

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


`texture_mapping`	`TextureMapping`	Teksturkanalen som dette UV-lag betjener. Standard er `TextureMapping.DIFFUSE`.

Yderligere egenskab


`texture_mapping`	`TextureMapping`	læse	Teksturkanalen som dette UV-lag er tilknyttet.

`add_data(data)`

Tilføj UV-koordinatdata. Accepterer list[Vector2], list[Vector3], list[FVector2], list[FVector3], eller list[FVector4]. Alle værdier gemmes internt som FVector4 med ubrugte komponenter sat til 0.0.

VertexElementVertexColor

Gemmer per-vertex RGBA-farveværdier i intervallet 0–1.

from aspose.threed.entities import VertexElementVertexColor

VertexElement → VertexElementFVector → VertexElementVertexColor

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

vertex_element_type er fastsat til VertexElementType.VERTEX_COLOR.

VertexElementTangent

Gemmer per-vertex eller per-hjørne tangentvektorer, der bruges til normalmap-rendering.

from aspose.threed.entities import VertexElementTangent

VertexElement → VertexElementFVector → VertexElementTangent

vertex_element_type er fastsat til VertexElementType.TANGENT.

VertexElementBinormal

Gemmer per-vertex eller per-corner binormale (bitangent) vektorer, som supplerer VertexElementTangent til tangentrum normalkortlægning.

from aspose.threed.entities import VertexElementBinormal

VertexElement → VertexElementFVector → VertexElementBinormal

vertex_element_type er fastsat til VertexElementType.BINORMAL.

VertexElementSmoothingGroup

Gemmer heltals‑smoothing‑gruppe‑ID’er pr. polygon. Indlæses fra OBJ‑filer, der indeholder s deklarationer.

from aspose.threed.entities import VertexElementSmoothingGroup

VertexElement → VertexElementIntsTemplate → VertexElementSmoothingGroup

vertex_element_type er fastsat til VertexElementType.SMOOTHING_GROUP.

VertexElementType‑enumeration

Identificerer den semantiske rolle for et vertex‑element‑lag.

from aspose.threed.entities import VertexElementType


`NORMAL`	Overflade‑normale vektorer.
`UV`	Tekstur‑UV‑koordinater.
`VERTEX_COLOR`	RGBA‑farve pr. vertex.
`TANGENT`	Tangentiale vektorer til normalkortlægning.
`BINORMAL`	Binormale (bitangent) vektorer.
`SMOOTHING_GROUP`	Heltals‑ID’er for smoothing‑grupper pr. polygon.
`MATERIAL`	Materiale‑indeks pr. polygon.
`POLYGON_GROUP`	Polygon‑grupperingsindeks.
`VERTEX_CREASE`	Vægte for knæk ved underopdelings‑vertex.
`EDGE_CREASE`	Vægte for knæk ved underopdelings‑kant.
`USER_DATA`	Arbitrær brugerdefineret data.
`VISIBILITY`	Per-element synlighedsflag.
`SPECULAR`	Spekulær farve eller intensitet.
`WEIGHT`	Blandingsvægte for skinning.
`HOLE`	Polygonhulflag.

MappingMode‑enumeration

Styrer hvilken geometriprimitiv hver vertex‑element‑værdi er knyttet til.

from aspose.threed.entities import MappingMode


`CONTROL_POINT`	Én værdi pr. kontrolpunkt (vertex).
`POLYGON_VERTEX`	Én værdi pr. polygonhjørne (face-vertex).
`POLYGON`	Én værdi pr. polygon.
`EDGE`	Én værdi pr. kant.
`ALL_SAME`	En enkelt værdi gælder for hele mesh’en.

ReferenceMode‑enumeration

Styrer hvordan data‑arrayet indekseres.

from aspose.threed.entities import ReferenceMode


`DIRECT`	Data tilgås sekventielt uden et separat indices array.
`INDEX`	Data tilgås via et separat indices array.
`INDEX_TO_DIRECT`	Et indices array kortlægger hver mapping primitive til en position i data array.

Vedhæft et normal‑lag til et mesh (DIRECT‑kortlægning):

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")

Vedhæft UV-koordinater (INDEX_TO_DIRECT-mapping):

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")