OpenSCAD

OpenSCAD предназначен для создания точных твёрдотельных 3D-моделей посредством текстового описания геометрии. Пользователь не вытягивает грани мышью и не формирует эскиз размерными ограничениями, а пишет сценарий: задаёт примитивы, размещает их в пространстве, объединяет, пересекает и вычитает друг из друга. После вычисления сценария программа показывает готовый объект в трёхмерном окне.

Такой способ моделирования особенно полезен для корпусов, креплений, переходников, втулок, шаблонов, органайзеров и других деталей, форму которых можно выразить через размеры и математические зависимости. Изменение одной переменной перестраивает все связанные элементы. Например, увеличение ширины корпуса одновременно сдвигает отверстия, удлиняет крышку и изменяет внутреннюю полость без ручного редактирования каждой операции.

OpenSCAD распространяется бесплатно, работает локально и доступен для Windows, macOS и Linux. Исходный проект хранится в текстовом файле .scad, поэтому модель удобно архивировать, сравнивать между редакциями и обрабатывать внешними сценариями. Программа ориентирована прежде всего на техническое, а не художественное 3D-моделирование.

Что представляет собой OpenSCAD

OpenSCAD относится к программируемым CAD-системам. В центре рабочего процесса находится не графическая сцена, а исходный текст. Каждая инструкция создаёт объект, преобразует уже созданную геометрию или определяет правило, по которому строится часть модели.

Простейший сценарий состоит из одной строки:

cube([40, 30, 10]);

Команда создаёт прямоугольный параллелепипед длиной 40, шириной 30 и высотой 10 единиц. OpenSCAD не закрепляет физическую единицу измерения внутри файла, однако при подготовке моделей для 3D-печати числовые значения обычно трактуются как миллиметры. Поэтому параллелепипед из примера после экспорта в STL воспринимается слайсером как деталь размером 40 × 30 × 10 мм.

Для создания отверстия добавляется цилиндр и булева операция difference():

difference() {
    cube([40, 30, 10]);

    translate([20, 15, -1])
        cylinder(h = 12, d = 8);
}

Внешний блок остаётся положительной геометрией, а цилиндр вычитается из него. Цилиндр начинается на единицу ниже основания и заканчивается выше верхней поверхности, поэтому вычитание проходит через всю толщину детали. Такой небольшой запас предотвращает совпадение поверхностей, которое способно привести к визуальным артефактам в быстром просмотре.

Подход основан на Constructive Solid Geometry — конструктивной блочной геометрии. Сложная форма собирается из кубов, цилиндров, сфер, многогранников и двумерных контуров. Затем к ним применяются перемещения, повороты, масштабирование, оболочки, суммы Минковского и булевы операции.

Чем программное моделирование отличается от обычного CAD

В графической параметрической системе пользователь обычно создаёт эскиз, ставит размеры и зависимости, затем применяет выдавливание, вращение, фаску или скругление. OpenSCAD описывает тот же замысел текстом. Вместо выбора плоскости и нажатия кнопки выдавливания применяется linear_extrude(), а положение детали задаётся числовым вектором в translate().

Это даёт несколько практических отличий:

• модель полностью воспроизводится из исходного текста;

• размеры можно вычислять по формулам;

• одинаковые части создаются циклами;

• вариант детали формируется изменением нескольких параметров;

• геометрию можно разделить на модули и подключаемые библиотеки;

• текст хорошо подходит для Git и других систем контроля изменений;

• массовая генерация выполняется из командной строки.

Обратная сторона метода — отсутствие полноценного прямого редактирования объекта. В трёхмерном окне можно вращать камеру, менять масштаб и выбирать центр обзора, но нельзя схватить отверстие мышью и передвинуть его. Координаты изменяются в сценарии или через Customizer, когда автор модели заранее подготовил редактируемые параметры. Навигация между текстом и изображением, пространственные преобразования, проверка размеров и отладка геометрии относятся к характерным сложностям такого подхода.

OpenSCAD не заменяет весь производственный процесс

Программа формирует геометрию, но не выполняет функции слайсера. Она не рассчитывает траектории печатающей головки, температуру, заполнение и поддержки, не создаёт управляющий G-code. Экспортированную модель открывают в отдельном приложении, например в Cura, где настраиваются параметры конкретного принтера и материала.

OpenSCAD также не предназначен для полигональной лепки, рисования персонажей и анимации. Для художественной работы с сеткой рациональнее использовать Blender или Wings 3D. При визуальном проектировании помещений и архитектурных концепций удобнее графические инструменты наподобие SketchUp. Другие программы этой категории собраны в разделе программ для 3D-моделирования.

Какие задачи решает OpenSCAD

Сильнее всего программа раскрывается в проектах, где форма определяется измеряемыми параметрами. В таких моделях каждый элемент имеет понятное назначение: стенка обладает заданной толщиной, отверстие привязано к краю, крышка рассчитана относительно корпуса, а повторяющиеся детали располагаются с постоянным шагом.

Корпуса для электроники

OpenSCAD подходит для прямоугольных и цилиндрических корпусов, держателей плат, кожухов датчиков и панелей с отверстиями под разъёмы. Размеры платы, толщина стенок, монтажные стойки и посадочный зазор крышки выносятся в переменные. После замены платы достаточно скорректировать несколько исходных значений.

Особенно удобно программировать повторяющиеся стойки. Четыре крепления по углам корпуса создаются циклом, а не четырьмя независимыми операциями. Если расстояние между монтажными отверстиями изменится, перестроится весь массив.

Крепления и переходники

Кронштейны часто состоят из основания, вертикальной стенки, рёбер и отверстий. Все эти части выражаются через простые тела и булевы операции. OpenSCAD позволяет быстро сформировать несколько вариантов с разной длиной, толщиной и диаметром крепежа.

По тому же принципу создаются:

• переходники между отверстиями разных стандартов;

• держатели труб и кабелей;

• настенные фиксаторы;

• направляющие;

• угловые соединители;

• опоры для датчиков и камер;

• адаптеры для нестандартных ручек и переключателей.

Втулки, шайбы и дистанционные элементы

Кольцевая втулка строится вычитанием двух цилиндров. Для семейства деталей достаточно задать внешний диаметр, внутренний диаметр и высоту:

outer_diameter = 18;
inner_diameter = 8;
height = 12;

difference() {
    cylinder(h = height, d = outer_diameter);
    translate([0, 0, -0.1])
        cylinder(h = height + 0.2, d = inner_diameter);
}

Такой исходник легко превращается в генератор: пользователь меняет три числа и получает новую втулку без изменения структуры модели.

Органайзеры и модульные системы хранения

Ящики, лотки, разделители и кассеты часто состоят из регулярной сетки. Циклы for позволяют создать одинаковые ячейки, отверстия или перегородки. Количество рядов, столбцов, ширина ячейки и толщина перегородки становятся параметрами.

Преимущество особенно заметно при выпуске серии органайзеров под разные наборы инструментов. Один сценарий может формировать модели на 6, 12 или 24 секции, сохраняя постоянную толщину стенок и общий принцип сборки.

Шаблоны, калибры и измерительные приспособления

В OpenSCAD создают:

• сверлильные шаблоны;

• угловые калибры;

• трафареты;

• ограничители глубины;

• посадочные макеты;

• линейки с делениями;

• проверочные профили.

Повторяющиеся метки формируются циклом, а подписи — модулем text(). Поскольку координаты вычисляются математически, расстояния между элементами остаются согласованными.

Детали с большим числом вариантов

Модель удобно превращать в набор конфигураций. Например, кронштейн может иметь варианты под винты M3, M4 и M5, разные расстояния между отверстиями и несколько длин основания. Вместо хранения десятков вручную отредактированных исходников создаётся один файл с параметрами.

Customizer дополнительно выводит эти параметры в графическую панель. Пользователь меняет диаметр, длину или количество элементов через поле, список либо ползунок, не редактируя код.

Кому подходит OpenSCAD

Программа не требует профессионального опыта в разработке программного обеспечения, но предполагает готовность работать с синтаксисом, координатами и формулами. Наиболее быстро её осваивают люди, знакомые с любым языком программирования, электронными таблицами или техническими вычислениями.

Программистам

