VertexElement

VertexElement — Aspose.3D Python API Reference

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

VertexElement é a classe base abstrata para todas as camadas de dados por vértice que podem ser anexadas a um Geometry objeto. Cada camada contém um array de valores de dados junto com mapping_mode e reference_mode metadados que descrevem como os dados são mapeados na geometria subjacente. Subclasses são especializadas para normais, coordenadas UV, cores de vértice, tangentes, binormais e grupos de suavização.

from aspose.threed.entities import VertexElement

VertexElement


`vertex_element_type`	`VertexElementType`	leitura	Tipo semântico desta camada (ex., `NORMAL`, `UV`, `VERTEX_COLOR`).
`name`	`str`	leitura/gravação	Nome opcional para esta camada.
`mapping_mode`	`MappingMode`	leitura/gravação	Controla qual primitiva de geometria cada valor de dado está associado.
`reference_mode`	`ReferenceMode`	leitura/gravação	Controla se os valores são endereçados diretamente ou por meio de um array de índices.
`indices`	`list[int]`	leitura	Array de índices usado quando `reference_mode` é `INDEX_TO_DIRECT`.
`data`	`list[FVector4]`	leitura	Valores de dados brutos armazenados como `FVector4` entradas (disponíveis em `VertexElementFVector` subclasses).


`set_data(data)`	`None`	Substitua o array de dados. Aceita `list[FVector2]`, `list[FVector3]`, ou `list[FVector4]`; os valores são normalizados para `FVector4` internamente.
`set_indices(data)`	`None`	Substitua o array de índices por uma lista de inteiros.
`clear()`	`None`	Remova todos os valores de dados e índices da camada.
`copy_to(target)`	`None`	Copie dados e índices para outro `VertexElementFVector` instância.

VertexElementNormal

Armazena vetores normais de superfície. Dados de normais são tipicamente usados pelos renderizadores para cálculos de iluminação.

from aspose.threed.entities import VertexElementNormal

VertexElement → VertexElementFVector → VertexElementNormal

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

vertex_element_type está fixo em VertexElementType.NORMAL.

VertexElementUV

Armazena coordenadas de textura UV. Uma malha pode conter múltiplas camadas UV para diferentes canais de textura.

from aspose.threed.entities import VertexElementUV

VertexElement → VertexElementFVector → VertexElementUV

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


`texture_mapping`	`TextureMapping`	O canal de textura que esta camada UV serve. O padrão é `TextureMapping.DIFFUSE`.

Propriedade adicional


`texture_mapping`	`TextureMapping`	ler	O canal de textura ao qual esta camada UV está associada.

`add_data(data)`

Anexa dados de coordenadas UV. Aceita list[Vector2], list[Vector3], list[FVector2], list[FVector3], ou list[FVector4]. Todos os valores são armazenados internamente como FVector4 com componentes não usados definidos como 0.0.

VertexElementVertexColor

Armazena valores de cor RGBA por vértice no intervalo 0–1.

from aspose.threed.entities import VertexElementVertexColor

VertexElement → VertexElementFVector → VertexElementVertexColor

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

vertex_element_type está fixado a VertexElementType.VERTEX_COLOR.

VertexElementTangent

Armazena vetores tangentes por vértice ou por canto, usados para renderização de mapas normais.

from aspose.threed.entities import VertexElementTangent

VertexElement → VertexElementFVector → VertexElementTangent

vertex_element_type está fixado a VertexElementType.TANGENT.

VertexElementBinormal

Armazena vetores binormais (bitangentes) por vértice ou por canto, complementando VertexElementTangent para mapeamento normal em espaço tangente.

from aspose.threed.entities import VertexElementBinormal

VertexElement → VertexElementFVector → VertexElementBinormal

vertex_element_type está fixado a VertexElementType.BINORMAL.

VertexElementSmoothingGroup

Armazena IDs inteiros de grupos de suavização por polígono. Carregado de arquivos OBJ que contêm s declarações.

from aspose.threed.entities import VertexElementSmoothingGroup

VertexElement → VertexElementIntsTemplate → VertexElementSmoothingGroup

vertex_element_type é fixado em VertexElementType.SMOOTHING_GROUP.

Enumeração VertexElementType

Identifica a função semântica de uma camada de elemento de vértice.

from aspose.threed.entities import VertexElementType


`NORMAL`	Vetores normais de superfície.
`UV`	Coordenadas UV da textura.
`VERTEX_COLOR`	Cor RGBA por vértice.
`TANGENT`	Vetores tangentes para mapeamento normal.
`BINORMAL`	Vetores binormais (bitangentes).
`SMOOTHING_GROUP`	IDs inteiros de grupos de suavização por polígono.
`MATERIAL`	Índice de material por polígono.
`POLYGON_GROUP`	Índice de agrupamento de polígonos.
`VERTEX_CREASE`	Pesos de vinco de vértice na subdivisão.
`EDGE_CREASE`	Pesos de vinco de aresta na subdivisão.
`USER_DATA`	Dados arbitrários definidos pelo usuário.
`VISIBILITY`	Sinais de visibilidade por elemento.
`SPECULAR`	Cor ou intensidade especular.
`WEIGHT`	Pesos de mistura para skinning.
`HOLE`	Sinais de furos em polígonos.

Enumeração MappingMode

Controla a qual primitiva geométrica cada valor de elemento de vértice está associado.

from aspose.threed.entities import MappingMode


`CONTROL_POINT`	Um valor por ponto de controle (vértice).
`POLYGON_VERTEX`	Um valor por canto de polígono (face-vertex).
`POLYGON`	Um valor por polígono.
`EDGE`	Um valor por aresta.
`ALL_SAME`	Um único valor se aplica a toda a malha.

Enumeração ReferenceMode

Controla como o array de dados é indexado.

from aspose.threed.entities import ReferenceMode


`DIRECT`	Os dados são acessados sequencialmente sem um array de índices separado.
`INDEX`	Os dados são acessados por meio de um array de índices separado.
`INDEX_TO_DIRECT`	Um array de índices mapeia cada primitivo de mapeamento para uma posição no array de dados.

Anexe uma camada de normais a uma malha (mapeamento 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")

Anexar coordenadas UV (mapeamento 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")