Class Node

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

Ein Knoten stellt ein benanntes Element in der Hierarchie des Szenengraphen dar. Jeder Knoten hat eine lokale Transformation, kann Kindknoten enthalten und trägt null oder mehr Entity Objekte wie Meshes, Kameras oder Lichter.

export class Node extends SceneObject

Properties

A3DObject ← SceneObject ← Node

Properties

Erstelle einen übergeordneten Knoten, füge ihm zwei Kindknoten hinzu und durchlaufe die gesamte Hierarchie nach Namen.

import { Scene, Node } from '@aspose/3d';

const scene = new Scene();
const root = scene.rootNode;

const vehicle = root.createChildNode('vehicle');
const body = vehicle.createChildNode('body');
const wheel = vehicle.createChildNode('wheel_front_left');

function traverse(node: Node, depth = 0): void {
  console.log(' '.repeat(depth * 2) + node.name);
  for (const child of node.childNodes) {
    traverse(child, depth + 1);
  }
}

traverse(root);
// Output:
//   vehicle
//     body
//     wheel_front_left

Properties

Properties	Properties	Properties
`name`	`string`	Der Name dieses Knotens. Wird verwendet, um den Knoten im Szenengraphen zu identifizieren.
`parentNode`	`Node	null`
`childNodes`	`Node[]`	Ein Array direkter Kindknoten, die an diesem Knoten angehängt sind.
`entities`	`Entity[]`	Die Liste der Entitäten (Meshes, Kameras, Lichter usw.), die an diesem Knoten angehängt sind.
`materials`	`Material[]`	Die Liste der Materialien, die mit diesem Knoten verbunden sind.
`transform`	`Transform`	Die lokale Transformation dieses Knotens, mit `translation: Vector3`, `rotation: Quaternion`, und `scaling: Vector3` Komponenten.
`globalTransform`	`GlobalTransform`	Schreibgeschützt. Die Welt-Raum-Transformation, berechnet durch Multiplikation aller Vorfahren-Transformationen bis zur Wurzel.
`visible`	`boolean`	Ob dieser Knoten und sein Unterbaum gerendert werden. Standard ist `true`.
`excluded`	`boolean`	Properties `true`, der Knoten und sein Unterbaum werden vom Export ausgeschlossen. Standard ist `false`.
`entity`	`Entity	undefined`

Properties

addChildNode(node)

Fügt ein bestehendes Node Exemplar als direktes Kind dieses Knotens hinzu.

addChildNode(node: Node): void

Properties

node Node

Der anzuhängende Knoten. Der Knoten wird von seinem aktuellen Elternteil zu diesem Knoten umgeordnet.

Properties

void

Properties

import { Scene, Node } from '@aspose/3d';

const scene = new Scene();
const parent = scene.rootNode.createChildNode('parent');
const child = new Node('child');
parent.addChildNode(child);
console.log(`Children of parent: ${parent.childNodes.length}`); // 1

createChildNode(name?, entity?, material?)

Erstellt ein neues Node, optional mit einem Namen, einer Entität und einem Material, und fügt es als Kind dieses Knotens hinzu.

createChildNode(name?: string, entity?: Entity, material?: Material): Node

Properties

name string (optional)

Der Name für den neuen Kindknoten.

entity Entity (optional)

Eine Entität, die an den neuen Knoten angehängt werden soll, zum Beispiel ein Mesh Instanz.

material Material (optional)

Ein Material, das dem neuen Knoten zugeordnet werden soll.

Properties

Node

Der neu erstellte Kindknoten.

Properties

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

const scene = new Scene();
const mesh = new Mesh();
// ... populate mesh ...
const meshNode = scene.rootNode.createChildNode('geometry', mesh);
console.log(`Node name: ${meshNode.name}`);
console.log(`Entities attached: ${meshNode.entities.length}`);

evaluateGlobalTransform(withGeometricTransform)

Berechnet und gibt die Welt-Raum-Transformationsmatrix für diesen Knoten zurück. Pass true um den geometrischen Transformations-Offset, der im Knoten gespeichert ist, einzuschließen (von einigen FBX-Exportern verwendet).

evaluateGlobalTransform(withGeometricTransform: boolean): Matrix4

Properties

withGeometricTransform boolean

Properties true, schließt die geometrische Transformation in das Ergebnis ein.

Properties

Matrix4

Die 4×4 Transformationsmatrix im Weltkoordinatensystem.

Properties

import { Scene } from '@aspose/3d';

const scene = new Scene();
scene.open('model.fbx');
const node = scene.rootNode.childNodes[0];
const matrix = node.evaluateGlobalTransform(false);
console.log('World transform matrix computed.');

getBoundingBox()

Berechnet die achsenorientierte Begrenzungsbox dieses Knotens und aller seiner Nachkommen im Weltkoordinatensystem.

getBoundingBox(): BoundingBox

Properties

BoundingBox

Die achsenorientierte Begrenzungsbox, die alle Geometrien unter diesem Knoten umschließt.

Properties

import { Scene } from '@aspose/3d';

const scene = new Scene();
scene.open('model.obj');
const bbox = scene.rootNode.getBoundingBox();
console.log(`Min: ${JSON.stringify(bbox.minimum)}`);
console.log(`Max: ${JSON.stringify(bbox.maximum)}`);

merge(node)

Fügt den Inhalt eines anderen Knotens (seine Entitäten, Materialien und Kinder) in diesen Knoten ein und entfernt den Quellknoten aus der Szene.

merge(node: Node): void

Properties

node Node

Der Quellknoten, dessen Inhalt in diesen Knoten zusammengeführt wird.

Properties

void

Properties

import { Scene } from '@aspose/3d';

const scene = new Scene();
scene.open('multi_part.fbx');

const root = scene.rootNode;
if (root.childNodes.length >= 2) {
  root.childNodes[0].merge(root.childNodes[1]);
  console.log(`Children after merge: ${root.childNodes.length}`);
}