Bitbybit Docs
    Preparing search index...

    Class BabylonNode

    Nœuds de transformation : des points invisibles avec une position et une orientation auxquels les maillages et d'autres nœuds peuvent être rattachés, de sorte qu'un groupe entier se déplace comme un seul. Construire une hiérarchie de nœuds est la façon dont les arrangements complexes sont placés : tournez le parent et chaque enfant tourne avec lui. Les méthodes ici créent des nœuds, lisent leurs axes et positions dans l'espace monde ou local, et les déplacent, les tournent et les rattachent à un autre parent ; les angles sont en degrés.

    Index

    Constructors

    Methods

    • Dessine les trois axes d'un nœud sous forme de lignes colorées de la longueur donnée, rattachées à lui, pour que sa position et son orientation soient visibles ; les couleurs par défaut sont rouge pour X, vert pour Y et bleu pour Z.

      Parameters

      • inputs: DrawNodeDto

        Le nœud, les couleurs des axes et la longueur des axes

      Returns void

      bitbybit.babylon.node.drawNode({ node, colorX: "#ff0000", colorY: "#00ff00", colorZ: "#0000ff", size: 2 });
      
    • Dessine les trois axes de plusieurs nœuds sous forme de lignes colorées de la longueur donnée, chaque jeu rattaché à son nœud, comme drawNode le fait pour un seul.

      Parameters

      • inputs: DrawNodesDto

        Les nœuds, les couleurs des axes et la longueur des axes

      Returns void

      bitbybit.babylon.node.drawNodes({ nodes: [nodeA, nodeB], colorX: "#ff0000", colorY: "#00ff00", colorZ: "#0000ff", size: 2 });
      
    • Crée un nœud à origin tourné des trois angles rotation en degrés autour de X, Y et Z, dans le système de coordonnées de parent quand il est donné.

      Parameters

      Returns TransformNode

      Le nouveau nœud

      const node = bitbybit.babylon.node.createNodeFromRotation({ parent: null, origin: [0, 5, 0], rotation: [0, 45, 0] });
      
    • Crée un nœud rattaché au nœud racine de la scène, un nouveau point de départ pour construire une hiérarchie à l'origine du monde.

      Returns TransformNode

      Le nouveau nœud, dont le parent est le nœud racine de la scène

      const world = bitbybit.babylon.node.createWorldNode();
      const arm = bitbybit.babylon.node.createNodeFromRotation({ parent: world, origin: [0, 5, 0], rotation: [0, 0, 30] });
    • Lit la direction dans laquelle pointe l'axe Z local d'un nœud dans l'espace monde, avec la rotation de chaque parent appliquée.

      Parameters

      Returns number[]

      La direction avant sous forme de vecteur

    • Lit la direction dans laquelle pointe l'axe X local d'un nœud dans l'espace monde, avec la rotation de chaque parent appliquée.

      Parameters

      Returns number[]

      La direction droite sous forme de vecteur

    • Lit la direction dans laquelle pointe l'axe Y local d'un nœud dans l'espace monde, avec la rotation de chaque parent appliquée.

      Parameters

      Returns number[]

      La direction haut sous forme de vecteur

    • Lit où se trouve l'origine d'un nœud dans l'espace monde, avec la transformation de chaque parent appliquée.

      Parameters

      Returns number[]

      La position dans le monde sous forme de point

    • Lit la rotation d'un nœud dans l'espace monde, avec la rotation de chaque parent appliquée, sous forme de matrice 4x4 de 16 nombres.

      Parameters

      Returns number[]

      La rotation sous forme de matrice de 16 nombres

    • Lit la rotation d'un nœud par rapport à son parent sous forme de matrice 4x4 de 16 nombres ; le nœud doit porter un quaternion de rotation, que rotate et setDirection lui donnent.

      Parameters

      Returns number[]

      La rotation sous forme de matrice de 16 nombres

    • Liste les nœuds et les maillages rattachés directement sous un nœud, ceux qui se déplacent avec lui.

      Parameters

      Returns Node[]

      Les enfants directs

    • Lit le nœud auquel un nœud est rattaché, celui avec lequel il se déplace ; un nœud de premier niveau n'en a pas.

      Parameters

      Returns Node

      Le nœud parent

    • Lit la position d'un nœud mesurée dans ses propres axes locaux plutôt que dans ceux de son parent, ce qui diffère une fois le nœud tourné.

      Parameters

      Returns number[]

      La position sous forme de point dans l'espace local du nœud

    • Donne le nœud racine de la scène, le sommet de la hiérarchie auquel createWorldNode se rattache.

      Returns TransformNode

      Le nœud racine

    • Lit la rotation d'un nœud par rapport à son parent sous forme de trois angles en degrés autour de X, Y et Z.

      Parameters

      Returns number[]

      Les angles de rotation en degrés

    • Tourne un nœud de angle degrés autour d'un axe passant par position, de sorte que le nœud orbite autour de ce point au lieu de tourner sur place ; ses enfants suivent.

      Parameters

      Returns void

      bitbybit.babylon.node.rotateAroundAxisWithPosition({ node, position: [0, 0, 0], axis: [0, 1, 0], angle: 90 });
      
    • Tourne un nœud de angle degrés autour d'un axe passant par sa propre origine, en plus de sa rotation actuelle ; ses enfants suivent.

      Parameters

      • inputs: RotateNodeDto

        Le nœud, la direction de l'axe et l'angle en degrés

      Returns void

      bitbybit.babylon.node.rotate({ node, axis: [0, 1, 0], angle: 45 });
      
    • Déplace un nœud à un point de l'espace monde, quels que soient ses parents ; ses enfants suivent.

      Parameters

      Returns void

      bitbybit.babylon.node.setAbsolutePosition({ node, position: [10, 0, 0] });
      
    • Tourne un nœud pour que son axe Z local pointe le long de direction ; ses enfants suivent.

      Parameters

      Returns void

      bitbybit.babylon.node.setDirection({ node, direction: [1, 0, 0] });
      
    • Rattache un nœud à un autre pour qu'il se déplace avec lui désormais, en gardant sa place actuelle dans le monde ; un parent null le détache.

      Parameters

      Returns void

      bitbybit.babylon.node.setParent({ node: wheel, parentNode: car });
      
    • Déplace un nœud de distance unités de la scène le long de direction, donnée dans les axes locaux propres du nœud ; ses enfants suivent.

      Parameters

      Returns void

      bitbybit.babylon.node.translate({ node, direction: [0, 1, 0], distance: 5 });