Aspose.3D FOSS
TypeScript
Mesh

Mesh

Paket: @aspose/3d (v24.12.0)

Mesh är också tillgänglig via sub‑sökvägsimport @aspose/3d/entities.

Mesh är den primära polygongeometri‑enheten i @aspose/3d. Den lagrar vertexpositioner som kontrollpunkter, definierar polygonytor med listor av vertexindex och stöder flera lager av vertex‑elementdata såsom normaler och UV‑koordinater.

export class Mesh extends Geometry

ImageRenderOptions

A3DObject ← SceneObject ← Entity ← Geometry ← Mesh

ImageRenderOptions

Bygg ett enda triangel‑mesh, fäst det i scenen och spara till GLB.

import { Scene, Vector4 } from '@aspose/3d';
import { Mesh } from '@aspose/3d/entities';

// Create the mesh and define three control points (vertices)
const mesh = new Mesh();
mesh.controlPoints.push(
  new Vector4(0, 1, 0, 1),   // apex
  new Vector4(-1, 0, 0, 1),  // bottom-left
  new Vector4(1, 0, 0, 1),   // bottom-right
);

// Define one triangular polygon using vertex indices
mesh.createPolygon(0, 1, 2);

// Attach the mesh to the scene and save (extension infers GLB format)
const scene = new Scene();
scene.rootNode.createChildNode('triangle', mesh);
scene.save('triangle.glb');
console.log(`Polygon count: ${mesh.polygonCount}`); // 1

ImageRenderOptions

NameTypeAccessDescription
edgesnumber[]ReadGets the edges.
polygonCountnumberReadGets the polygon count.
polygonsnumber[][]ReadGets the polygons.
deformersany[]ReadGets the deformers.
SignatureDescription
`constructor(name: stringnull, _heightMap: any, _transform: any, _triMesh: boolean
createPolygon()Adds a new polygon to the mesh
getPolygonSize(index: number) → numberReturns the number of vertices in the polygon at the given index
toMesh() → MeshReturns a Mesh instance representing the current object (identity conversion)
optimize(_vertexElements: boolean, _toleranceControlPoint: number, _toleranceNormal: number, _toleranceUV: number) → MeshNot implemented in the FOSS edition — throws at runtime. Reduces mesh complexity using vertex element flag and tolerance values for control points, normals, and UVs
doBoolean(_op: any, _a: Mesh, _transformA: any, _b: Mesh, _transformB: any) → MeshNot implemented in the FOSS edition — throws at runtime. Performs a boolean operation defined by _op on meshes _a and _b with respective transforms
isManifold() → booleanNot implemented in the FOSS edition — throws at runtime. Returns true if manifold is set.
union(_a: Mesh, _b: Mesh) → MeshNot implemented in the FOSS edition — throws at runtime. Returns a new Mesh that is the union of meshes _a and _b
difference(_a: Mesh, _b: Mesh) → MeshNot implemented in the FOSS edition — throws at runtime. Returns a new Mesh that is the difference of mesh _a minus mesh _b
intersect(_a: Mesh, _b: Mesh) → MeshNot implemented in the FOSS edition — throws at runtime.
triangulate() → MeshConverts all polygons in the mesh to triangles and returns the mesh
getBoundingBox() → anyReturns the bounding box.
getEntityRendererKey() → anyNot implemented in the FOSS edition — throws at runtime. Returns the entity renderer key.

ImageRenderOptions

createPolygon(…indices)

Definierar en ny polygonyta med de angivna kontrollpunkt‑indexen. Indexen måste referera till giltiga positioner i controlPoints.

createPolygon(...indices: number[]): void

ImageRenderOptions

...indices number[]

Tre eller fler nollbaserade index i controlPoints array, i moturs varvordning.

ImageRenderOptions

void

ImageRenderOptions 

import { Vector4 } from '@aspose/3d';
import { Mesh } from '@aspose/3d/entities';

const mesh = new Mesh();
mesh.controlPoints.push(
  new Vector4(0, 0, 0, 1),
  new Vector4(1, 0, 0, 1),
  new Vector4(1, 1, 0, 1),
  new Vector4(0, 1, 0, 1),
);
// Define a quad as two triangles, or a single quad polygon:
mesh.createPolygon(0, 1, 2, 3);
console.log(`Polygons: ${mesh.polygonCount}`); // 1

triangulate()

Omvandlar alla icke‑triangulära polygoner i detta mesh till trianglar. Returnerar det triangulerade meshet (kan vara samma instans eller en ny).

triangulate(): Mesh

ImageRenderOptions

Mesh

Det triangulerade meshet.

ImageRenderOptions

const mesh = new Mesh(); mesh.controlPoints.push( new Vector4(0, 0, 0, 1), new Vector4(1, 0, 0, 1), new Vector4(1, 1, 0, 1), new Vector4(0, 1, 0, 1), ); mesh.createPolygon(0, 1, 2, 3); // quad const triangulated = mesh.triangulate(); console.log(Polygons after triangulation: ${triangulated.polygonCount}); // 2


---

### toMesh()

Returnerar mesh som en `Mesh` instans. För `Mesh` objekt är detta en identitetsoperation; metoden är mer meningsfull på primitiva geometrityper som ärver från `Geometry`.

```typescript
toMesh(): Mesh

