VertexElement

VertexElement — Aspose.3D Python API Reference

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

VertexElement är den abstrakta basklassen för alla per-vertex-datalager som kan fästas på en Geometry objekt. Varje lager innehåller en array av datavärden tillsammans med mapping_mode och reference_mode metadata som beskriver hur data mappas på den underliggande geometrin. Subklasser är specialiserade för normaler, UV-koordinater, vertexfärger, tangenter, binormaler och slätningsgrupper.

from aspose.threed.entities import VertexElement

VertexElement


`vertex_element_type`	`VertexElementType`	läsa	Semantisk typ för detta lager (t.ex., `NORMAL`, `UV`, `VERTEX_COLOR`).
`name`	`str`	läsa/skriva	Valfritt namn för detta lager.
`mapping_mode`	`MappingMode`	läsa/skriva	Styr vilken geometriprimitiv varje datavärde är associerat med.
`reference_mode`	`ReferenceMode`	läsa/skriva	Styr om värden adresseras direkt eller via en indexarray.
`indices`	`list[int]`	läsa	Indexarray som används när `reference_mode` är `INDEX_TO_DIRECT`.
`data`	`list[FVector4]`	läst	Rådatavärden lagrade som `FVector4` poster (tillgängliga på `VertexElementFVector` subklasser).


`set_data(data)`	`None`	Ersätt dataarrayen. Accepterar `list[FVector2]`, `list[FVector3]`, eller `list[FVector4]`; värden normaliseras till `FVector4` internt.
`set_indices(data)`	`None`	Ersätt indexarrayen med en lista av heltal.
`clear()`	`None`	Ta bort alla datavärden och index från lagret.
`copy_to(target)`	`None`	Kopiera data och index till en annan `VertexElementFVector` instans.

VertexElementNormal

Lagrar ytnormala vektorer. Normaldata används vanligtvis av renderare för ljusberäkningar.

from aspose.threed.entities import VertexElementNormal

VertexElement → VertexElementFVector → VertexElementNormal

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

vertex_element_type är fastställd till VertexElementType.NORMAL.

VertexElementUV

Lagrar UV-texturkoordinater. Ett mesh kan ha flera UV-lager för olika texturkanaler.

from aspose.threed.entities import VertexElementUV

VertexElement → VertexElementFVector → VertexElementUV

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


`texture_mapping`	`TextureMapping`	Texturkanalen som detta UV-lager tjänar. Standardvärdet är `TextureMapping.DIFFUSE`.

Ytterligare egenskap


`texture_mapping`	`TextureMapping`	läsa	Texturkanalen som detta UV-lager är associerat med.

`add_data(data)`

Lägg till UV-koordinatdata. Accepterar list[Vector2], list[Vector3], list[FVector2], list[FVector3], eller list[FVector4]. Alla värden lagras internt som FVector4 med oanvända komponenter satta till 0.0.

VertexElementVertexColor

Lagrar per-vertex RGBA-färgvärden i intervallet 0–1.

from aspose.threed.entities import VertexElementVertexColor

VertexElement → VertexElementFVector → VertexElementVertexColor

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

vertex_element_type är fastställd till VertexElementType.VERTEX_COLOR.

VertexElementTangent

Lagrar tangentvektorer per vertex eller per hörn, som används för rendering av normalmap.

from aspose.threed.entities import VertexElementTangent

VertexElement → VertexElementFVector → VertexElementTangent

vertex_element_type är fastställd till VertexElementType.TANGENT.

VertexElementBinormal

Lagrar per-vertex- eller per-corner-binormal (bitangent) vektorer, kompletterande VertexElementTangent för tangent-space normal mapping.

from aspose.threed.entities import VertexElementBinormal

VertexElement → VertexElementFVector → VertexElementBinormal

vertex_element_type är fastställd till VertexElementType.BINORMAL.

VertexElementSmoothingGroup

Lagrar per-polygon heltals‑ID:n för jämningsgrupper. Laddas från OBJ‑filer som innehåller s deklarationer.

from aspose.threed.entities import VertexElementSmoothingGroup

VertexElement → VertexElementIntsTemplate → VertexElementSmoothingGroup

vertex_element_type är fastställd till VertexElementType.SMOOTHING_GROUP.

VertexElementType‑enumeration

Identifierar den semantiska rollen för ett vertex‑elementlager.

from aspose.threed.entities import VertexElementType


`NORMAL`	Ytans normalvektorer.
`UV`	UV‑koordinater för textur.
`VERTEX_COLOR`	RGBA‑färg per vertex.
`TANGENT`	Tangentialvektorer för normalavbildning.
`BINORMAL`	Binormalvektorer (bitangent).
`SMOOTHING_GROUP`	Per-polygon heltals‑ID:n för jämningsgrupp.
`MATERIAL`	Materialindex per polygon.
`POLYGON_GROUP`	Polygongrupperingsindex.
`VERTEX_CREASE`	Subdivision‑vertex‑veckvikter.
`EDGE_CREASE`	Subdivision‑kant‑veckvikter.
`USER_DATA`	Godtyckliga användardefinierade data.
`VISIBILITY`	Per-element synlighetsflaggor.
`SPECULAR`	Speculär färg eller intensitet.
`WEIGHT`	Blendvikter för skinning.
`HOLE`	Polygonhålsflaggor.

MappingMode‑enumeration

Styr vilken geometriprimitiv varje vertex‑elementvärde är associerat med.

from aspose.threed.entities import MappingMode


`CONTROL_POINT`	Ett värde per kontrollpunkt (vertex).
`POLYGON_VERTEX`	Ett värde per polygonhörn (face-vertex).
`POLYGON`	Ett värde per polygon.
`EDGE`	Ett värde per kant.
`ALL_SAME`	Ett enda värde gäller för hela meshen.

ReferenceMode‑enumeration

Styr hur dataarrayen indexeras.

from aspose.threed.entities import ReferenceMode


`DIRECT`	Data läses sekventiellt utan en separat indices array.
`INDEX`	Data läses via en separat indices array.
`INDEX_TO_DIRECT`	En indices array mappar varje mappningsprimitive till en position i data array.

Fäst ett normal‑lager på ett mesh (DIRECT‑mappning):

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

Koppla UV-koordinater (INDEX_TO_DIRECT-mappning):

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