Script: Example in TypeScript

type TopoDSShapePointer = Bit.Inputs.OCCT.TopoDSShapePointer;

start();

async function start() {
    const hexRadius = 20;
    const innerSideLength = 1.5;
    const nrHexagonsX = 6;
    const nrHexagonsY = 7;
    const cornerFilletRadiusForBase = 0.6;

    createLightsAndAdjustCamera();

    const trianglePoints = createTrianglePoints(hexRadius);
    const baseFlatTriangle = await baseSetupForHexagonTriangleShape(trianglePoints);
    const hexGrid = makeHexGrid(nrHexagonsX, nrHexagonsY, hexRadius);

    const linesForIntersection = verticalLinesForIntersection(hexGrid);
    const nurbsSurface = createNurbsSurfaceForHexGridProjections(hexGrid, nrHexagonsY);
    const pointsOnSurface = findIntersectionsOnSurface(linesForIntersection, nurbsSurface);

    const pointsAboveSurface = bitbybit.point.transformPoints({
        points: pointsOnSurface,
        transformation: bitbybit.babylon.transforms.translationXYZ({ translation: [0, 15, 0] })
    });

    const columns = bitbybit.line.linesBetweenStartAndEndPoints({
        startPoints: hexGrid,
        endPoints: pointsAboveSurface
    });

    const bulbBox = await bitbybit.occt.shapes.solid.createBox({ width: 1, length: 1, height: 4, center: [0, 0, 0] });

    const loftSolid = await createLoftSolid(trianglePoints[1], trianglePoints[2]);
    const innerVoidSolid = await createSolidForDifference(-innerSideLength, baseFlatTriangle);
    const baseTriangleSolid = await findDifferenceAndFilletResult(loftSolid, innerVoidSolid, cornerFilletRadiusForBase);
    const chamferedGlassSolid = await createChamferGlassSolid(baseTriangleSolid);

    const hexagonsBase = await rotateTriangles(baseTriangleSolid, 0, 300, 60);
    const hexagonsGlass = await rotateTriangles(chamferedGlassSolid, 0, 300, 60);

    const ground = await bitbybit.occt.transforms.translate({
        shape: await bitbybit.occt.shapes.solid.createBox({ width: 500, length: 500, height: 1, center: [0, 0, 0] }),
        translation: [125, 0, 125]
    })

    drawEverything(hexagonsBase, hexagonsGlass, bulbBox, ground, pointsOnSurface, pointsAboveSurface, columns);
}

function createLightsAndAdjustCamera() {
    bitbybit.babylon.scene.adjustActiveArcRotateCamera({ position: [250, 170, 250], lookAt: [0, 0, 0], maxZ: 1000, wheelPrecision: 3, panningSensibility: 100 });
    const lightOpts = { diffuse: '#ff99ff', specular: '#ffffff', radius: 0.5, intensity: 60000 };
    bitbybit.babylon.scene.drawPointLight({ position: [200, 130, 200], ...lightOpts });
    bitbybit.babylon.scene.drawPointLight({ position: [0, 160, 0], ...lightOpts });
    bitbybit.babylon.scene.drawPointLight({ position: [200, 130, 200], ...lightOpts });
}

async function baseSetupForHexagonTriangleShape(trianglePoints: Bit.Inputs.Base.Point3[]): Promise<TopoDSShapePointer> {
    return await bitbybit.occt.shapes.wire.createPolygonWire({ points: trianglePoints });
}

function createTrianglePoints(length: number): Bit.Inputs.Base.Point3[] {
    const lineOrient = bitbybit.line.create({ start: [0, 0, 0], end: [0, 0, length] });
    const point1 = [0, 0, 0] as Bit.Inputs.Base.Point3;
    const point2 = bitbybit.line.getEndPoint({
        line: bitbybit.line.transformLine({
            line: lineOrient,
            transformation: bitbybit.babylon.transforms.rotationCenterY({ center: [0, 0, 0], angle: 59.99 })
        })
    });
    const point3 = bitbybit.line.getEndPoint({
        line: bitbybit.line.transformLine({
            line: lineOrient,
            transformation: bitbybit.babylon.transforms.rotationCenterY({ center: [0, 0, 0], angle: 0.01 })
        })
    });
    return [point1, point2, point3];
}

function makeHexGrid(nrHexagonsX: number, nrHexagonsY: number, radiusHexagon: number) {
    return bitbybit.point.transformPoints({
        points: bitbybit.point.hexGrid({ nrHexagonsX, nrHexagonsY, radiusHexagon }),
        transformation: bitbybit.babylon.transforms.rotationCenterX({ angle: 90, center: [0, 0, 0] })
    });
}

function verticalLinesForIntersection(hexGrid: Bit.Inputs.Base.Point3[]) {
    return bitbybit.line.linesBetweenStartAndEndPoints({
        startPoints: hexGrid,
        endPoints: bitbybit.point.transformPoints({
            points: hexGrid,
            transformation: bitbybit.babylon.transforms.translationXYZ({ translation: [0, 200, 0] })
        })
    });
}