Разработчикам понятна сама модель работы: текстовый исходник, функции, модули, параметры, условия и циклы. При этом язык OpenSCAD значительно уже Python, JavaScript или C++. Он предназначен прежде всего для описания геометрии и не пытается быть универсальной средой разработки.

Программист получает удобные для себя преимущества:

• повторное использование функций и модулей;

• построение массивов вычисляемой геометрии;

• хранение файлов в Git;

• автоматический экспорт;

• создание генераторов деталей;

• проверка параметров через assert();

• вывод служебных значений посредством echo().

Владельцам 3D-принтеров

OpenSCAD хорошо подходит для функциональной печати: держателей, корпусов, заглушек, фиксаторов и ремонтных деталей. Такой объект обычно проще описать размерами, чем моделировать как художественную сетку.

Программа особенно полезна, когда напечатанная деталь требует нескольких итераций. После первой примерки можно увеличить посадочный зазор на 0,2 мм, изменить диаметр отверстия или толщину защёлки в переменных. Остальная геометрия перестроится автоматически.

Инженерам и конструкторам

OpenSCAD удобен как генератор простой и средней по сложности геометрии, но не заменяет комплексную машиностроительную CAD-систему. В нём отсутствует развитая среда сборок, ассоциативные производственные чертежи, расчёт механизмов, полноценное управление материалами и технологическая подготовка производства.

Для отдельной параметрической детали возможностей часто достаточно. Для изделия с десятками взаимозависимых компонентов, посадками, спецификациями и чертежами удобнее FreeCAD, Autodesk Fusion или другая инженерная система.

Преподавателям

Результат выполнения кода виден в трёхмерном окне, поэтому OpenSCAD связывает программирование с геометрией. Через модели можно объяснять:

• декартовы координаты;

• векторы;

• углы;

• циклы;

• условия;

• функции;

• симметрию;

• преобразования;

• основы конструктивной геометрии.

Кому программа неудобна

OpenSCAD не подходит пользователю, который ожидает полностью визуального моделирования. Простая операция, выполняемая в обычном CAD перетаскиванием или выбором грани, здесь требует понимания координат и структуры сценария.

Другой инструмент рациональнее выбрать для:

• органических форм и персонажей;

• сложного поверхностного моделирования;

• быстрого концептуального моделирования мышью;

• промышленных сборок;

• подготовки полного комплекта чертежей;

• визуализации с реалистичными материалами;

• скульптинга;

• анимации.

Лицензия и платформы

OpenSCAD является свободным программным обеспечением. Код проекта распространяется по GNU General Public License версии 2 или более поздней. Платные тарифы, подписка и функциональные ограничения по лицензии отсутствуют. Программа может использоваться для личных, учебных и коммерческих проектов с соблюдением условий лицензии самого приложения и отдельных подключаемых библиотек.

Основные настольные платформы:

Платформа	Поддерживаемый вариант
Windows	настольное приложение для 32- и 64-разрядных x86-систем
macOS	настольное приложение
Linux	пакеты дистрибутивов, AppImage, Snap и Flatpak
FreeBSD, NetBSD, OpenBSD	пакеты соответствующих систем
Другие системы	сборка из исходного кода при наличии зависимостей

OpenSCAD работает локально. Для создания модели не требуется постоянное подключение к интернету, регистрация или облачное хранилище. Файл .scad можно держать рядом с библиотеками, импортируемыми контурами и экспортированными моделями.

Системные требования

Нагрузка OpenSCAD определяется не столько размером исходного файла, сколько сложностью вычисляемой геометрии. Несколько сотен строк с простыми кубами и цилиндрами обрабатываются легче, чем короткий сценарий с большим количеством сегментов, вложенными суммами Минковского и тяжёлой импортированной сеткой.

Операционные системы

Для настольных выпусков предусмотрены следующие базовые требования:

• Windows 7 или более новая система на x86;

• OS X 10.9 или более новая система;

• актуальный Linux-дистрибутив с необходимыми графическими библиотеками;

• FreeBSD 10 и новее;

• NetBSD 6.1 и новее.

Linux-сборки представлены для x86-64 и ARM64. Наличие пакета в конкретном репозитории зависит от дистрибутива.

Процессор

Предельная сложность модели зависит от производительности процессора. Полный рендеринг вычисляет результирующую геометрию, поэтому большое число булевых операций увеличивает время обработки. Особенно тяжёлыми становятся:

• minkowski() над многогранными телами;

• сферы и цилиндры с чрезмерным $fn;

• глубокие цепочки difference() и intersection();

• многократное повторение сложного модуля;

• операции над детализированными STL;

• большие polyhedron() с тысячами граней.

Для простых печатных деталей подходит обычный современный настольный процессор. Для регулярной работы с тяжёлыми моделями важнее высокая вычислительная производительность, чем возможности игровой видеокарты.

Оперативная память

Память расходуется на кэш геометрии и промежуточные результаты. После полного рендеринга сложная конструкция способна занимать значительно больше памяти, чем её исходный сценарий. Размер кэшей отображается в консоли и настраивается в параметрах программы.

Для небольших корпусов, креплений и шаблонов достаточно типичной конфигурации домашнего компьютера. Модели с большим количеством граней, импортированными сетками и тяжёлыми библиотеками требуют большего объёма памяти.

Графическая система

Быстрый просмотр использует OpenGL и OpenCSG. Видеокарта участвует в отображении предварительной сцены, однако итоговая геометрия рассчитывается отдельно. Поэтому мощный графический адаптер улучшает навигацию по сложному просмотру, но не устраняет вычислительные задержки полного рендеринга.

Требования к диску

Сами .scad-файлы обычно имеют небольшой размер, поскольку содержат текст. Основной объём занимают:

• экспортированные STL и 3MF;

• подключаемые библиотеки;

• импортированные сетки;

• наборы шрифтов;

• промежуточные изображения;

• архивы вариантов модели.

Интерфейс программы

Главное окно сочетает редактор исходного текста, область просмотра модели и консоль. Дополнительные панели открываются через меню Window. Рабочие области можно закреплять у краёв окна, переносить и выводить отдельно.

На изображении слева расположен сценарий, а справа — результат его выполнения. Полупрозрачные элементы показывают, как программа визуализирует составную конструктивную геометрию.

Text Editor

В редакторе создаётся и изменяется .scad-файл. Он поддерживает:

• подсветку синтаксиса;

• поиск и замену;

• комментирование строк;

• автодополнение встроенных конструкций;

• подсказки по аргументам;

• закладки;

• работу с несколькими вкладками;

• переход к месту ошибки;

• вставку шаблонов кода;

• изменение чисел посредством клавиатуры и колеса мыши.

Контекстное меню редактора содержит Insert Template. Команда вставляет подготовленный фрагмент, например цикл for или условную конструкцию. Пользовательские шаблоны хранятся в JSON-файлах.

Число рядом с курсором можно увеличивать и уменьшать комбинациями Alt+Up Arrow и Alt+Down Arrow. При автоматическом предварительном просмотре изменение сразу отражается на модели. На macOS для интерактивной корректировки используются соответствующие сочетания с Option.

Model Viewing Pane

Трёхмерная область показывает результат сценария. Она служит для визуальной проверки, но не для непосредственного редактирования геометрии.

Управление камерой выполняется мышью:

• перетаскивание левой кнопкой вращает вид;

• правая кнопка перемещает область просмотра;

• колесо изменяет масштаб;

• двойной щелчок задаёт центр вращения;

• + и - приближают и отдаляют сцену.

Команды Top, Bottom, Left, Right, Front, Back и Diagonal выравнивают камеру относительно глобальной системы координат. Center возвращает начало координат в центр области просмотра.

Console Pane

Консоль отображает:

• синтаксические ошибки;

• предупреждения;

• сообщения echo();

• статистику кэша;

• количество объектов;

• длительность рендеринга;

• сообщения об импортированной геометрии;

• ошибки неманифолдных сеток.

Во время продолжительного рендеринга внизу консоли появляется индикатор процесса и кнопка отмены. Контекстное меню позволяет очистить, скопировать или сохранить содержимое панели.

Меню Design

Две основные команды находятся в меню Design:

• Preview — быстрый просмотр, вызываемый клавишей F5;

• Render — полный расчёт геометрии, вызываемый клавишей F6.

Предварительный просмотр предназначен для редактирования. Он быстро показывает взаимное расположение тел, но не формирует окончательную сетку. Полный рендеринг вычисляет результат булевых операций и необходим перед надёжным экспортом модели.