ImageRenderOptions

Mesh

Denna mesh‑instans.

static union(a, b)

NOT IMPLEMENTED. Denna metod är definierad i API-ytan men kastar Error('union is not implemented') vid körning. Anropa den inte i produktionskod.

Utför en boolesk union av två mesh. Resultatet innehåller den kombinerade volymen av båda indata.

static union(a: Mesh, b: Mesh): Mesh

ImageRenderOptions

a Mesh

Den första mesh-operanden.

b Mesh

Den andra mesh-operanden.

ImageRenderOptions

Mesh

Ett nytt nät som representerar unionen av a och b.

ImageRenderOptions 

import { Mesh } from '@aspose/3d/entities';

// Assumes meshA and meshB are already populated Mesh instances
const combined = Mesh.union(meshA, meshB);
console.log(`Union polygon count: ${combined.polygonCount}`);

static difference(a, b)

NOT IMPLEMENTED. Denna metod är definierad i API-ytan men kastar Error('difference is not implemented') vid körning. Anropa den inte i produktionskod.

Utför en boolesk differens, subtraherar volymen av nätet b från nätet a.

static difference(a: Mesh, b: Mesh): Mesh

ImageRenderOptions

a Mesh

Bas‑mesh.

b Mesh

Nätet att subtrahera från a.

ImageRenderOptions

Mesh

Ett nytt nät som representerar a minus b.

ImageRenderOptions

const result = Mesh.difference(meshA, meshB); console.log(Difference polygon count: ${result.polygonCount});


---

### static intersect(a, b)

**NOT IMPLEMENTED.** Denna metod är definierad i API-ytan men kastar `Error('intersect is not implemented')` vid körning. Anropa den inte i produktionskod.

Utför en boolesk skärning av två meshar. Resultatet innehåller endast den överlappande volymen.

```typescript
static intersect(a: Mesh, b: Mesh): Mesh

ImageRenderOptions

a Mesh

Den första mesh-operanden.

b Mesh

Den andra mesh-operanden.

ImageRenderOptions

Mesh

Ett nytt mesh som representerar skärningen av a och b.

ImageRenderOptions

const overlap = Mesh.intersect(meshA, meshB); console.log(Intersection polygon count: ${overlap.polygonCount});


---

### createElement(type, mapping?, reference?)

Skapar ett nytt `VertexElement` dataskikt på detta mesh för anpassade per-vertex-attribut.

```typescript
createElement(
  type: VertexElementType,
  mapping?: MappingMode,
  reference?: ReferenceMode
): VertexElement

ImageRenderOptions

type VertexElementType

Typen av vertex-attribut att skapa (till exempel, VertexElementType.Normal).

mapping MappingMode (valfritt)

Hur elementdata mappas till meshens topologi. Standardvärde är MappingMode.ControlPoint.

reference ReferenceMode (valfritt)

Hur elementindex refererar till dataarrayen. Standardvärde är ReferenceMode.Direct.

ImageRenderOptions

VertexElement

Det nyss skapade vertex-elementlagret.

createElementUV(mapping, mappingMode?, referenceMode?)

Skapar ett UV-koordinatlager på detta mesh.

createElementUV(
  mapping: TextureMapping,
  mappingMode?: MappingMode,
  referenceMode?: ReferenceMode
): VertexElementUV

ImageRenderOptions

mapping TextureMapping

UV-kanalen att skapa (till exempel, TextureMapping.Diffuse).

mappingMode MappingMode (valfritt)

Hur UV-koordinater mappas till vertexar.

referenceMode ReferenceMode (valfritt)

Hur UV-indexdata refererar till UV-arrayen.

ImageRenderOptions

VertexElementUV

Det nyss skapade UV‑elementlagret.

ImageRenderOptions 

import { Mesh } from '@aspose/3d/entities';
import { TextureMapping } from '@aspose/3d';

const mesh = new Mesh();
// ... define control points and polygons ...
const uvLayer = mesh.createElementUV(TextureMapping.Diffuse);
console.log(`UV element created: ${uvLayer !== undefined}`);
 Svenska