function createNurbsSurfaceForHexGridProjections(hexGridPoints: Bit.Inputs.Base.Point3[], nrHexagonsY: number) {
    const surface = bitbybit.verb.surface.createSurfaceByCorners({
        point1: bitbybit.point.transformPoint({
            point: hexGridPoints[0], transformation: bitbybit.babylon.transforms.translationXYZ({ translation: [0, 100, 0] }),
        }),
        point2: bitbybit.point.transformPoint({
            point: hexGridPoints[nrHexagonsY - 1], transformation: bitbybit.babylon.transforms.translationXYZ({ translation: [0, 50, 0] }),
        }),
        point3: bitbybit.point.transformPoint({
            point: hexGridPoints[hexGridPoints.length - 1], transformation: bitbybit.babylon.transforms.translationXYZ({ translation: [0, 90, 0] }),
        }),
        point4: bitbybit.point.transformPoint({
            point: hexGridPoints[hexGridPoints.length - nrHexagonsY], transformation: bitbybit.babylon.transforms.translationXYZ({ translation: [0, 40, 0] }),
        }),
    });
    return bitbybit.verb.surface.transformSurface({
        surface,
        transformation: [
            bitbybit.babylon.transforms.scaleXYZ({ scaleXyz: [1.5, 1, 1.5] }),
            bitbybit.babylon.transforms.translationXYZ({ translation: [-20, 0, -20] })
        ]
    })
}

function findIntersectionsOnSurface(linesForIntersection: Bit.Inputs.Line.LinePointsDto[], surface: number): Bit.Inputs.Base.Point3[] {
    return linesForIntersection.map(line => {
        const curve = bitbybit.line.convertToNurbsCurve({ line });
        const intersection = bitbybit.verb.intersect.curveAndSurface({ curve, surface });
        let result;
        if (intersection.length > 0) {
            result = intersection[0].curvePoint;
        } else {
            result = line.start;
        }
        return result;
    })
}

async function createLoftSolid(point2: number[], point3: number[]): Promise<TopoDSShapePointer> {
    const heightOfHexagon = 14;
    const tiltedBottomTriangleWire = await bitbybit.occt.shapes.wire.createPolygonWire({
        points: [
            [0, 5, 0],
            [point2[0], 0, point2[2]],
            [point3[0], 0, point3[2]],
        ]
    });
    const tiltedTopTriangleWire = await bitbybit.occt.shapes.wire.createPolygonWire({
        points: [
            [0, 10, 0],
            [point2[0], heightOfHexagon, point2[2]],
            [point3[0], heightOfHexagon, point3[2]],
        ]
    });
    return await bitbybit.occt.operations.loft({ shapes: [tiltedBottomTriangleWire, tiltedTopTriangleWire], makeSolid: true });
}

async function createSolidForDifference(offset: number, baseTriangle: TopoDSShapePointer): Promise<TopoDSShapePointer> {
    const offTriangleWire = await bitbybit.occt.operations.offset({ shape: baseTriangle, distance: offset, tolerance: 0.00001 });
    const offTraingleFace = await bitbybit.occt.shapes.face.createFaceFromWire({ shape: offTriangleWire, planar: true });
    return await bitbybit.occt.operations.extrude({ shape: offTraingleFace, direction: [0, 50, 0] });
}

async function findDifferenceAndFilletResult(outerSolid, innerSolid, radius): Promise<TopoDSShapePointer> {
    const hollowSolid = await bitbybit.occt.booleans.difference({ shape: outerSolid, shapes: [innerSolid], keepEdges: true });
    return await bitbybit.occt.fillets.filletEdges({ shape: hollowSolid, radius, indexes: undefined });
}

async function createChamferGlassSolid(baseTriangleSolid: TopoDSShapePointer): Promise<TopoDSShapePointer> {
    const edgeIndexesToChamfer = [15, 12, 3];
    const faceIndexForWire = 14;
    const chamferDist = 0.5;
    const wireOfFilletShape = await bitbybit.occt.shapes.wire.getWire({ shape: baseTriangleSolid, index: faceIndexForWire });
    const faceOfTheWire = await bitbybit.occt.shapes.face.createFaceFromWire({ shape: wireOfFilletShape, planar: true });
    const extruded = await bitbybit.occt.operations.extrude({ shape: faceOfTheWire, direction: [0, 1, 0] });
    return await bitbybit.occt.fillets.chamferEdges({ shape: extruded, distance: chamferDist, indexes: edgeIndexesToChamfer });
}

async function rotateTriangles(shape: TopoDSShapePointer, angleFrom: number, angleTo: number, angleStep: number): Promise<TopoDSShapePointer[]> {
    let result = [];
    for (let angle = angleFrom; angle <= angleTo; angle += angleStep) {
        const rotated = await bitbybit.occt.transforms.rotate({
            shape,
            axis: [0, 1, 0],
            angle
        });
        result.push(rotated);
    }
    return result;
}