Меню View

В этом меню переключаются режимы отображения и положение камеры. Полезные команды:

• Show Edges показывает рёбра;

• Show Axes выводит оси координат;

• Show Crosshairs отмечает центр вида;

• Perspective включает перспективную проекцию;

• Orthogonal включает ортографическую проекцию;

• View All помещает всю модель в окно;

• Reset View возвращает исходный обзор.

Ортографическая проекция удобна для проверки размеров и взаимного расположения деталей. Перспективная лучше передаёт пространственный объём.

Как устроен язык OpenSCAD

Язык построен вокруг выражений, модулей и преобразований. Примитив создаёт объект, преобразование получает дочернюю геометрию и возвращает её изменённый вариант, а булева операция формирует новое тело из нескольких дочерних объектов.

Точка с запятой и фигурные скобки

Одиночная инструкция заканчивается точкой с запятой:

cube(10);

Несколько дочерних инструкций объединяются фигурными скобками:

translate([20, 0, 0]) {
    cube(10);
    sphere(6);
}

Здесь translate() перемещает оба объекта.

Комментарии

Однострочный комментарий начинается с //:

// Толщина стенки
wall = 2;

Многострочный фрагмент помещается между /* и */:

/*
Параметры корпуса
и монтажных отверстий
*/

Комментарии используются не только для пояснений. Customizer распознаёт специальные аннотации рядом с переменными и превращает их в ползунки, списки и группы.

Значения и векторы

Основные типы значений:

• числа;

• строки;

• логические true и false;

• неопределённое значение undef;

• векторы и списки;

• диапазоны.

Вектор из трёх чисел часто задаёт координаты или размеры:

position = [20, 15, 5];
size = [40, 30, 10];

Обращение к элементам выполняется по индексу:

echo(size[0]); // 40

Особенность присваивания

Переменные OpenSCAD не ведут себя как изменяемые переменные в последовательной программе. Описание модели вычисляется декларативно, а присваивания внутри одной области не образуют обычную цепочку изменения состояния.

Поэтому конструкция:

value = 10;
value = 20;
cube(value);

не должна восприниматься как два последовательных шага. Для локального вычисления используется let(), а для перебора значений — for. Эта особенность требует привыкания даже от опытных программистов.

Геометрические примитивы

Cube

cube() создаёт параллелепипед:

cube(20);
cube([40, 30, 10]);
cube([40, 30, 10], center = true);

При center = false объект начинается в точке [0, 0, 0] и продолжается в положительном направлении осей. При center = true центр тела совпадает с началом координат.

Центрирование упрощает симметричные модели. Например, отверстие по центру пластины легче вычитать из центрированного блока.

Sphere

sphere() создаёт сферу:

sphere(r = 10);
sphere(d = 20);

Параметр r задаёт радиус, d — диаметр. Детализация поверхности зависит от $fn, $fa и $fs.

Cylinder

cylinder() строит цилиндр или усечённый конус:

cylinder(h = 20, r = 8);
cylinder(h = 20, d = 16);
cylinder(h = 20, r1 = 10, r2 = 5);

h определяет высоту, r1 и r2 — радиусы нижнего и верхнего основания. Для сквозных отверстий цилиндр обычно делают немного выше вычитаемого тела.

Polyhedron

polyhedron() создаёт многогранник по вершинам и граням:

points = [
    [0, 0, 0],
    [20, 0, 0],
    [0, 20, 0],
    [0, 0, 20]
];

faces = [
    [0, 2, 1],
    [0, 1, 3],
    [0, 3, 2],
    [1, 2, 3]
];

polyhedron(points = points, faces = faces);

Индексы в faces ссылаются на элементы массива points. Порядок вершин определяет направление нормали. Неверный порядок приводит к вывернутым или некорректно соединённым поверхностям.

Двумерные объекты

Двумерная подсистема используется для контуров, которые затем экспортируются или превращаются в объём.

Square

square(20);
square([40, 20], center = true);

Circle

circle(r = 10);
circle(d = 20);

Круг аппроксимируется многоугольником, поэтому его гладкость также зависит от параметров фрагментации.

Polygon

polygon([
    [0, 0],
    [40, 0],
    [30, 20],
    [10, 25]
]);

Для сложного контура можно передать отдельный массив путей. Это позволяет описывать внешнюю границу и внутренние отверстия.

Text

text(
    "OpenSCAD",
    size = 12,
    font = "Liberation Sans",
    halign = "center",
    valign = "center"
);

Модуль создаёт двумерные очертания текста. Для получения объёмной надписи применяется linear_extrude().

OpenSCAD включает семейства Liberation Mono, Liberation Sans и Liberation Serif. Их использование уменьшает различия между платформами. Дополнительные шрифты берутся из системы или подключаются к проекту.

Преобразования объектов

Перемещение

translate() переносит дочерний объект:

translate([30, 10, 5])
    cube([20, 10, 5]);

Вектор содержит смещение по X, Y и Z.

Вращение

rotate([0, 0, 45])
    cube([20, 10, 5]);

Углы указываются в градусах. Вектор задаёт последовательное вращение вокруг осей X, Y и Z.

Для вращения вокруг одной оси можно применять форму:

rotate(a = 45, v = [0, 0, 1])
    cube([20, 10, 5]);

Масштабирование

scale([2, 1, 0.5])
    sphere(10);

Объект растягивается вдвое по X, сохраняет размер по Y и уменьшается вдвое по Z.

Изменение до заданного размера

resize([40, 20, 10])
    sphere(10);

resize() приводит габариты к заданным значениям. Это отличается от коэффициентов scale().

Зеркальное отражение

mirror([1, 0, 0])
    translate([20, 0, 0])
        cube(10);

Вектор задаёт нормаль плоскости отражения.

Матрица преобразования

multmatrix() выполняет произвольное аффинное преобразование посредством матрицы 4 × 4. Инструмент применяется для нестандартных поворотов, сдвигов и комбинаций преобразований, которые неудобно выражать последовательностью простых модулей.

Цвет и прозрачность

color("orange")
    cube(20);

color([0.2, 0.6, 1.0, 0.4])
    translate([10, 10, 10])
        sphere(15);

color() влияет на представление в окне. STL не хранит цвет и материал, поэтому цветовое оформление служит главным образом для анализа сцены. Для многоцветного производства нужен формат и последующий процесс, поддерживающий отдельные части или цветовые данные.

Булевы операции

Union

union() объединяет тела:

union() {
    cube([30, 20, 5]);
    translate([15, 10, 5])
        cylinder(h = 15, d = 10);
}

Соприкасающиеся и пересекающиеся объекты образуют одну результирующую геометрию.

Difference

Первый дочерний объект остаётся, остальные вычитаются:

difference() {
    cube([40, 30, 10]);

    translate([10, 15, -1])
        cylinder(h = 12, d = 6);

    translate([30, 15, -1])
        cylinder(h = 12, d = 6);
}

Порядок дочерних объектов имеет значение.

Intersection

intersection() сохраняет только общий объём:

intersection() {
    cube([20, 20, 20], center = true);
    sphere(14);
}

Результатом становится сфера, обрезанная границами куба.

Почему быстрый просмотр и полный рендеринг различаются

Предварительный режим использует OpenCSG и графический Z-буфер. Он быстро показывает видимый результат наложения тел, не рассчитывая все реальные грани. Полный рендеринг формирует полигональную геометрию. Поэтому рёбра, появившиеся в результате вычитания, могут отображаться в двух режимах по-разному.

Построение объёма из двумерного контура

Linear Extrude

linear_extrude() вытягивает плоскую форму по оси Z:

linear_extrude(height = 8)
    square([40, 20], center = true);

Параметр center = true центрирует результат по высоте:

linear_extrude(height = 8, center = true)
    circle(d = 30);

Скручивание задаётся через twist:

linear_extrude(
    height = 50,
    twist = 180,
    slices = 80
)
    translate([15, 0])
        square([6, 6], center = true);

Плоский квадрат перемещён от оси, поэтому при вытягивании образует закрученную спиральную форму.

Rotate Extrude

rotate_extrude() вращает двумерный профиль вокруг оси Z:

rotate_extrude()
    translate([20, 0])
        circle(r = 4);

