newdoc.png

QA - node-summary

## BeeGraphy Editor Dimensions Package
Dimension nodes for the BeeGraphy Editor. This package provides tools to measure and render dimension graphics (with labels and arrows) directly in the editor viewport.
### Usage
The nodes in this package help you visualize measurements (e.g., distances, angles, bounding boxes) between points and geometry. You can find them under the **Dimensions** group in the node palette or via search.
### Available Nodes
#### 1. Distance Dimension
Measures the distance between two 3D points and renders a labeled dimension graphic (extension lines, main line, optional arrows, and a text label).
* **Inputs:** `start`, `end`, `direction` (optional), `labelOffset` (0.2), `decimalPlaces` (2), `labelSuffix` ("mm"), `labelOverwrite`, `style`.
* **Outputs:** `curve` (ThreeCurve), `distance` (Number).
#### 2. Angular Dimension
Measures and visualizes the angle defined by a center point and two direction vectors. Draws an arc, arrowheads, and a text label.
* **Inputs:** `centerPoint`, `direction1`, `direction2`, `radius` (0.5), `labelOffset` (0.1), `decimalPlaces` (1), `labelSuffix` ("°"), `labelOverwrite`, `radians` (false), `style`.
* **Outputs:** `curve` (ThreeCurve), `angle` (Number).
#### 3. Radial Dimension
Measures radius or diameter from a center point to a radius point. Displays value with leader line, arrowhead, and optional center mark.
* **Inputs:** `centerPoint`, `radiusPoint`, `labelOffset` (0.2), `decimalPlaces` (2), `labelSuffix` ("mm"), `labelOverwrite`, `showDiameter` (false), `showCenterMark` (true), `style`.
* **Outputs:** `curve` (ThreeCurve), `radius`, `diameter`.
#### 4. Diametrical Dimension
Measures and visualizes a diameter with a specified direction. Draws diameter line with optional arrowheads and center mark.
* **Inputs:** `centerPoint`, `direction`, `diameter`, `labelOffset` (0.2), `decimalPlaces` (2), `labelSuffix` ("mm"), `labelOverwrite`, `showCenterMark` (true), `style`.
* **Outputs:** `curve` (ThreeCurve), `diameter`, `radius`.
#### 5. Dimension 2D
Measures and visualizes 2D bounding box dimensions of geometry. Shows width (X), height (Y), and optional diagonal.
* **Inputs:** `geometry`, `showWidth`, `showHeight`, `showDiagonal`, `labelOffset` (0.2), `decimalPlaces` (2), `labelSuffix` ("mm"), `labelOverwriteX/Y/Diag`, `style`.
* **Outputs:** `curve` (ThreeCurve), `width`, `height`, `diagonal`, `minPoint`, `maxPoint`.
#### 6. Dimension 3D
Measures and visualizes 3D bounding box dimensions of geometry. Shows width (X), length (Y), height (Z), and optional diagonal.
* **Inputs:** `geometry`, `showWidth`, `showLength`, `showHeight`, `showDiagonal`, `labelOffset` (0.2), `decimalPlaces` (2), `labelSuffix` ("mm"), `labelOverwriteX/Y/Z/Diag`, `style`.
* **Outputs:** `curve` (ThreeCurve), `width`, `length`, `height`, `diagonal`.
#### 7. Dimension Style
Produces a reusable style object to control the appearance of dimension graphics.
* **Inputs:** `lineColor`, `lineThickness` (0.01), `extensionLineLength` (0.1), `arrowTailLength` (0.2), `textColor`, `textSize` (16), `textBackgroundColor` (#000000), `textBackgroundOpacity` (0.9), `arrowSize` (0.05), `showArrows` (true).
* **Output:** `style` (Meta).
### Notes:
* **Distance Dimension** will automatically compute a perpendicular direction if `direction` is not provided.
* Label text can be fully overridden via `labelOverwrite`; include `{val}` to embed the computed value.

plugin-example 11

<h3 style="text-align: left">What is Lorem Ipsum?</h3>Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.<h3 style="text-align: left">Why do we use it?</h3>It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using 'Content here, content here', making it look like readable English. Many desktop publishing packages and web page editors now use Lorem Ipsum as their default model text, and a search for 'lorem ipsum' will uncover many web sites still in their infancy. Various versions have evolved over the years, sometimes by accident, sometimes on purpose (injected humour and the like).

pumpkin_5842596.png

strawberry_6802423.png

cute-animals-svgrepo-com.svg

elk-svgrepo-com.svg

Test-plugin Test-plugin

<h2>BeeGraphy Editor Manufacturing Machines Package</h2>This package contains manufacturing machine nodes designed for use in the BeeGraphy Editor, providing tools for assigning and managing manufacturing machines within production workflows.<h3>Usage</h3>The nodes in this package are used to define, configure, and apply manufacturing machines to models and operations. These nodes can be found in the Manufacturing → Machines group in the menu or via the search engine.<h3>Machine Node Types</h3>The package provides various machine nodes that represent different types of manufacturing equipment and calculate processing parameters based on machine capabilities and input geometry.Each machine node type is designed to work with specific manufacturing operations and measurement values:

Screenshot 2025-12-19 at 10.00.18.png

Gemini_Generated_Image_w0rseqw0rseqw0rs.png

bulldozer.svg

Machine

delivery-man_1200115.png

Test

ddddd

BeeGraphy Editor Data Structure Package

This package provides essential data structure nodes for performing various operations on lists, sequences, sets, and trees within the BeeGraphy Editor. These nodes are categorized into groups, each tailored for specific data management and manipulation tasks.

Usage

The nodes in this package allow users to work with different data structures, including lists, sequences, sets, and trees. Typical operations include measuring lengths, manipulating items, organizing hierarchical data, and performing complex data transformations.

To locate these nodes, look under the corresponding group in the menu, or use the search functionality.

Node Groups

List Group

The List group provides nodes for working with ordered collections of items. These nodes enable you to manipulate list elements by adding, removing, inserting, and extracting items at specific positions. You can measure list lengths, sort items, reverse lists, partition lists into subsets, and perform various filtering and transformation operations. List nodes are essential for managing collections of data where order matters and items can be accessed by their position.

Sequence Group

The Sequence group contains nodes for generating and managing ordered data sequences. These nodes help you create numerical sequences, generate patterns, and perform sequence-specific operations such as remapping values, finding bounds, and creating sequences with specific growth patterns. Sequence nodes are useful for generating ordered data, creating mathematical progressions, and working with numerical ranges.

Set Group

The Set group offers nodes for handling collections of unique items and performing set operations. These nodes allow you to merge sets, find intersections and differences between sets, remove duplicates, and manipulate set membership. Set nodes are ideal for working with data where uniqueness is important and for performing mathematical set operations like union, intersection, and difference.

Tree Group

The Tree group provides nodes designed for hierarchical data organization and tree structure manipulation. These nodes enable you to construct and deconstruct tree paths, flatten and unflatten tree structures, graft and prune branches, filter tree data, and perform various tree transformations. Tree nodes are essential for working with hierarchical data structures, managing nested data, and organizing complex relationships between data elements.

Each group provides specialized nodes to simplify complex data handling, making it easier to create dynamic and organized data structures in the BeeGraphy Editor.

List.png

List Light.png

List

BeeGraphy Editor Material Package

This package contains material nodes designed for use in the BeeGraphy Editor, providing tools for assigning materials and colors to models and curves.

Usage

The nodes in this package are used to apply materials and textures to models, allowing for enhanced visual representation. These nodes can be found in the Texture group in the menu or via the search engine.

Material Node Categories

General Material Nodes

General material nodes provide fundamental functionality for applying materials to geometry. These nodes allow you to assign materials and textures to models or curves, enabling customization of visual appearance. They serve as the primary interface for connecting materials to your designs and managing material assignments throughout your workflow.

Material Type Nodes

Material type nodes represent different categories of materials based on their physical properties and manufacturing characteristics. These nodes include linear materials for elongated elements, sheet materials for flat surfaces, volumetric materials for three-dimensional objects, weight-based materials, count-based materials, and various profile materials such as beams, bars, and tubes with different cross-sectional shapes. Each material type node is designed to work with specific geometric properties and manufacturing requirements.

Material Factory Nodes

Material factory nodes provide tools for creating and configuring materials programmatically. These nodes enable you to generate material definitions with specific properties, parameters, and characteristics. Factory nodes are useful for creating custom materials, setting up material libraries, and automating material creation processes in your workflows.

Material Deconstruction Nodes

Material deconstruction nodes allow you to extract and analyze material properties from existing materials or geometry. These nodes enable you to break down material information into its constituent parts, retrieve material parameters, and access material data for further processing or analysis. Deconstruction nodes are valuable for inspecting materials, transferring material properties, and creating workflows that depend on material information.

Each category of material nodes serves a specific purpose in the material management workflow, from creation and configuration to application and analysis, helping you create visually rich and properly materialized designs in the BeeGraphy Editor.

Materials.png

Materials Light.png

Material

3488782.png

12.svg

QA - hello world2

QA - Test New Doc

## BeeGraphy Editor Dimensions Package

Dimension nodes for the BeeGraphy Editor. This package provides tools to measure and render dimension graphics (with labels and arrows) directly in the editor viewport.

### Usage

The nodes in this package help you visualize measurements (e.g., distances, angles, bounding boxes) between points and geometry. You can find them under the **Dimensions** group in the node palette or via search.

### Available Nodes

#### 1. Distance Dimension
Measures the distance between two 3D points and renders a labeled dimension graphic (extension lines, main line, optional arrows, and a text label).

* **Inputs:** `start`, `end`, `direction` (optional), `labelOffset` (0.2), `decimalPlaces` (2), `labelSuffix` ("mm"), `labelOverwrite`, `style`.
* **Outputs:** `curve` (ThreeCurve), `distance` (Number).

#### 2. Angular Dimension
Measures and visualizes the angle defined by a center point and two direction vectors. Draws an arc, arrowheads, and a text label.

* **Inputs:** `centerPoint`, `direction1`, `direction2`, `radius` (0.5), `labelOffset` (0.1), `decimalPlaces` (1), `labelSuffix` ("°"), `labelOverwrite`, `radians` (false), `style`.
* **Outputs:** `curve` (ThreeCurve), `angle` (Number).

#### 3. Radial Dimension
Measures radius or diameter from a center point to a radius point. Displays value with leader line, arrowhead, and optional center mark.

* **Inputs:** `centerPoint`, `radiusPoint`, `labelOffset` (0.2), `decimalPlaces` (2), `labelSuffix` ("mm"), `labelOverwrite`, `showDiameter` (false), `showCenterMark` (true), `style`.
* **Outputs:** `curve` (ThreeCurve), `radius`, `diameter`.

#### 4. Diametrical Dimension
Measures and visualizes a diameter with a specified direction. Draws diameter line with optional arrowheads and center mark.

* **Inputs:** `centerPoint`, `direction`, `diameter`, `labelOffset` (0.2), `decimalPlaces` (2), `labelSuffix` ("mm"), `labelOverwrite`, `showCenterMark` (true), `style`.
* **Outputs:** `curve` (ThreeCurve), `diameter`, `radius`.

#### 5. Dimension 2D
Measures and visualizes 2D bounding box dimensions of geometry. Shows width (X), height (Y), and optional diagonal.

* **Inputs:** `geometry`, `showWidth`, `showHeight`, `showDiagonal`, `labelOffset` (0.2), `decimalPlaces` (2), `labelSuffix` ("mm"), `labelOverwriteX/Y/Diag`, `style`.
* **Outputs:** `curve` (ThreeCurve), `width`, `height`, `diagonal`, `minPoint`, `maxPoint`.

#### 6. Dimension 3D
Measures and visualizes 3D bounding box dimensions of geometry. Shows width (X), length (Y), height (Z), and optional diagonal.

* **Inputs:** `geometry`, `showWidth`, `showLength`, `showHeight`, `showDiagonal`, `labelOffset` (0.2), `decimalPlaces` (2), `labelSuffix` ("mm"), `labelOverwriteX/Y/Z/Diag`, `style`.
* **Outputs:** `curve` (ThreeCurve), `width`, `length`, `height`, `diagonal`.

#### 7. Dimension Style
Produces a reusable style object to control the appearance of dimension graphics.

* **Inputs:** `lineColor`, `lineThickness` (0.01), `extensionLineLength` (0.1), `arrowTailLength` (0.2), `textColor`, `textSize` (16), `textBackgroundColor` (#000000), `textBackgroundOpacity` (0.9), `arrowSize` (0.05), `showArrows` (true).
* **Output:** `style` (Meta).

### Notes:

* **Distance Dimension** will automatically compute a perpendicular direction if `direction` is not provided.
* Label text can be fully overridden via `labelOverwrite`; include `{val}` to embed the computed value.

Package manager page.png

Package manager page light.png

Package manager page.svg

Package manager page light.svg

Dimension

BeeGraphy OpenCascade Library This library provides a TypeScript wrapper and interface for OpenCascade.js, enabling geometric modeling operations in the BeeGraphy Editor. It serves as the core geometric computation engine, providing access to OpenCascade CAD kernel functionality through a web-based interface. Overview The library wraps the OpenCascade.js WebAssembly module and provides high-level abstractions for working with geometric entities. It includes proxy classes for geometric types, builder patterns for creating geometry, utility functions for geometric operations, and worker-based execution for performance optimization. Key Components Geometric Type Proxies The library provides proxy classes that wrap OpenCascade geometric types, enabling type-safe operations on geometric entities. These proxies include vector representations for points and directions, plane definitions for coordinate systems, curve representations for one-dimensional geometry, surface representations for two-dimensional geometry, and solid representations for three-dimensional volumetric objects. These proxies abstract the underlying OpenCascade API and provide a more convenient interface for geometric operations. Builder Classes Builder classes provide programmatic interfaces for constructing geometric entities. These builders enable you to create curves, surfaces, solids, and fonts through a fluent API. Builder classes handle the complexity of OpenCascade object construction and provide validation and error handling for geometric creation operations. Initialization The library requires initialization before use. The initialization process loads the OpenCascade WebAssembly module and sets up the worker environment. Once initialized, the library provides access to all geometric operations and builder classes. Integration This library is designed to integrate with the BeeGraphy Editor node engine system. It registers geometric type instances with the engine type system, enabling seamless interoperability between the editor's node system and OpenCascade geometric operations. The library serves as the foundation for geometric modeling nodes in the BeeGraphy Editor.

test-plugin

test սգկգքոդգհոեդի եոեհդոեդ

test Plugin 12

Three.js render nodes for the BeeGraphy Editor.

Three Render

BeeGraphy Editor Toolbox Plugin

This plugin provides hardware and joinery nodes for assembling furniture and cabinet designs within the BeeGraphy Editor.

## Usage

The nodes in this plugin are used to place, join, and machine standard hardware components — fasteners, hinges, connectors, slides, and brackets — onto 3D panel geometry. These nodes can be found in the **Toolbox** group in the menu or via the search engine.

## Capabilities

### Fasteners

Fastener nodes provide standard hardware items with their associated 3D geometry and machining operations. Supported fasteners include bolt and nut pairs (M4–M24), wooden and steel dowel pins, Euro screws, confirmats, tee nuts, and wood screws. Each node outputs the hardware item along with the pre-defined boring and drilling operations required for installation.

### Connectors and Hinges

Connector nodes provide knock-down fitting hardware for flat-pack assembly. The cam lock (Minifix-style) node outputs an eccentric connector with a pocket, through-hole, and cross-bore. The cup hinge node provides a 35 mm European-style hinge with all six associated machining operations for cup bore and mounting arm installation.

### Placement Nodes

Placement nodes handle positioning hardware onto panels and joining parts together:

- **PlaceHardware** — positions a hardware item at a specified world-space location and surface normal, applying boolean cuts to the host solid in real time.
- **JoinParts** — joins two panel solids using a hardware item by applying host and mating machining operations to each part respectively, outputting both assembled panels with operations baked in world coordinates.
- **AutoHinge** — automatically distributes N cup hinges on a door panel relative to a cabinet side using standard margin rules, applying cup bore operations to the door and mounting plate holes to the cabinet.
- **HardwareArray** — distributes a hardware item at regular intervals along a panel face.

### Slides and Rails

Slide nodes output drawer and linear rail hardware pairs from the toolbox library. The drawer slide node supports side-mount and under-mount configurations with a dynamic screw hole array. The linear rail node provides standard rail-and-carriage assemblies.

### Brackets

The corner bracket node provides a right-angle L-bracket for cabinet and carcass reinforcement with screw holes on both legs.

### Machining Visualizer

The MachiningVisualizer node renders machining operations as color-coded ghost overlays on a host solid, with optional dimension labels showing diameter and depth for each operation type. It is useful for inspecting and debugging the operations produced by other toolbox nodes before export.

Toolbox

# BAZON Furniture Manufacturing Plugin

This plugin provides a specialized suite of nodes for a node-based 3D modeling engine, designed specifically for **furniture manufacturing and CNC preparation**. It automates the transition from 3D geometry to machine-ready files (NC, BMP, and XML).

## 🛠 Nodes

### 1. Set Edge Banding
Assigns specific edge banding materials to the edges of a panel. This is a critical step for furniture manufacturing where different edges of a single part may require different finishes (e.g., PVC 0.4mm vs. 2mm).
*   **Inputs:** Edge geometries and material labels.
*   **Function:** Tags geometry with metadata labels that the exporter later uses to generate visual labels and machine instructions.

### 2. Merge Operations
A data aggregation node that combines all manufacturing attributes into a single part definition.
*   **Inputs:** Machine configurations, part geometry, drilling/milling operations (OpsGeom), and edge banding data.
*   **Function:** Syncs geometry with its associated machining operations and orientation, preparing it for the final export phase.

### 3. BAZON Exporter
The final stage of the pipeline. It processes the merged data to generate a complete manufacturing package.
*   **Outputs:** A `.zip` archive containing:
    *   **Milling (NC):** CNC programs for panel sizing and routing.
    *   **Edge Drilling (NC):** Instructions for horizontal/vertical boring.
    *   **Label Machine Files:** `.xml` and `.cyc` files for automated labeling.
    *   **Part Previews (BMP):** Visual labels for workshop staff, showing part dimensions, material, and hole positions.

## 🚀 Key Features
*   **Automatic NC Generation:** Supports Fanuc and other post-processors.
*   **Intelligent Labeling:** Generates bitmapped part previews including indicators for which edges are banded.
*   **Nesting Ready:** Integrates rotation data from nesting algorithms to ensure drilling remains accurate regardless of part orientation.
*   **Material Detection:** Automatically detects stock thickness to calculate Z-depths for CNC operations.

---
*Developed for industrial furniture production workflows.*

BAZON

Leaves0156_1_S.png

PlayboyLogo.svg.png

Math advanced

BeeGraphy Editor Nesting Plugin

This plugin provides nesting nodes designed for optimizing the arrangement of geometric objects on sheets or surfaces within the BeeGraphy Editor.

Usage

The nodes in this plugin are used to efficiently pack and arrange multiple geometric objects onto sheets or surfaces, minimizing waste and optimizing material usage. These nodes can be found in the Nesting group in the menu or via the search engine.

Nesting Capabilities

The plugin provides nesting algorithms that automatically arrange geometric objects to maximize space utilization. These nodes support various nesting strategies and algorithms designed for different use cases:

- Rectangular nesting nodes arrange geometric objects on rectangular sheets using guillotine-based algorithms. These nodes support different optimization approaches, including naive algorithms for quick results and genetic algorithms for more sophisticated optimization. Rectangular nesting nodes allow you to specify sheet dimensions, spacing between objects, edge clearances, and other parameters to control the nesting process.

Nesting nodes take collections of geometries as input and arrange them optimally on specified sheet sizes. The nodes provide information about the arrangement, including positions of nested objects, sheet usage statistics, and identification of which objects are placed on which sheets. These capabilities are essential for manufacturing workflows where material efficiency is critical, such as sheet metal cutting, fabric cutting, or any process that requires optimizing the layout of objects on material sheets.

nesting-dark.png

nesting-light.png

Nesting

BeeGraphy Editor Imaging Plugin

This plugin includes image manipulation nodes designed for use in the BeeGraphy Editor, enabling advanced image processing and analysis capabilities. These nodes are part of the BeeGraphy Editor engine and allow you to work with images, extract information, and perform various transformations.

Usage

The nodes in this plugin are responsible for processing, analyzing, and manipulating image data. They support a variety of image operations, allowing users to extract color information, analyze image properties, apply filters, and preview results.

To find these nodes, look under the Image group in the menu, or use the search engine.

Available Image Processing Capabilities

The plugin provides several types of image processing nodes, each designed for different image manipulation scenarios:

- Image sampling nodes extract color and coordinate information from images. They allow you to sample colors at specific points or across the entire image, providing coordinate data along with color values in various formats such as hexadecimal, intensity, hue, saturation, and brightness. These nodes are useful for converting image data into geometric coordinates or analyzing color distributions.

- UV-based sampling nodes work with UV coordinates to extract color information from images at specific points. They support domain mapping, tiling options, and bilinear interpolation, making them ideal for texture mapping and procedural workflows where you need to sample images based on geometric coordinates.

- Image dimension analysis nodes calculate and provide image properties such as width, height, and aspect ratio. These nodes are essential for understanding image dimensions and maintaining proper proportions in your workflows.

- Grayscale conversion nodes transform color images into grayscale versions. This conversion is useful for simplifying images, reducing color complexity, or preparing images for further processing that requires monochrome input.

- Edge detection nodes identify and highlight edges in images using convolution filters. These nodes are valuable for image analysis, pattern recognition, and creating stylized effects by emphasizing the boundaries between different regions in an image.

- Image preview nodes allow you to visualize images directly in the editor. They provide a convenient way to inspect image data at various stages of processing and verify the results of image manipulation operations.

Common Parameters and Features

Most image processing nodes share common concepts and capabilities:

- Image input: All nodes accept image data as input, which can come from various sources including file uploads, generated images, or outputs from other image processing nodes.

- Color extraction: Many nodes provide color information in multiple formats, including hexadecimal color codes, RGB values, intensity levels, and HSL (Hue, Saturation, Lightness) components.

- Coordinate systems: Sampling nodes work with different coordinate systems, from pixel-based coordinates to normalized UV coordinates, allowing flexible mapping between image space and geometric space.

- Interpolation: Advanced sampling nodes support bilinear interpolation, which provides smoother color sampling when working with fractional coordinates.

- Domain mapping: Some nodes allow you to define custom domains for coordinate mapping, enabling flexible remapping of image coordinates to different ranges.

- Preview capabilities: Several nodes include built-in preview functionality, allowing you to see the results of image processing operations directly in the editor interface.

Each node type may also have specialized parameters that are specific to its processing method, such as sampling gaps, scale factors, aspect ratio locking, and various filter settings.

image-sampler.png

image-sampler-light.png

Imaging

Lorem IpsumContrary to popular belief, Lorem Ipsum is not simply random text. It has roots in a piece of classical Latin literature from 45 BC, making it over 2000 years old. Richard McClintock, a Latin professor at Hampden-Sydney College in Virginia, looked up one of the more obscure Latin words, consectetur, from a Lorem Ipsum passage, and going through the cites of the word in classical literature, discovered the undoubtable source. Lorem Ipsum comes from sections 1.10.32 and 1.10.33 of "de Finibus Bonorum et Malorum" (The Extremes of Good and Evil) by Cicero, written in 45 BC. This book is a treatise on the theory of ethics, very popular during the Renaissance. The first line of Lorem Ipsum, "Lorem ipsum dolor sit amet..", comes from a line in section 1.10.32.The standard chunk of Lorem Ipsum used since the 1500s is reproduced below for those interested. Sections 1.10.32 and 1.10.33 from "de Finibus Bonorum et Malorum" by Cicero are also reproduced in their exact original form, accompanied by English versions from the 1914 translation by H. Rackham.

images (1).png

QA - testuploadzip

images (2).png

QA - lists


1. Վերնագրեր
Օգտագործվում է # նշանը։ Ինչքան շատ են վանդակաշարերը, այնքան փոքր է վերնագիրը։

# Վերնագիր 1

## Վերնագիր 2

### Վերնագիր 3

2. Տեքստի ոճավորում
Թավ (Bold): Օգտագործվում է երկու աստղանիշ՝ **տեքստ** -> տեքստ

Շեղ (Italic): Օգտագործվում է մեկ աստղանիշ՝ *տեքստ* -> տեքստ

~~Ջնջված~~: Օգտագործվում է երկու թիլդա՝ ~~տեքստ~~ -> ~~տեքստ~~

3. Ցուցակներ
Չհամարակալված: Օգտագործեք աստղանիշ * կամ գծիկ -:

Համարակալված: Պարզապես գրեք թվերը՝ 1., 2.:

4. Հղումներ և Նկարներ
Հղում: [Google](https://google.com)

Նկար: ![Նկարի անուն](URL)

cactus-svgrepo-com.svg

test

BeeGraphy Editor Tools Package

This package contains a comprehensive set of tool nodes designed to assist with various operations and analyses in the BeeGraphy Editor.

Usage

The nodes in this package are categorized into specialized groups to simplify design and modeling tasks. They enable users to create, manipulate, analyze, and transform models with precision. To locate these nodes, browse the corresponding groups in the menu or use the search functionality.

Node Groups

Surface Group

The Surface group provides nodes for creating and manipulating surfaces. These nodes enable you to generate freeform surfaces, analyze surface properties, apply surface transformations, create panel structures, perform surface boolean operations, and convert surfaces to triangulated meshes. Surface nodes are essential for working with complex surface geometry and creating smooth, continuous surfaces in your designs.

Vector Group

The Vector group contains nodes for vector operations and calculations. These nodes allow you to perform vector addition, subtraction, normalization, dot products, cross products, and various vector transformations. Vector nodes are fundamental for working with directions, positions, and spatial relationships in 3D space.

Transform Group

The Transform group provides tools for applying geometric transformations to objects. These nodes enable translation, rotation, scaling, and combined transformations. Transform nodes are essential for positioning, orienting, and resizing geometry in your designs.

Primitive Curves Group

The Primitive Curves group contains nodes for generating basic curve shapes. These nodes allow you to create fundamental curves such as lines, circles, arcs, splines, and other geometric primitives. Primitive curve nodes serve as building blocks for more complex curve-based designs.

Curve Analysis Group

The Curve Analysis group provides nodes for analyzing curve properties and characteristics. These nodes enable you to measure curve length, evaluate curvature, check continuity, extract points along curves, and analyze curve geometry. Curve analysis nodes are valuable for understanding and validating curve properties in your designs.

Curve Toolset Group

The Curve Toolset group offers utility nodes for curve manipulation and processing. These nodes provide tools for curve editing, trimming, extending, joining, and various curve operations that enhance curve-based workflows.

Curve Triangulation Group

The Curve Triangulation group contains nodes for converting curves into triangulated representations. These nodes enable you to create mesh representations of curves for rendering, analysis, or further processing.

Boolean Operation Group

The Boolean Operation group provides tools for performing Boolean operations on geometry. These nodes enable union, difference, and intersection operations on surfaces, solids, and regions. Boolean operation nodes are essential for combining, subtracting, and intersecting geometric objects to create complex shapes.

Solid Group

The Solid group contains nodes for creating and modifying solid geometry. These nodes enable you to generate primitive solids, create freeform solids, analyze solid properties, apply solid transformations, perform solid boolean operations, and convert solids to meshes. Solid nodes are fundamental for working with three-dimensional solid objects.

Intersection Group

The Intersection group provides tools for finding intersections between geometric entities. These nodes enable you to find intersections between curves, surfaces, solids, and other geometric objects. Intersection nodes are valuable for determining relationships between geometric elements.

Text Group

The Text group contains nodes for generating and manipulating text objects. These nodes enable you to create text geometry, apply text transformations, and work with typography in your designs. Text nodes are useful for adding labels, annotations, and text-based elements to your models.

Image Group

The Image group provides tools for processing and incorporating images into designs. These nodes enable you to work with image data, convert images to geometry, and use images as design references or textures.

Analysis Group

The Analysis group contains nodes for data and model analysis. These nodes enable geometric analysis, structural assessments, property calculations, and various analytical operations that help you understand and evaluate your designs.

Array Group

The Array group provides tools for creating arrays and repeating patterns. These nodes enable you to create linear arrays, rectangular arrays, polar arrays, and other pattern arrangements. Array nodes are useful for duplicating and arranging geometry in systematic patterns.

Toolset Group

The Toolset group offers general-purpose utility nodes for enhancing workflows. These nodes provide various helper functions, conversions, and utility operations that support and streamline design processes.

Triangulation Group

The Triangulation group contains nodes for converting geometry into triangular mesh representations. These nodes enable you to create mesh versions of surfaces and solids for rendering, analysis, or export purposes.

Each group provides specialized nodes tailored to specific tasks, streamlining complex design and modeling workflows in the BeeGraphy Editor.

Tools.png

Tools Light.png

Tool

images.png

1.svg

QA - hello second1452 inputdgfhgjfholgjfohjfgjfogjhofjoijgoihjfoijiogjbkljfjgfohjhogifjhoigjhjglkjhlkgjhlkfgjhkljgfl

BeeGraphy Editor Math Package

This package includes math nodes designed for performing various mathematical operations within the BeeGraphy Editor.

Usage

The nodes in this package are organized to handle a range of mathematical tasks, from basic arithmetic to trigonometry and constants. You can find these nodes under the Math group in the menu or by using the search engine.

Node Groups

Operators Group

The Operators group provides nodes for basic arithmetic operations and mathematical manipulations. These nodes enable you to perform fundamental calculations such as addition, subtraction, multiplication, and division. You can also work with powers, roots, rounding operations, absolute values, and comparisons. The group includes nodes for finding minimum and maximum values, performing modulo operations, and working with logical gates for boolean operations. Operators nodes are essential for performing basic mathematical computations and comparisons in your workflows.

Trigonometric Group

The Trigonometric group contains nodes for trigonometric functions and their inverse operations. These nodes allow you to calculate sine, cosine, and tangent values, as well as their hyperbolic variants. You can also compute inverse trigonometric functions to determine angles from ratios. Trigonometric nodes are useful for working with angles, rotations, periodic functions, and geometric calculations involving circles and waves.

Tools Group

The Tools group offers utility nodes for more complex calculations and mathematical transformations. These nodes provide logarithmic and exponential functions, angle conversions between degrees and radians, type conversions between numbers and strings, and specialized mathematical operations such as calculating averages and hypotenuses. Tools nodes are valuable for advanced mathematical operations, data type conversions, and performing specialized calculations that go beyond basic arithmetic.

Constants Group

The Constants group provides access to fundamental mathematical constants that are frequently used in calculations. These nodes output standard mathematical values such as pi, Euler's number, square roots of common values, and logarithmic constants. Constants nodes are essential for calculations that require precise mathematical constants and eliminate the need to manually enter these values in your workflows.

Each group provides specialized nodes to simplify complex mathematical tasks, making it easier to perform calculations in the BeeGraphy Editor.

Math.png

Math Light.png

Math

BeeGraphy Editor Services Package

This package contains service nodes designed for use in the BeeGraphy Editor, providing tools for assigning services to models.

Usage
The nodes in this package are used to apply services to models. These nodes can be found in the Services group in the menu or via the search engine.

Service Node Types
The package provides various service nodes that calculate costs and apply services based on different measurement units. Each service node type is designed to work with specific material properties and measurement values:

Count-based service nodes Apply services based on the number of items or units. These nodes are useful for services that are charged per item, such as hardware components, fasteners, or individual elements in a design.

Length-based service nodes Calculate services based on linear measurements. These nodes are ideal for services that depend on length, such as cutting, routing, or edge finishing operations that are priced per unit of length.

Area-based service nodes Apply services based on surface area measurements. These nodes are suitable for services that depend on the area covered, such as surface treatments, coatings, or material application that is priced per unit of area.

Volume-based service nodes Calculate services based on volumetric measurements. These nodes are useful for services that depend on volume, such as filling operations, material consumption, or processes priced per unit of volume.

Weight-based service nodes Apply services based on weight measurements. These nodes are ideal for services that depend on the weight of materials or components, such as shipping, handling, or processes where cost is determined by weight.

Time-based service nodes Calculate services based on time duration. These nodes are suitable for services that depend on processing time, labor hours, or any time-dependent operations where cost is determined by the duration of work.

Integration
Each service node requires material input and the corresponding measurement value to calculate and register the service cost. These nodes integrate with the manufacturing service system to track and process service costs for price estimation and manufacturing workflows.

ServicesDark.png

Services light.png

toolsDark.svg

toolsLite.svg

Service

Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.

title-IT-project-management-explained.png

QA test09102025

BeeGraphy Editor Exporter Package This package includes exporter nodes designed for use in the BeeGraphy Editor, enabling the export of models in various widely supported formats. These nodes are part of the BeeGraphy Editor engine. Usage The nodes in this package are responsible for exporting resulting models into different formats, making it easy to share, print, or use your work in other applications. To find these nodes, look under the **Export** group in the menu, or use the search engine. Available Exporter Nodes **STL Exporter**: Exports the model in STL format, commonly used for 3D printing. **STEP Exporter**: Exports the model in STEP format, ideal for CAD applications and interoperability between different software. **OBJ Exporter**: Exports the model in OBJ format, a widely supported format for 3D models across various programs.**DXF Exporter**: Exports the model in DXF format, commonly used for CAD drawings and vector-based designs. **IGES Exporter**: Exports the model in IGES format, a standard for exchanging digital information between CAD systems. **TXT Exporter**: Exports text data in plain text format for easy sharing and storage. **Table Exporter**: Exports table data in various formats (.xlsx, .csv, .pdf), commonly used for spreadsheets, data analysis, reports, and importing into Excel or database systems. **GLTF Exporter**: Exports the model in GLTF format, optimized for web-based 3D viewers, real-time engines, and AR/VR applications. **GLB Exporter**: Exports the model in GLB format, optimized for web-based 3D viewers, real-time engines, and AR/VR applications. Each exporter node simplifies the process of exporting your models into various formats, ensuring compatibility with different tools and workflows.

Exporter.png

Exporter Light.png

Exporter

BeeGraphy Editor Input Package

This package includes a collection of input nodes for the BeeGraphy Editor, providing essential components for receiving various data types. These nodes integrate with the BeeGraphy Editor engine, making them easy to locate and use in the editor's node menu under the Input group or via the search functionality.

Usage

Input nodes in this package are designed to handle different data types, from numeric values to complex objects like textures and curves. They enable seamless data input and manipulation within BeeGraphy Editor workflows.

Input Node Categories

Numeric Input Nodes

Numeric input nodes allow you to enter and work with numerical values. These nodes support constant numbers, adjustable ranges, and mathematical expressions. You can define fixed numeric constants, create adjustable ranges with minimum and maximum values, and process complex mathematical expressions for dynamic calculations. Numeric input nodes are essential for parameterizing your designs and creating interactive controls.

Text Input Nodes

Text input nodes provide various ways to work with textual data. These nodes support simple single-line text input, multi-line text areas for longer content, and rich text editors with formatting options. You can also select from predefined options using dropdown menus. Text input nodes are useful for labels, descriptions, annotations, and any workflow that requires textual information.

Selection and Choice Nodes

Selection and choice nodes enable you to provide discrete options and boolean values. These nodes include dropdown selectors for choosing from predefined options, boolean toggles for true/false values, and color pickers for selecting colors. Selection nodes are ideal for creating configurable options and providing users with controlled choices in their workflows.

Geometric and Curve Input Nodes

Geometric and curve input nodes allow you to work with geometric data and curves. These nodes enable you to create and edit NURBS curves, map numerical inputs to graphical representations, and manage UV coordinates for texture mapping. Geometric input nodes are essential for parametric design, animation curves, and working with complex geometric data.

Media and Asset Input Nodes

Media and asset input nodes provide capabilities for importing and working with various media types. These nodes support image imports, SVG vector graphics, texture inputs for materials, material selection, font selection, and 3D object imports. Media input nodes are crucial for incorporating external assets into your designs and creating visually rich projects.

Specialized Input Nodes

Specialized input nodes offer advanced functionality for specific use cases. These nodes include graph mappers for transforming numerical data through graphical functions, math expression processors for dynamic calculations, and UV mapping tools for texture coordinate management. Specialized input nodes extend the capabilities of the editor for advanced workflows and custom requirements.

Each input node type serves a specific purpose in data entry and manipulation, helping to create dynamic and responsive designs within the BeeGraphy Editor.

Input.png

Input Light.png

Input

<h2>What is Lorem Ipsum?</h2>Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.

Screen Shot 2024-11-29 at 10.14.36.png

Article-71-illustration-formats-01.png

2802000.svg

Example

node-qa-first

BeeGraphy Editor Light Plugin

This plugin includes light nodes designed for use in the BeeGraphy Editor, enabling advanced control of lighting in 3D scenes. These nodes are part of the BeeGraphy Editor engine and allow you to create realistic and dynamic lighting setups for your projects.

Usage

The nodes in this plugin are responsible for configuring and managing lighting in your scene. They support a variety of light types, allowing users to create custom illumination setups that enhance the visual quality of their models.

To find these nodes, look under the Light group in the menu, or use the search engine.

Available Light Types

The plugin provides several types of light nodes, each designed for different lighting scenarios:

- Ambient lighting nodes provide uniform lighting across the entire scene without casting shadows. These are useful for general scene illumination and reducing harsh contrasts.

- Directional lighting nodes simulate sunlight by casting parallel light rays from a specific direction. They are ideal for outdoor scenes and creating natural daylight effects.

- Point lighting nodes emit light in all directions from a specific position in 3D space. They work well for simulating light bulbs, lamps, and other localized light sources.

- Spot lighting nodes create focused beams of light with adjustable angles and falloff. They are perfect for highlighting specific areas or creating dramatic lighting effects.

- Rectangular area lighting nodes provide soft, realistic lighting from rectangular surfaces. They are excellent for simulating window light, LED panels, and other area light sources.

- Hemisphere lighting nodes combine ambient and directional lighting, creating a natural sky-like illumination that transitions from one color at the top to another at the bottom.

Common Parameters

Most light nodes share common parameters that allow you to customize their appearance and behavior:

- Color: Controls the color of the light, allowing you to create warm, cool, or colored lighting effects.

- Intensity: Adjusts the brightness of the light, enabling you to control how strongly the light affects the scene.

- Position: Defines the location of the light in 3D space for lights that have a specific position.

- Shadow casting: Many light types support shadow casting, which can be enabled or disabled to control whether the light creates shadows in the scene.

- Shadow map settings: For lights that cast shadows, you can configure shadow map resolution and bias to fine-tune shadow quality and appearance.

Each light type may also have additional specialized parameters that are specific to its lighting model, such as distance, decay, angle, and power settings.

Plugins & Documentations

Create Plugins