async function drawEverything(
    hexagonsBase: Bit.Inputs.OCCT.TopoDSShapePointer[],
    hexagonsGlass: Bit.Inputs.OCCT.TopoDSShapePointer[],
    bulbBox: Bit.Inputs.OCCT.TopoDSShapePointer,
    ground: Bit.Inputs.OCCT.TopoDSShapePointer,
    pointsOnHexagonSurface: Bit.Inputs.Base.Point3[],
    pointsAboveSurface: Bit.Inputs.Base.Point3[],
    columns,
): Promise<void> {

    const whiteColour = '#ffffff';
    const violetColour = '#993399';
    const goldColour = '#ffcc33';
    const blueColour = '#3366ff';
    const blackColour = '#000000';

    const lineDrawOptions = new Bit.Inputs.Line.DrawLinesDto(columns);
    lineDrawOptions.size = 50;
    lineDrawOptions.opacity = 0.5;
    lineDrawOptions.colours = whiteColour;
    bitbybit.line.drawLines(lineDrawOptions);

    const hexagonsBaseInPosition = await Promise.all(hexagonsBase.map(hexagonBase => {
        return bitbybit.occt.transforms.translate({
            shape: hexagonBase,
            translation: pointsOnHexagonSurface[0],
        })
    }));

    const hexagonsGlassInPosition = await Promise.all(hexagonsGlass.map(hexagonGlass => {
        return bitbybit.occt.transforms.translate({
            shape: hexagonGlass,
            translation: pointsOnHexagonSurface[0],
        })
    }));

    const drawingOptions = new Bit.Inputs.Draw.DrawOcctShapeOptions();
    drawingOptions.precision = 1;

    drawingOptions.faceColour = violetColour;
    drawingOptions.edgeColour = whiteColour;
    drawingOptions.edgeWidth = 5;
    await bitbybit.draw.drawAny({ entity: hexagonsBaseInPosition[0], options: drawingOptions });

    drawingOptions.faceColour = goldColour;
    drawingOptions.faceOpacity = 0.3;
    drawingOptions.drawEdgeIndexes = true;
    drawingOptions.edgeIndexHeight = 0.15;
    drawingOptions.edgeWidth = 3;
    drawingOptions.edgeIndexColour = whiteColour;

    await bitbybit.draw.drawAnyAsync({ entity: hexagonsGlassInPosition[0], options: drawingOptions });

    const fiveTriangleBasesOnFirsHexagon = await bitbybit.occt.shapes.compound.makeCompound({ shapes: hexagonsBaseInPosition.filter((_, index) => index !== 0) });

    drawingOptions.faceColour = violetColour;
    drawingOptions.faceOpacity = 0.2;
    drawingOptions.drawEdgeIndexes = false;
    drawingOptions.edgeWidth = 3;
    drawingOptions.edgeOpacity = 0.6;

    await bitbybit.draw.drawAnyAsync({ entity: fiveTriangleBasesOnFirsHexagon, options: drawingOptions });

    const compoundRemainderBases = await bitbybit.occt.shapes.compound.makeCompound({ shapes: hexagonsBase });
    const compoundRemainderGlasses = await bitbybit.occt.shapes.compound.makeCompound({ shapes: hexagonsGlass });

    drawingOptions.precision = 40;
    drawingOptions.drawEdges = false;
    drawingOptions.faceColour = blueColour;
    drawingOptions.faceOpacity = 1;

    const meshBase = await bitbybit.draw.drawAnyAsync({ entity: compoundRemainderBases, options: drawingOptions });

    drawingOptions.faceColour = goldColour;
    drawingOptions.faceOpacity = 0.3;

    const meshGlass = await bitbybit.draw.drawAnyAsync({ entity: compoundRemainderGlasses, options: drawingOptions });

    const pointsOnWhichToDrawRemainder = pointsOnHexagonSurface.filter((_, index) => index !== 0);
    pointsOnWhichToDrawRemainder.forEach(point => {
        bitbybit.babylon.mesh.createMeshInstanceAndTransform({
            mesh: meshBase,
            position: point,
            rotation: [0, 0, 0],
            scaling: [1, 1, 1],
        });
        bitbybit.babylon.mesh.createMeshInstanceAndTransform({
            mesh: meshGlass,
            position: point,
            rotation: [0, 0, 0],
            scaling: [1, 1, 1],
        });
    });

    const boxDrawOptions = new Bit.Inputs.Draw.DrawOcctShapeOptions();
    boxDrawOptions.drawEdges = false;
    boxDrawOptions.faceColour = whiteColour;
    const meshBulbBox = await bitbybit.draw.drawAnyAsync({ entity: bulbBox, options: boxDrawOptions });
    pointsAboveSurface.forEach(point => {
        bitbybit.babylon.mesh.createMeshInstanceAndTransform({
            mesh: meshBulbBox,
            position: point,
            rotation: [0, 0, 0],
            scaling: [1, 1, 1],
        })
    });

    const groundDrawOptions = new Bit.Inputs.Draw.DrawOcctShapeOptions();
    groundDrawOptions.drawEdges = false;
    groundDrawOptions.faceOpacity = 0.99;
    groundDrawOptions.faceColour = blackColour;
    await bitbybit.draw.drawAnyAsync({ entity: ground, options: groundDrawOptions });
}