Результатом становится тор. Контур должен располагаться по одну сторону от оси вращения. Пересечение профилем оси создаёт проблемную геометрию.

Projection

projection() преобразует трёхмерный объект в двумерную проекцию:

projection(cut = true)
    translate([0, 0, -5])
        sphere(20);

При cut = true берётся сечение плоскостью Z = 0. При false формируется плоская проекция всей модели.

Инструмент используется для подготовки DXF или SVG, шаблонов и контуров лазерной резки.

Hull, Minkowski и Offset

Hull

hull() строит выпуклую оболочку вокруг дочерних объектов:

hull() {
    translate([-20, 0, 0])
        cylinder(h = 5, d = 12);

    translate([20, 0, 0])
        cylinder(h = 5, d = 12);
}

Получается вытянутая пластина с полукруглыми концами. Метод удобен для рычагов, соединительных планок и плавных переходов между примитивами.

Minkowski

minkowski() вычисляет сумму Минковского. Частый сценарий — округление прямоугольного тела сферой:

minkowski() {
    cube([36, 26, 6], center = true);
    sphere(r = 2);
}

Габариты результата увеличиваются на диаметр добавляемой сферы. Операция резко увеличивает количество граней, поэтому её следует использовать осознанно.

Offset

offset() изменяет двумерный контур:

offset(r = 2)
    square([30, 20], center = true);

Положительное значение расширяет форму, отрицательное уменьшает. Параметр delta создаёт угловое или фасочное смещение.

offset() удобен при подготовке зазоров, рамок и стенок в двумерном профиле.

Управление гладкостью

Кривые в экспортированной модели состоят из прямых сегментов. Их количество регулируют три специальные переменные:

• $fn — фиксированное количество фрагментов;

• $fa — минимальный угловой шаг;

• $fs — минимальная длина фрагмента.

Пример:

$fn = 64;
cylinder(h = 20, d = 30);

Цилиндр получит 64 стороны.

Чрезмерное значение $fn замедляет все последующие операции. Сфера с $fn = 200 содержит намного больше граней, чем требуется большинству печатных деталей. Рациональнее разделять черновую и итоговую детализацию:

draft = true;

$fn = draft ? 24 : 96;

Во время редактирования используется 24 сегмента, перед экспортом переменная переключается на 96.

Параметрическое моделирование

Параметрическая модель начинается с отделения замысла от конкретных размеров. Числа, которые пользователь планирует менять, выносятся в начало файла:

length = 80;
width = 50;
height = 25;
wall = 2.4;
hole_diameter = 3.4;

Далее геометрия строится только через эти переменные:

difference() {
    cube([length, width, height]);

    translate([wall, wall, wall])
        cube([
            length - 2 * wall,
            width - 2 * wall,
            height
        ]);
}

После изменения wall внутренняя полость автоматически пересчитывается.

Формулы и связанные параметры

Зависимости можно выражать непосредственно:

inner_length = length - 2 * wall;
inner_width = width - 2 * wall;
lid_length = length + 2 * 0.2;

Такая структура делает модель читаемой. Пользователь видит, откуда получен размер, вместо набора неясных чисел по всему файлу.

Модули

Модуль объединяет геометрию в повторно используемый блок:

module mounting_post(
    outer_d = 8,
    hole_d = 3.2,
    post_height = 10
) {
    difference() {
        cylinder(h = post_height, d = outer_d);

        translate([0, 0, -0.1])
            cylinder(
                h = post_height + 0.2,
                d = hole_d
            );
    }
}

Вызов:

mounting_post();

translate([40, 0, 0])
    mounting_post(outer_d = 10, post_height = 14);

Модуль принимает именованные аргументы и значения по умолчанию. Это облегчает повторное использование и чтение сценария.

Children

children() передаёт модулю дочерние объекты:

module move_pair(distance = 30) {
    translate([-distance / 2, 0, 0])
        children();

    translate([distance / 2, 0, 0])
        children();
}

move_pair(40)
    cylinder(h = 10, d = 8);

Один цилиндр из вызова создаётся дважды.

Функции

Функция возвращает значение:

function clearance(diameter, gap = 0.3) =
    diameter + 2 * gap;

hole = clearance(3);

Функции применяются для математических расчётов, генерации массивов координат и преобразования данных. Геометрию создают модули, а не функции.

Условия

add_lid = true;

if (add_lid) {
    translate([0, 0, 30])
        cube([80, 50, 2]);
}

Развилка:

part = "base";

if (part == "base") {
    base();
} else if (part == "lid") {
    lid();
} else {
    base();
    translate([0, 0, 35])
        lid();
}

Так один файл может экспортировать основание, крышку или сборочный вид.

Циклы

for (x = [10, 70]) {
    for (y = [10, 40]) {
        translate([x, y, 0])
            cylinder(h = 5, d = 4);
    }
}

Вложенные циклы создают четыре отверстия или стойки по углам.

Для регулярного ряда:

for (i = [0 : 5]) {
    translate([i * 12, 0, 0])
        cylinder(h = 4, d = 6);
}

Include и Use

include 
use 

include выполняет содержимое подключаемого файла и делает доступными его определения и переменные. use импортирует определения модулей и функций без выполнения основной геометрии файла.

Для библиотечного файла чаще применяется use, поскольку демонстрационные объекты из него не попадут в проект.

Customizer

Customizer формирует графическую панель из переменных, расположенных в начале исходника. Пользователь меняет параметры без ручного редактирования строк.

Обычное числовое поле

width = 80;

Переменная отображается как поле ввода.

Ползунок

wall = 2.4; // [1:0.1:5]

Диапазон задаётся как минимум, шаг и максимум. Панель создаёт ползунок от 1 до 5 с шагом 0,1.

Список значений

part = "both"; // [base, lid, both]

Появляется раскрывающийся список.

Можно добавить понятные подписи:

quality = 64; // [24:Draft, 64:Normal, 128:High]

Логический переключатель

add_vents = true;

Логическая переменная отображается как флажок.

Группы

/* [Body] */
length = 80;
width = 50;
height = 25;

/* [Mounting] */
hole_diameter = 3.4;
post_diameter = 8;

Комментарии с названиями в квадратных скобках группируют параметры.

Скрытые переменные

/* [Hidden] */
inner_length = length - 2 * wall;

Всё после группы Hidden не показывается в панели. Там размещают вычисляемые значения и служебные параметры.

Customizer отображает только подходящие переменные основного файла. Значения из подключаемых через include и use файлов в панели не появляются как самостоятельные элементы. Наборы параметров сохраняются в JSON и могут использоваться при пакетном экспорте из командной строки.

Импорт файлов

Импорт выполняется модулем import():

import("part.stl");

Путь разрешается относительно файла сценария, если не задан абсолютный адрес.

Трёхмерная геометрия

OpenSCAD импортирует:

• STL;

• OFF;

• AMF;

• 3MF.

Импортированный объект становится геометрическим узлом. Его можно перемещать, вращать, масштабировать и использовать в булевых операциях:

difference() {
    import("housing.stl");

    translate([0, 0, -10])
        cylinder(h = 100, d = 12);
}

При этом STL не превращается обратно в параметрическую историю. OpenSCAD видит готовую сетку, а не исходные отверстия, эскизы и операции.

Двумерные контуры

Поддерживаются DXF и SVG:

linear_extrude(height = 4)
    import("logo.svg");

Для DXF и SVG можно выбрать слой:

import("panel.dxf", layer = "cut");

После импорта контур вытягивается, смещается или объединяется с другой геометрией.

Карты высот

surface() создаёт рельеф из текстовой матрицы или PNG:

surface(
    file = "heightmap.png",
    center = true,
    invert = false
);

Яркость пикселей преобразуется в высоту. Инструмент подходит для рельефных карт и декоративных поверхностей, но не заменяет художественный редактор высот.

Требования к импортированному STL

Сетка должна быть замкнутой и манифолдной: без дыр, самопересечений и неоднозначных рёбер. Повреждённый STL способен нормально отображаться в Preview, но исчезнуть или вызвать ошибку при Render.

Типичные сообщения:

CGAL error
Object may not be a valid 2-manifold

Перед булевой обработкой проблемную сетку исправляют в специализированном редакторе. Для этого подходит Blender или другой инструмент анализа полигонов.

Экспорт результатов

