Bitbybit Docs
    Preparing search index...

    Class JSCADShapes

    Construir sólidos JSCAD: cubos, paralelepípedos, esferas, elipsoides, cilindros, um toro e um sólido a partir de pontos de polígonos em bruto, cada um com uma variante que coloca uma cópia em cada ponto de uma lista. O kernel mantém Z como o seu próprio eixo, por isso um cilindro fica de pé ao longo de Z e um toro deita-se no plano XY; cada sólido é uma malha fechada de polígonos e segments diz quantas facetas planas aproximam uma superfície redonda.

    Index

    Constructors

    constructor

    primitives

    cube cuboid cylinderElliptic cylinder ellipsoid geodesicSphere roundedCuboid roundedCylinder sphere torus

    primitives on centers

    cubesOnCenterPoints cuboidsOnCenterPoints cylinderEllipticOnCenterPoints cylindersOnCenterPoints ellipsoidsOnCenterPoints geodesicSpheresOnCenterPoints roundedCuboidsOnCenterPoints roundedCylindersOnCenterPoints spheresOnCenterPoints

    shapes

    fromPolygonPoints

    Constructors

    primitives

    • Constrói um cubo com comprimento de aresta size centrado em center, com as suas faces paralelas aos eixos.

      Parameters

      Returns Promise<JSCADEntity>

      O sólido do cubo

      const cube = await bitbybit.jscad.shapes.cube({ center: [0, 0, 0], size: 10 });

    • Constrói uma caixa centrada em center com width ao longo de X, height ao longo de Y e length ao longo de Z, com as suas faces paralelas aos eixos.

      Parameters

      • inputs: CuboidDto

        O centro e os três comprimentos dos lados

      Returns Promise<JSCADEntity>

      O sólido da caixa

      const box = await bitbybit.jscad.shapes.cuboid({ center: [0, 0, 0], width: 10, height: 5, length: 20 });

    • Constrói um cilindro com secção transversal elíptica cujos raios podem diferir nas duas extremidades, de pé ao longo de Z e centrado em center.

      startRadius é o raio X e Y na extremidade inferior e endRadius na superior, por isso pares desiguais criam um sólido afunilado ou em forma de cone; height é repartida igualmente acima e abaixo de center.

      Parameters

      • inputs: CylidnerEllipticDto

        O centro, a altura, os dois pares de raios e o número de segmentos

      Returns Promise<JSCADEntity>

      O sólido do cilindro elíptico

      const cone = await bitbybit.jscad.shapes.cylinderElliptic({ center: [0, 0, 0], height: 10, startRadius: [4, 2], endRadius: [1, 0.5], segments: 32 });

    • Constrói um cilindro redondo com o radius dado de pé ao longo de Z, com height repartida igualmente acima e abaixo de center.

      segments é o número de lados planos à sua volta; mais torna-o mais redondo.

      Parameters

      • inputs: CylidnerDto

        O centro, a altura, o raio e o número de segmentos

      Returns Promise<JSCADEntity>

      O sólido do cilindro

      const cylinder = await bitbybit.jscad.shapes.cylinder({ center: [0, 0, 0], height: 10, radius: 3, segments: 32 });

    • Constrói um elipsoide, uma esfera esticada separadamente ao longo de X, Y e Z, centrado em center.

      radius contém os três meios-tamanhos pela ordem [x, y, z]; valores iguais criam uma esfera.

      Parameters

      • inputs: EllipsoidDto

        O centro, os três raios e o número de segmentos

      Returns Promise<JSCADEntity>

      O sólido do elipsoide

      const egg = await bitbybit.jscad.shapes.ellipsoid({ center: [0, 0, 0], radius: [5, 3, 8], segments: 32 });

    • Constrói uma esfera a partir de triângulos de tamanho uniforme, da maneira como uma cúpula geodésica é construída, centrada em center.

      frequency é quão finamente as vinte faces iniciais são subdivididas; é usado em múltiplos inteiros de 6 e tem de ser pelo menos 6, e valores mais altos dão uma esfera mais redonda.

      Parameters

      Returns Promise<JSCADEntity>

      O sólido da esfera geodésica

      const dome = await bitbybit.jscad.shapes.geodesicSphere({ center: [0, 0, 0], radius: 5, frequency: 12 });

    • Constrói uma caixa com todas as suas arestas e cantos arredondados por roundRadius, centrada em center com width ao longo de X, height ao longo de Y e length ao longo de Z.

      roundRadius tem de ser menor que metade do lado mais pequeno ou é lançado um erro; segments define quão suavemente o arredondamento é facetado.

      Parameters

      • inputs: RoundedCuboidDto

        O centro, os três comprimentos dos lados, o raio de arredondamento e o número de segmentos

      Returns Promise<JSCADEntity>

      O sólido da caixa arredondada

      const soft = await bitbybit.jscad.shapes.roundedCuboid({ center: [0, 0, 0], width: 10, height: 5, length: 20, roundRadius: 1, segments: 16 });

    • Constrói um cilindro de pé ao longo de Z cujos dois bordos são arredondados por roundRadius, com height repartida igualmente acima e abaixo de center.

      height tem de ser mais do dobro de roundRadius ou é lançado um erro.

      Parameters

      • inputs: RoundedCylidnerDto

        O centro, o raio de arredondamento, a altura, o raio e o número de segmentos

      Returns Promise<JSCADEntity>

      O sólido do cilindro arredondado

      const pill = await bitbybit.jscad.shapes.roundedCylinder({ center: [0, 0, 0], roundRadius: 1, height: 10, radius: 3, segments: 32 });

    • Constrói uma esfera com o radius dado centrada em center; segments é o número de facetas à sua volta, por isso mais torna-a mais redonda.

      Parameters

      Returns Promise<JSCADEntity>

      O sólido da esfera

      const ball = await bitbybit.jscad.shapes.sphere({ center: [0, 0, 0], radius: 5, segments: 32 });

    • Constrói um toro, um anel com secção transversal redonda, deitado plano no plano XY em torno de center com Z a atravessar o seu furo.

      outerRadius é a distância do centro ao meio do tubo e innerRadius o raio próprio do tubo, que tem de ser menor. As rotações e startAngle estão em graus; uma outerRotation abaixo de 360 deixa o anel aberto.

      Parameters

      • inputs: Bit.Inputs.JSCAD.TorusDto

        O centro, os dois raios, os dois números de segmentos, as duas rotações e o ângulo inicial

      Returns Promise<JSCADEntity>

      O sólido do toro

      const ring = await bitbybit.jscad.shapes.torus({ center: [0, 0, 0], innerRadius: 1, outerRadius: 5, innerSegments: 16, outerSegments: 48, innerRotation: 0, outerRotation: 360, startAngle: 0 });

    primitives on centers

    • Constrói um cubo com comprimento de aresta size em cada ponto de centers, pela mesma ordem.

      Parameters

      Returns Promise<JSCADEntity[]>

      Um cubo por ponto central

      const cubes = await bitbybit.jscad.shapes.cubesOnCenterPoints({ centers: [[0, 0, 0], [20, 0, 0], [40, 0, 0]], size: 10 });

    • Constrói uma caixa com os width, height e length dados em cada ponto de centers, pela mesma ordem.

      Parameters

      Returns Promise<JSCADEntity[]>

      Uma caixa por ponto central

      const boxes = await bitbybit.jscad.shapes.cuboidsOnCenterPoints({ centers: [[0, 0, 0], [20, 0, 0]], width: 10, height: 5, length: 20 });

    • Constrói um cilindro elíptico com os raios e a altura dados em cada ponto de centers, pela mesma ordem, tal como cylinderElliptic faz para um.

      Parameters

      Returns Promise<JSCADEntity[]>

      Um cilindro elíptico por ponto central

      const cones = await bitbybit.jscad.shapes.cylinderEllipticOnCenterPoints({ centers: [[0, 0, 0], [20, 0, 0]], height: 10, startRadius: [4, 2], endRadius: [1, 0.5], segments: 32 });

    • Constrói um cilindro com o radius e a height dados em cada ponto de centers, pela mesma ordem, tal como cylinder faz para um.

      Parameters

      Returns Promise<JSCADEntity[]>

      Um cilindro por ponto central

      const posts = await bitbybit.jscad.shapes.cylindersOnCenterPoints({ centers: [[0, 0, 0], [20, 0, 0], [40, 0, 0]], height: 10, radius: 1, segments: 16 });

    • Constrói um elipsoide com os raios dados em cada ponto de centers, pela mesma ordem, tal como ellipsoid faz para um.

      Parameters

      Returns Promise<JSCADEntity[]>

      Um elipsoide por ponto central

      const eggs = await bitbybit.jscad.shapes.ellipsoidsOnCenterPoints({ centers: [[0, 0, 0], [20, 0, 0]], radius: [5, 3, 8], segments: 32 });

    • Constrói uma esfera geodésica com o radius dado em cada ponto de centers, pela mesma ordem, tal como geodesicSphere faz para uma.

      Parameters

      Returns Promise<JSCADEntity[]>

      Uma esfera geodésica por ponto central

      const domes = await bitbybit.jscad.shapes.geodesicSpheresOnCenterPoints({ centers: [[0, 0, 0], [20, 0, 0]], radius: 5, frequency: 12 });

    • Constrói uma caixa arredondada com os lados e o arredondamento dados em cada ponto de centers, pela mesma ordem, tal como roundedCuboid faz para uma.

      Parameters

      • inputs: RoundedCuboidCentersDto

        Os pontos centrais, os três comprimentos dos lados, o raio de arredondamento e o número de segmentos

      Returns Promise<JSCADEntity[]>

      Uma caixa arredondada por ponto central

      const softBoxes = await bitbybit.jscad.shapes.roundedCuboidsOnCenterPoints({ centers: [[0, 0, 0], [20, 0, 0]], width: 10, height: 5, length: 20, roundRadius: 1, segments: 16 });

    • Constrói um cilindro arredondado com o tamanho e o arredondamento dados em cada ponto de centers, pela mesma ordem, tal como roundedCylinder faz para um.

      Parameters

      Returns Promise<JSCADEntity[]>

      Um cilindro arredondado por ponto central

      const pills = await bitbybit.jscad.shapes.roundedCylindersOnCenterPoints({ centers: [[0, 0, 0], [20, 0, 0]], roundRadius: 1, height: 10, radius: 3, segments: 32 });

    • Constrói uma esfera com o radius dado em cada ponto de centers, pela mesma ordem, tal como sphere faz para uma.

      Parameters

      Returns Promise<JSCADEntity[]>

      Uma esfera por ponto central

      const balls = await bitbybit.jscad.shapes.spheresOnCenterPoints({ centers: [[0, 0, 0], [20, 0, 0], [40, 0, 0]], radius: 5, segments: 32 });

    shapes

    • Constrói um sólido a partir das suas faces, cada uma dada como uma lista de pontos que dão a volta à face.

      Liste os pontos de cada face no sentido horário vistos de fora do sólido; as faces têm de fechar o sólido para que as operações booleanas funcionem nele. Cada lista é lida por ordem inversa e a entrada não é alterada.

      Parameters

      Returns Promise<JSCADEntity>

      O sólido

      const tetrahedron = await bitbybit.jscad.shapes.fromPolygonPoints({ polygonPoints: [
          [[0, 0, 0], [10, 0, 0], [0, 10, 0]],
          [[0, 0, 0], [0, 10, 0], [0, 0, 10]],
          [[0, 0, 0], [0, 0, 10], [10, 0, 0]],
          [[10, 0, 0], [0, 0, 10], [0, 10, 0]],
      ] });

    Settings

    Member Visibility

    On This Page

    Constructors
    primitives
    primitives on centers
    shapes