Доступные форматы зависят от размерности результата.

Трёхмерные модели

OpenSCAD экспортирует:

• STL;

• OFF;

• AMF;

• 3MF.

STL широко используется для передачи модели в слайсер, но не хранит параметрический исходник. Редактируемой основой проекта остаётся .scad.

3MF способен хранить более сложную структуру, однако фактическое сохранение отдельных частей и цветов зависит от структуры модели и принимающего приложения.

Двумерные результаты

После projection() или создания чистой 2D-геометрии доступны:

• DXF;

• SVG;

• PDF;

• PNG.

DXF и SVG подходят для обмена контурами и лазерной резки. PDF формирует одностраничный документ. PNG сохраняет изображение, а не редактируемую CAD-геометрию.

Правильная последовательность экспорта

1. Проверить модель через Design > Preview.

2. Убедиться, что все части находятся в ожидаемых координатах.

3. Выполнить Design > Render.

4. Просмотреть предупреждения в Console Pane.

5. Оценить рёбра и отверстия.

6. Экспортировать нужный формат.

7. Открыть файл в принимающей программе.

8. Проверить масштаб и целостность сетки.

Подробная инструкция: параметрический корпус с крышкой

Ниже создаётся корпус для небольшой электронной платы. Модель содержит полое основание, четыре стойки, вентиляционные отверстия и отдельную крышку.

Параметры проекта

// Отображаемая часть
part = "both"; // [base, lid, both]

/* [Body] */
body_length = 80;
body_width = 52;
body_height = 24;
wall = 2.4;
floor_thickness = 2.4;
corner_radius = 4;

/* [Lid] */
lid_thickness = 2.4;
lid_overlap = 5;
lid_clearance = 0.25;

/* [Mounting Posts] */
post_diameter = 7;
post_height = 8;
screw_hole = 3.2;
post_offset_x = 9;
post_offset_y = 9;

/* [Ventilation] */
add_vents = true;
vent_count = 6;
vent_width = 2;
vent_length = 28;
vent_spacing = 5;

/* [Quality] */
quality = 64; // [24:Draft, 64:Normal, 128:High]

/* [Hidden] */
$fn = quality;

inner_length = body_length - 2 * wall;
inner_width = body_width - 2 * wall;

Переменные сгруппированы для Customizer. Служебные вычисления скрыты.

Скруглённый прямоугольник

OpenSCAD не применяет интерактивную команду скругления к выбранным рёбрам. Для корпуса удобно создать двумерный скруглённый контур через offset():

module rounded_rectangle_2d(length, width, radius) {
    offset(r = radius)
        square(
            [length - 2 * radius, width - 2 * radius],
            center = true
        );
}

Сначала создаётся уменьшенный прямоугольник, затем offset(r = radius) расширяет его и формирует округлённые углы.

Внешняя оболочка

module outer_body() {
    linear_extrude(height = body_height)
        rounded_rectangle_2d(
            body_length,
            body_width,
            corner_radius
        );
}

Контур вытягивается до полной высоты корпуса.

Внутренняя полость

module inner_cavity() {
    translate([0, 0, floor_thickness])
        linear_extrude(height = body_height)
            rounded_rectangle_2d(
                inner_length,
                inner_width,
                max(
                    corner_radius - wall,
                    0.1
                )
            );
}

Полость начинается на уровне floor_thickness, поэтому нижняя часть основания остаётся сплошной. Высота вычитаемого объёма достигает верхнего края и открывает корпус сверху.

Монтажная стойка

module mounting_post() {
    difference() {
        cylinder(
            h = post_height,
            d = post_diameter
        );

        translate([0, 0, -0.1])
            cylinder(
                h = post_height + 0.2,
                d = screw_hole
            );
    }
}

Отверстие проходит через всю стойку.

Расстановка четырёх стоек

module mounting_posts() {
    x_position =
        body_length / 2 -
        wall -
        post_offset_x;

    y_position =
        body_width / 2 -
        wall -
        post_offset_y;

    for (x = [-x_position, x_position]) {
        for (y = [-y_position, y_position]) {
            translate([
                x,
                y,
                floor_thickness
            ])
                mounting_post();
        }
    }
}

Координаты вычисляются относительно центра корпуса. При изменении длины и ширины стойки остаются симметрично привязанными к краям.

Вентиляционная прорезь

module vent_slot() {
    hull() {
        translate([
            -vent_length / 2,
            0,
            0
        ])
            cylinder(
                h = lid_thickness + 0.4,
                d = vent_width
            );

        translate([
            vent_length / 2,
            0,
            0
        ])
            cylinder(
                h = lid_thickness + 0.4,
                d = vent_width
            );
    }
}

Два цилиндра соединяются hull(), формируя продолговатую прорезь с круглыми концами.

Массив вентиляционных отверстий

module vent_array() {
    total_width =
        (vent_count - 1) * vent_spacing;

    for (i = [0 : vent_count - 1]) {
        translate([
            0,
            -total_width / 2 +
            i * vent_spacing,
            -0.2
        ])
            vent_slot();
    }
}

Массив автоматически центрируется. Изменение vent_count не требует ручного перерасчёта первой координаты.

Основание корпуса

module base() {
    union() {
        difference() {
            outer_body();
            inner_cavity();
        }

        mounting_posts();
    }
}

Сначала из внешнего тела вычитается полость, затем добавляются стойки.

Наружная часть крышки

module lid_plate() {
    linear_extrude(height = lid_thickness)
        rounded_rectangle_2d(
            body_length,
            body_width,
            corner_radius
        );
}

Внутренний посадочный бортик

module lid_insert() {
    insert_length =
        inner_length -
        2 * lid_clearance;

    insert_width =
        inner_width -
        2 * lid_clearance;

    difference() {
        linear_extrude(height = lid_overlap)
            rounded_rectangle_2d(
                insert_length,
                insert_width,
                max(
                    corner_radius -
                    wall -
                    lid_clearance,
                    0.1
                )
            );

        translate([0, 0, -0.1])
            linear_extrude(
                height = lid_overlap + 0.2
            )
                rounded_rectangle_2d(
                    insert_length - 2 * wall,
                    insert_width - 2 * wall,
                    max(
                        corner_radius -
                        2 * wall,
                        0.1
                    )
                );
    }
}

Бортик создаётся как тонкая рамка. lid_clearance уменьшает его внешние размеры относительно полости. Зазор задаётся с каждой стороны.

Полная крышка

module lid() {
    difference() {
        union() {
            lid_plate();

            translate([0, 0, -lid_overlap])
                lid_insert();
        }

        if (add_vents) {
            translate([
                0,
                0,
                -0.2
            ])
                vent_array();
        }
    }
}

Рамка направлена вниз, а вентиляционные отверстия вычитаются из верхней пластины.

Вывод выбранной части

if (part == "base") {
    base();
}

if (part == "lid") {
    lid();
}

if (part == "both") {
    translate([
        -body_length / 2 - 8,
        0,
        0
    ])
        base();

    translate([
        body_length / 2 + 8,
        0,
        lid_overlap
    ])
        lid();
}

В режиме both основание и крышка разводятся по сторонам, чтобы их было удобно осматривать.

Полный сценарий

part = "both"; // [base, lid, both]

/* [Body] */
body_length = 80;
body_width = 52;
body_height = 24;
wall = 2.4;
floor_thickness = 2.4;
corner_radius = 4;

/* [Lid] */
lid_thickness = 2.4;
lid_overlap = 5;
lid_clearance = 0.25;

/* [Mounting Posts] */
post_diameter = 7;
post_height = 8;
screw_hole = 3.2;
post_offset_x = 9;
post_offset_y = 9;

/* [Ventilation] */
add_vents = true;
vent_count = 6;
vent_width = 2;
vent_length = 28;
vent_spacing = 5;

/* [Quality] */
quality = 64; // [24:Draft, 64:Normal, 128:High]

/* [Hidden] */
$fn = quality;

inner_length = body_length - 2 * wall;
inner_width = body_width - 2 * wall;

module rounded_rectangle_2d(
    length,
    width,
    radius
) {
    offset(r = radius)
        square(
            [
                length - 2 * radius,
                width - 2 * radius
            ],
            center = true
        );
}

module outer_body() {
    linear_extrude(height = body_height)
        rounded_rectangle_2d(
            body_length,
            body_width,
            corner_radius
        );
}

module inner_cavity() {
    translate([0, 0, floor_thickness])
        linear_extrude(height = body_height)
            rounded_rectangle_2d(
                inner_length,
                inner_width,
                max(
                    corner_radius - wall,
                    0.1
                )
            );
}

module mounting_post() {
    difference() {
        cylinder(
            h = post_height,
            d = post_diameter
        );

        translate([0, 0, -0.1])
            cylinder(
                h = post_height + 0.2,
                d = screw_hole
            );
    }
}

module mounting_posts() {
    x_position =
        body_length / 2 -
        wall -
        post_offset_x;

    y_position =
        body_width / 2 -
        wall -
        post_offset_y;

    for (x = [-x_position, x_position]) {
        for (y = [-y_position, y_position]) {
            translate([
                x,
                y,
                floor_thickness
            ])
                mounting_post();
        }
    }
}

module vent_slot() {
    hull() {
        translate([
            -vent_length / 2,
            0,
            0
        ])
            cylinder(
                h = lid_thickness + 0.4,
                d = vent_width
            );

        translate([
            vent_length / 2,
            0,
            0
        ])
            cylinder(
                h = lid_thickness + 0.4,
                d = vent_width
            );
    }
}

module vent_array() {
    total_width =
        (vent_count - 1) *
        vent_spacing;

    for (i = [0 : vent_count - 1]) {
        translate([
            0,
            -total_width / 2 +
            i * vent_spacing,
            -0.2
        ])
            vent_slot();
    }
}

module base() {
    union() {
        difference() {
            outer_body();
            inner_cavity();
        }

        mounting_posts();
    }
}

module lid_plate() {
    linear_extrude(height = lid_thickness)
        rounded_rectangle_2d(
            body_length,
            body_width,
            corner_radius
        );
}

module lid_insert() {
    insert_length =
        inner_length -
        2 * lid_clearance;

    insert_width =
        inner_width -
        2 * lid_clearance;

    difference() {
        linear_extrude(height = lid_overlap)
            rounded_rectangle_2d(
                insert_length,
                insert_width,
                max(
                    corner_radius -
                    wall -
                    lid_clearance,
                    0.1
                )
            );

        translate([0, 0, -0.1])
            linear_extrude(
                height = lid_overlap + 0.2
            )
                rounded_rectangle_2d(
                    insert_length - 2 * wall,
                    insert_width - 2 * wall,
                    max(
                        corner_radius -
                        2 * wall,
                        0.1
                    )
                );
    }
}

module lid() {
    difference() {
        union() {
            lid_plate();

            translate([
                0,
                0,
                -lid_overlap
            ])
                lid_insert();
        }

        if (add_vents) {
            translate([0, 0, -0.2])
                vent_array();
        }
    }
}

if (part == "base") {
    base();
}

if (part == "lid") {
    lid();
}

if (part == "both") {
    translate([
        -body_length / 2 - 8,
        0,
        0
    ])
        base();

    translate([
        body_length / 2 + 8,
        0,
        lid_overlap
    ])
        lid();
}

Проверка модели

После ввода сценария нужно нажать F5. В окне появятся основание и крышка. Далее следует проверить:

• полость открыта сверху;

• стойки находятся внутри корпуса;

• отверстия проходят через стойки;

• бортик крышки направлен вниз;

• вентиляционные прорези не пересекают край;

• стенки не имеют разрывов.

После визуальной проверки выполняется F6. В консоли не должно быть сообщений о неманифолдной геометрии, вырожденных полигонах или невозможности построения объекта.

Для экспорта основания устанавливается:

part = "base";

Для крышки:

part = "lid";

Каждая часть рендерится и сохраняется отдельно.

Настройка зазора крышки

lid_clearance задаёт зазор с каждой стороны. При значении 0,25 мм общая разница между шириной полости и наружной шириной бортика составляет 0,5 мм.

Печатный результат зависит от принтера, материала, ориентации и калибровки. Поэтому точный зазор подбирается пробным образцом. Параметрическая модель позволяет менять его без перестройки крышки вручную.

Проверка толщины стенок

Толщина корпуса задаётся переменной wall. Внешний размер остаётся постоянным, а внутренний изменяется:

inner_length = body_length - 2 * wall;
inner_width = body_width - 2 * wall;

При увеличении wall внутреннее пространство уменьшается. Если требуется сохранить внутренний объём, внешние размеры следует вычислять от него:

body_length = required_inner_length + 2 * wall;
body_width = required_inner_width + 2 * wall;

Командная строка и пакетная генерация

OpenSCAD запускается без графического интерфейса. Базовая команда принимает входной .scad и выходной файл:

openscad -o output.stl model.scad

Формат определяется расширением результата.

Передача параметров

Значение переменной заменяется через -D:

openscad \
  -D 'part="base"' \
  -D 'body_length=100' \
  -o base-100.stl \
  enclosure.scad

Для крышки:

openscad \
  -D 'part="lid"' \
  -D 'body_length=100' \
  -o lid-100.stl \
  enclosure.scad

Генерация серии

Сценарий оболочки PowerShell или Bash может создать несколько размеров:

for size in 60 80 100 120
do
    openscad \
      -D "body_length=$size" \
      -D 'part="base"' \
      -o "base-$size.stl" \
      enclosure.scad
done

Один исходник выдаёт четыре модели.

Наборы Customizer

Сохранённые в JSON конфигурации подключаются параметрами -p и -P:

openscad \
  -o model.stl \
  -p parameters.json \
  -P compact \
  model.scad

-p указывает файл наборов, -P — имя конкретной конфигурации.

Применение в автоматизации

Командный режим подходит для:

• генерации каталога типоразмеров;

• пересборки моделей после изменения библиотеки;

• получения PNG-превью;

• проверки сценариев;

• выпуска файлов на сервере;

• интеграции в CI;

• создания веб-конфигураторов;

• автоматической подготовки вложений к релизу проекта.

Библиотеки OpenSCAD

Библиотека представляет собой один или несколько .scad-файлов с готовыми модулями и функциями. Она может содержать крепёж, профили, шестерни, резьбы, преобразования и вспомогательные вычисления.

К популярным библиотекам относятся BOSL2, MCAD, NopSCADlib и UB.scad. Перед подключением необходимо проверить документацию, лицензию и зависимости конкретного проекта.

Типичная структура

project/
├── main.scad
├── lib/
│   ├── fasteners.scad
│   └── geometry.scad
└── assets/
    └── logo.svg

Подключение:

use 
use 

Что дают библиотеки

• винты, гайки и шайбы стандартных размеров;

• резьбовые профили;

• зубчатые колёса;

• подшипники;

• алюминиевые профили;

• электронные компоненты;

• вспомогательные векторные функции;

• привязки и ориентацию объектов;

• скруглённые тела;

• оболочки и трубки;

• генераторы креплений.

Ограничения

Подключаемая библиотека не становится частью языка. Её интерфейс, совместимость и поведение определяются автором. Проект, использующий внешние модули, следует хранить вместе с нужной редакцией библиотеки или фиксировать её редакцию в системе контроля изменений.

Производительность

Preview и Render

Preview пересчитывается быстро и предназначен для постоянной работы. Render выполняет точный расчёт и может занимать значительно больше времени.

Для удобного процесса:

1. использовать низкую детализацию во время редактирования;

2. проверять отдельные модули;

3. временно скрывать тяжёлые части;

4. выполнять F6 перед экспортом;

5. повышать качество только на финальном этапе.

Модификаторы отладки

OpenSCAD поддерживает специальные символы перед объектом.

Выделение

#translate([20, 0, 0])
    cylinder(h = 20, d = 10);

# выделяет объект в Preview.

Полупрозрачный фон

%cube([40, 30, 10]);

% показывает объект как вспомогательный, не включая его в итоговую геометрию.

Скрытие

*heavy_module();

* полностью отключает узел.

Показывать только выбранное

!problem_area();

! оставляет для просмотра выбранную ветвь.

Эти символы особенно полезны в глубоком difference(), где трудно понять положение вычитаемого тела.

Уменьшение числа сегментов

Плохо:

$fn = 300;

для всего проекта.

Рациональнее:

preview_mode = true;
$fn = preview_mode ? 24 : 96;

Либо задавать качество локально:

cylinder(h = 20, d = 10, $fn = 48);

Оптимизация Minkowski

Сумма Минковского перемножает сложность геометрии дочерних объектов. Округление детализированного корпуса сферой с большим $fn создаёт очень тяжёлую сетку.

Для ускорения:

• округлять двумерный контур через offset() до вытягивания;

• снижать детализацию сферы;

• применять minkowski() к простой базовой форме;

• не повторять одинаковую тяжёлую операцию внутри цикла;

• использовать библиотечные методы скругления, оптимизированные для конкретной формы.

Повторное использование

Модуль делает код компактнее, но каждый его вызов всё равно создаёт геометрию. Сто повторений сложной детали требуют расчёта ста экземпляров. При отладке можно уменьшить количество элементов:

draft = true;
count = draft ? 5 : 50;

Диагностика ошибок

Синтаксическая ошибка

Пример:

cube([20, 20, 10])

Отсутствует точка с запятой. Консоль покажет строку, на которой разбор сценария остановился.

Несогласованные скобки

difference() {
    cube(20);
    sphere(10);

Закрывающей фигурной скобки нет. Редактор подсвечивает структуру, а сообщение указывает область ошибки.

Неопределённое значение

cube([length, width, height]);

Если length не определена, она принимает undef, и геометрия не строится корректно.

Для проверки:

assert(!is_undef(length), "length is undefined");

Отрицательный размер

inner = outer - 2 * wall;

При слишком большой стенке inner становится нулём или отрицательным. Проверка:

assert(
    inner > 0,
    "Wall is too thick for the selected size"
);

Совпадающие поверхности

Вычитаемый цилиндр ровно совпадает с верхом и низом пластины:

difference() {
    cube([40, 30, 10]);
    cylinder(h = 10, d = 8);
}

Надёжнее добавить небольшой запас:

difference() {
    cube([40, 30, 10]);

    translate([0, 0, -0.1])
        cylinder(h = 10.2, d = 8);
}

Модель видна после F5, но исчезает после F6

Основные причины:

• импортированная сетка неманифолдна;

• многогранник имеет неверный порядок граней;

• тела соприкасаются без реального пересечения;

• внутренний объект полностью вычитает внешний;

• после вычисления остаётся нулевая толщина;

• двумерная и трёхмерная геометрия смешаны в одной операции.

Неверный масштаб импортированной модели

STL не хранит формально заданную единицу измерения. Если принимающее приложение трактует числа иначе, модель открывается слишком большой или маленькой. Масштаб корректируется:

scale([0.001, 0.001, 0.001])
    import("part.stl");

Но коэффициент должен соответствовать фактическому происхождению файла.

Преимущества и ограничения

Плюсы:

• модель полностью определяется читаемым текстовым исходником;

• размеры и координаты связываются формулами;

• один файл создаёт семейство типоразмеров;

• циклы устраняют ручное копирование повторяющихся элементов;

• модули и библиотеки позволяют повторно использовать геометрию;

• Customizer предоставляет графическое изменение подготовленных параметров;

• командная строка автоматизирует экспорт;

• исходники удобно хранить в Git;

• программа работает локально;

• платная подписка отсутствует;

• поддерживаются Windows, macOS и Linux;

• STL, 3MF, DXF и SVG покрывают распространённые сценарии печати и контурного производства;

• геометрия хорошо подходит для корпусов, креплений и технических приспособлений;

• встроенная консоль показывает ошибки и статистику рендеринга.

Минусы:

• форму нельзя полноценно редактировать перетаскиванием элементов в трёхмерном окне;

• пользователю приходится работать с координатами и синтаксисом;

• пространственная отладка сложнее, чем в визуальном CAD;

• органические поверхности неудобны;

• сложные скругления требуют специальных построений или библиотек;

• тяжёлые булевы операции обрабатываются долго;

• большое $fn резко увеличивает сетку;

• отсутствует развитая среда промышленных сборок;

• нет полного комплекта ассоциативной конструкторской документации;

• импортированный STL остаётся готовой сеткой без истории построения;

• повреждённая сетка способна отображаться в Preview и не проходить Render;

• язык имеет непривычную семантику присваивания;

• некоторые простые графические операции требуют нескольких строк кода.

Сравнение с аналогами

Критерий	OpenSCAD	FreeCAD	Autodesk Fusion	Tinkercad	CadQuery	JSCAD
Основной способ работы	текстовый сценарий	визуальные рабочие среды и Python	эскизы, признаки, прямое и поверхностное моделирование	браузерное перетаскивание форм и Codeblocks	Python-код	JavaScript-код
Геометрическая основа	CSG и полигональный результат	OpenCascade, BREP	промышленное CAD-ядро	простая конструктивная геометрия	OpenCascade, BREP	программируемая CSG-геометрия
Параметры	переменные и формулы	параметры, ограничения и история	ограничения, признаки и конфигурации	размеры и блоки	переменные Python	переменные JavaScript
Прямое редактирование мышью	ограничено просмотром	есть	есть	основа процесса	зависит от внешней среды	ограничено
Сборки	базовая организация отдельными модулями	есть средства сборок	полноценные компоненты и соединения	нет инженерной среды сборок	программные сборки	базовая программная компоновка
Чертежи	ограниченный 2D-экспорт	TechDraw	производственные чертежи	нет	экспорт CAD-геометрии	ограниченный экспорт
Автоматизация	сильная командная строка	Python API	API и облачные процессы	ограниченная	сильная через Python	сильная через JavaScript
Работа без интернета	да	да	приложение связано с облачной системой данных	нет, веб-приложение	да	зависит от среды
Порог входа	выше для непрограммиста	высокий из-за большого интерфейса	средний	низкий	высокий без знания Python	требует JavaScript
Основной сценарий	параметрические технические детали	универсальная инженерная работа	проектирование и производство	обучение и простые модели	программное BREP-моделирование	веб- и JS-генерация

OpenSCAD и FreeCAD

FreeCAD является универсальным параметрическим 3D-редактором. Он создаёт BREP-геометрию, поддерживает двумерные чертежи, Python и специализированные рабочие среды. OpenSCAD проще по концепции: исходник вычисляется как программа, а графическое окно показывает результат.

OpenSCAD удобнее для генератора втулок, корпуса с настраиваемыми размерами или массива повторяющихся отверстий. FreeCAD рациональнее для детали, построенной из размерного эскиза, сложной истории признаков, сборки и выпуска чертежа.

OpenSCAD и Autodesk Fusion

Autodesk Fusion объединяет параметрическое, прямое, поверхностное и сеточное моделирование, сборки, чертежи, расчёты, электронику и CAM. Данные и совместная работа тесно связаны с облачной платформой.

OpenSCAD не конкурирует с таким комплексом по широте. Его преимущество — компактный открытый текстовый проект, локальная работа и простая массовая генерация. Для подготовки ЧПУ, промышленной сборки или поверхностного корпуса Fusion значительно функциональнее.

OpenSCAD и Tinkercad

Tinkercad работает в браузере и рассчитан на простое визуальное комбинирование форм. Codeblocks добавляет блочное создание повторяющихся и параметрических конструкций.

Новичку проще собрать модель в Tinkercad. OpenSCAD требует изучения синтаксиса, но обеспечивает более прозрачные формулы, модули, файлы библиотек и командную генерацию.

OpenSCAD и CadQuery

CadQuery — Python-библиотека параметрического BREP-моделирования на базе OpenCascade. Она экспортирует STEP, AMF, 3MF и STL, поддерживает скетчи, рабочие плоскости и программные сборки. Графический интерфейс предоставляют отдельные среды, включая CQ-editor.

OpenSCAD легче установить и начать использовать как единое настольное приложение. CadQuery предоставляет полноценный Python и геометрию, лучше подходящую для инженерного обмена через STEP. Цена гибкости CadQuery — более сложная программная среда.

OpenSCAD и JSCAD

JSCAD ориентирован на JavaScript и запуск программируемой геометрии в веб-среде. Он удобен разработчикам, которым нужно встроить генератор модели в браузерное приложение.

OpenSCAD предоставляет собственный компактный язык, готовый настольный интерфейс и развитую экосистему .scad-библиотек. JSCAD лучше сочетается с существующим JavaScript-проектом.

OpenSCAD и Blender

Blender работает с полигональными сетками, модификаторами, скульптингом, материалами, визуализацией и анимацией. Он подходит для органических и художественных объектов.

OpenSCAD выигрывает у него в простоте размерной параметризации технической детали. Blender выигрывает в прямом редактировании формы и обработке сложной импортированной сетки.

Отзывы пользователей и профильных изданий

Усреднённая оценка OpenSCAD заметно зависит от опыта пользователя. Программисты часто быстро принимают принцип моделирования кодом, потому что модули, циклы и формулы соответствуют привычному рабочему мышлению. Пользователи визуальных CAD-систем чаще считают даже простое перемещение детали излишне трудоёмким.

Что ценит сообщество

Наиболее часто положительно оцениваются:

• точная параметризация;

• воспроизводимость результата;

• компактные текстовые файлы;

• удобное создание семейств деталей;

• возможность хранить изменения в Git;

• автоматический экспорт;

• свободная лицензия;

• работа без облачной учётной записи;

• библиотеки готовых компонентов;

• пригодность для функциональной 3D-печати.

OpenSCAD особенно ценят за модели, состоящие из математически определяемых форм и повторяющихся элементов. Сценарий удобно передавать другим пользователям: получатель видит не только сетку, но и правила её построения.

Что вызывает критику

Повторяющиеся претензии относятся к:

• высокому порогу входа без опыта программирования;

• продолжительному рендерингу сложных объектов;

• отсутствию прямого визуального редактирования;

• сложным скруглениям;

• ограниченным сборкам;

• неудобству органических форм;

• особенностям языка;

• трудной проверке пространственных зависимостей;

• слабой обратной связи при ошибках геометрического замысла.

Пользовательские исследования подтверждают сложности пространственного понимания, проверки результата, отладки, навигации между кодом и видом и создания органических форм. При этом программный подход выбирают ради точности, абстракций, математических выражений и повторного использования.

Оценка профильных изданий

Профильные технические издания рассматривают OpenSCAD как CAD-инструмент, особенно понятный программистам. Его сильными сторонами называют свободную лицензию, текстовый формат, точную параметризацию и пригодность для функциональной 3D-печати.

К недостаткам относят непривычный для графического CAD процесс, сложность художественных форм, затраты времени на вычисление тяжёлой геометрии и отсутствие функций зрелой универсальной инженерной системы.

Итоговая оценка мнений

OpenSCAD не воспринимается сообществом как универсальная замена визуальному CAD. Его выбирают за конкретный способ работы. Для параметрического корпуса, генератора креплений или семейства адаптеров программа способна оказаться эффективнее тяжёлой инженерной системы. Для сложной сборки или органического объекта тот же способ превращается в ограничение.

Типичные ошибки начинающих

Создание всей модели одним выражением

Длинная цепочка вложенных операций быстро становится нечитаемой:

difference() {
    union() {
        // десятки объектов
    }
    // десятки вычитаний
}

Лучше разделять модель:

module shell() {}
module holes() {}
module posts() {}
module lid() {}

Неясные числа

Плохо:

translate([17.3, 8.5, 2.4])
    cylinder(h = 9.7, d = 3.4);

Понятнее:

wall = 2.4;
screw_diameter = 3.4;
post_height = 9.7;

translate([
    post_x,
    post_y,
    wall
])
    cylinder(
        h = post_height,
        d = screw_diameter
    );

Глобальный чрезмерный $fn

Высокое значение для всего проекта замедляет даже мелкие отверстия, невидимые в готовой детали. Качество следует задавать осознанно и локально.

Экспорт после одного Preview

F5 не заменяет полный расчёт. Перед выводом модели требуется F6 и проверка консоли.

Попытка редактировать STL как параметрическую модель

После импорта видны только треугольники готовой сетки. Изменить исходный диаметр отверстия или историю скругления нельзя. Допускаются масштабирование, обрезка, добавление и вычитание новой геометрии.

Смешивание 2D и 3D

Нельзя вычитать circle() непосредственно из cube(). Круг сначала превращается в трёхмерный цилиндр через linear_extrude() либо заменяется cylinder().

Неверное центрирование

Комбинация объектов с разными значениями center часто приводит к смещению. В проекте полезно выбрать единый принцип: симметричные части строить вокруг начала координат, а высоту отсчитывать от Z = 0.

Поворот вокруг неправильной точки

rotate() вращает геометрию вокруг начала координат. Для поворота вокруг другой точки применяется последовательность:

translate(pivot)
    rotate([0, 0, angle])
        translate(-pivot)
            object();

Игнорирование печатных зазоров

Точное совпадение размеров бортика и паза не создаёт физически собираемую пару. Зазор должен быть отдельным параметром.

Частые вопросы

OpenSCAD бесплатен?

Да. Программа распространяется по GNU GPL и не требует платной подписки.

Есть ли русский интерфейс?

Русская локализация добавлена в программу. Названия функций и модулей языка остаются английскими: cube(), translate(), difference() и другие.

Нужно ли знать программирование?

Для первого куба достаточно одной команды. Для полноценных параметрических моделей требуются переменные, координаты, модули, условия и циклы. Опыт программирования ускоряет обучение, но не является обязательным.

Подходит ли OpenSCAD для 3D-печати?

Да. Программа создаёт твёрдотельную геометрию и экспортирует распространённые трёхмерные форматы. Подготовка слоёв и G-code выполняется в отдельном слайсере.

Создаёт ли OpenSCAD G-code?

Нет. OpenSCAD создаёт модель, а не управляющую программу принтера.

Можно ли открыть STL?

Да. STL импортируется через import() и участвует в преобразованиях и булевых операциях.

Можно ли изменить размеры импортированного STL?

Всю модель можно масштабировать. Отдельный исходный параметр, например диаметр уже сформированного отверстия, недоступен, поскольку STL не содержит истории построения.

Чем F5 отличается от F6?

F5 формирует быстрый предварительный вид. F6 рассчитывает итоговую геометрию. Полный рендеринг необходим для проверки перед экспортом.

Можно ли сделать резьбу?

Да, геометрию резьбы создают специальным сценарием или библиотекой. Детализированная резьба увеличивает количество граней и время рендеринга.

Можно ли создавать шестерни?

Да. Профиль зубчатого колеса генерируется математически либо готовым библиотечным модулем. Параметрами служат число зубьев, модуль, толщина и диаметр отверстия.

Поддерживает ли программа сборки?

Отдельные компоненты можно организовывать модулями, файлами и преобразованиями. Специализированной промышленной среды сборок с сопряжениями и спецификацией OpenSCAD не предоставляет.

Сохраняется ли цвет в STL?

Нет. color() предназначен прежде всего для отображения в окне программы. STL описывает геометрию сетки.

Можно ли пользоваться внешним редактором?

Да. OpenSCAD отслеживает изменения файла и может автоматически обновлять предварительный просмотр. Внешняя среда может предоставлять собственное автодополнение и анализ синтаксиса.

Подходит ли .scad для Git?

Да. Это текстовый формат, поэтому системы контроля изменений показывают добавленные и удалённые строки. Для удобного сравнения следует соблюдать стабильное форматирование и не хранить все части модели в одной длинной строке.

Можно ли автоматически создать несколько STL?

Да. Командная строка принимает выходной файл и переопределённые параметры. Цикл оболочки запускает OpenSCAD для каждого типоразмера.

Почему модель рендерится долго?

Основные причины — высокая детализация кривых, тяжёлые minkowski(), большое число повторений, сложные булевы операции и детализированные импортированные сетки.

Итоговая оценка OpenSCAD

OpenSCAD рационально выбирать для модели, которую проще описать правилами, чем нарисовать мышью. Корпус с вычисляемой полостью, набор втулок, перфорированная панель, генератор органайзеров и серия креплений соответствуют его сильным сторонам.

Новичку без опыта написания кода придётся освоить координаты, синтаксис и конструктивную геометрию. После этого программа даёт точный и воспроизводимый процесс: параметры находятся в начале файла, повторяющиеся элементы создаются циклами, части оформляются модулями, а готовые варианты формируются автоматически.

Для органических форм, интерактивного редактирования, сложных сборок и производственных чертежей требуется другой CAD-инструмент. OpenSCAD не пытается заменить такие системы. Его специализация — программируемая параметрическая геометрия, текстовые исходники и автоматическая генерация технических моделей.