nexoniarz/Fry3DX
Watch
1
0
Fork
You've already forked Fry3DX
 0
mirror of https://github.com/Nexoniarz/Fry3DX.git synced 2026-11-03 04:24:26 +00:00
Code Issues Projects Releases Packages Wiki Activity
Fry3DX/src/app_panels.cpp

2054 lines
120 KiB
C++
Raw Blame History

// Fry3DX: the panels: layers, properties, menus, the commands and their keys.
#include "app.h"
using namespace fry;
namespace stdfs = std::filesystem;
namespace fryapp {
// ───────────────────────────── layers: folders and going to things ─────────────────────────────
auto App::findFolder(uint32_t id) -> Folder* {
for (Folder& f : scene_.folders)
if (f.id == id) return &f;
return nullptr;
}
auto App::inFolder(uint32_t folder, uint32_t within) -> bool { // (folder is within, or inside it somewhere)
for (int n = 0; folder && n < 256; ++n) {
if (folder == within) return true;
const Folder* f = findFolder(folder);
folder = f ? f->parent : 0;
}
return false;
}
auto App::objectsIn(uint32_t folder) -> std::set<uint32_t> {
std::set<uint32_t> out;
for (const Object& o : scene_.objects)
if (inFolder(o.folder, folder)) out.insert(o.id);
return out;
}
// The camera brought round to these (as framing them, but keeping the way it looks).
auto App::goTo(const std::set<uint32_t>& ids) -> void {
glm::vec3 lo(1e30f), hi(-1e30f);
for (const Object& o : scene_.objects)
if (ids.count(o.id)) {
const glm::mat4 m = objectMatrix(o);
for (const glm::vec3& v : o.mesh.verts) {
const glm::vec3 w(m * glm::vec4(v, 1.0f));
lo = glm::min(lo, w), hi = glm::max(hi, w);
}
}
if (lo.x > hi.x) return;
frameBox(lo, hi);
}
// The picked objects into a new folder (Ctrl+G): a group, picked and moved together.
auto App::groupSelected() -> void {
if (mode_ == Mode::Edit) leaveEdit();
if (selected_.empty()) return say("Pick the objects to put in a folder first");
pushUndo();
Folder f;
f.id = scene_.nextId++;
int n = 1;
while (std::any_of(scene_.folders.begin(), scene_.folders.end(), [&](const Folder& g) { return g.name == std::format("Group {}", n); })) ++n;
f.name = std::format("Group {}", n);
if (const Object* a = find(active_)) f.parent = a->folder; // (where the last picked was)
for (Object& o : scene_.objects)
if (selected_.count(o.id)) o.folder = f.id;
scene_.folders.push_back(f);
renamingFolder_ = f.id, std::snprintf(renameBuf_, sizeof renameBuf_, "%s", f.name.c_str());
say(f.name + ": click it to pick all of it; type a name");
}
// Ungrouped: what's inside goes up a level, the folder goes.
auto App::ungroup(uint32_t id) -> void {
const Folder* f = findFolder(id);
if (!f) return;
pushUndo();
const uint32_t up = f->parent;
for (Object& o : scene_.objects)
if (o.folder == id) o.folder = up;
for (Folder& g : scene_.folders)
if (g.parent == id) g.parent = up;
std::erase_if(scene_.folders, [&](const Folder& g) { return g.id == id; });
}
auto App::deleteFolder(uint32_t id) -> void {
pushUndo();
const auto ids = objectsIn(id);
std::erase_if(scene_.objects, [&](const Object& o) { return ids.count(o.id) > 0; });
std::erase_if(scene_.folders, [&](const Folder& g) { return inFolder(g.id, id); });
for (uint32_t i : ids) selected_.erase(i);
}
// A folder's eye or lock: all in it the same.
auto App::showFolder(Folder& f, bool on) -> void {
pushUndo();
for (Folder& g : scene_.folders)
if (inFolder(g.id, f.id)) g.visible = on;
for (Object& o : scene_.objects)
if (inFolder(o.folder, f.id)) o.visible = on;
}
auto App::lockFolder(Folder& f, bool on) -> void {
pushUndo();
for (Folder& g : scene_.folders)
if (inFolder(g.id, f.id)) g.locked = on;
for (Object& o : scene_.objects)
if (inFolder(o.folder, f.id)) o.locked = on;
}
auto App::moveToFolder(const std::set<uint32_t>& ids, uint32_t folder) -> void {
pushUndo();
for (Object& o : scene_.objects)
if (ids.count(o.id)) o.folder = folder;
}
// Only these shown (again: everything shown).
auto App::showOnly(const std::set<uint32_t>& ids) -> void {
pushUndo();
const bool already = std::all_of(scene_.objects.begin(), scene_.objects.end(), [&](const Object& o) { return o.visible == (ids.count(o.id) > 0); });
for (Object& o : scene_.objects) o.visible = already || ids.count(o.id);
for (Folder& f : scene_.folders) f.visible = true;
say(already ? "Everything shown again" : "Only that shown (do it again to show everything)");
}
auto App::folderMenu(uint32_t into, const std::set<uint32_t>& ids, int depth) -> void { // (Move to folder: the folders inside `into`)
for (const Folder& f : scene_.folders)
if (f.parent == into) {
const std::string label = std::string(size_t(depth) * 3, ' ') + f.name;
if (ImGui::MenuItem(label.c_str())) moveToFolder(ids, f.id);
folderMenu(f.id, ids, depth + 1);
}
}
// What a right-click on an object (or the picked ones) offers.
auto App::objectMenu(Object& o) -> void {
const std::set<uint32_t> ids = selected_.count(o.id) ? selected_ : std::set<uint32_t>{o.id};
if (ImGui::MenuItem("Go to it", "F")) goTo(ids);
if (ImGui::MenuItem("Rename")) renaming_ = o.id, std::snprintf(renameBuf_, sizeof renameBuf_, "%s", o.name.c_str());
if (ImGui::MenuItem("Duplicate", "Ctrl+D")) selected_ = ids, active_ = o.id, duplicateSelected();
if (ImGui::MenuItem("Show only this (again: all)")) showOnly(ids);
if (ImGui::BeginMenu("Move to folder")) {
if (ImGui::MenuItem("(the top, no folder)")) moveToFolder(ids, 0);
folderMenu(0, ids);
ImGui::Separator();
if (ImGui::MenuItem("A new folder", "Ctrl+G")) selected_ = ids, active_ = o.id, groupSelected();
ImGui::EndMenu();
}
ImGui::Separator();
if (ImGui::MenuItem("Delete", "Del")) selected_ = ids, deleteSelected();
}
// A row's show / hide or lock button: the picture of how it is now, dim when it's the usual way.
auto App::rowToggle(const char* id, Icon icon, bool usual, const char* tip) -> bool {
const ImVec2 at = ImGui::GetCursorScreenPos();
const float h = ImGui::GetFrameHeight() - 4;
const bool pressed = ImGui::InvisibleButton(id, ImVec2(h, h));
const ImU32 col = ImGui::IsItemHovered() ? kHot : usual ? IM_COL32(200, 200, 205, 150) : ImGui::GetColorU32(accentText());
drawIcon(ImGui::GetWindowDrawList(), icon, ImVec2(at.x + h * 0.1f, at.y + h * 0.1f), h * 0.8f, col);
if (ImGui::IsItemHovered()) ImGui::SetTooltip("%s", tip);
return pressed;
}
// The ⌖ button at the end of a row: brings the camera to it.
auto App::goButton(const char* tip) -> bool {
const ImVec2 at = ImGui::GetCursorScreenPos();
const float h = ImGui::GetFrameHeight() - 4;
const bool pressed = ImGui::InvisibleButton("##go", ImVec2(h, h));
const ImU32 col = ImGui::IsItemHovered() ? kHot : IM_COL32(200, 200, 205, 200);
const ImVec2 c(at.x + h * 0.5f, at.y + h * 0.5f);
ImDrawList* dl = ImGui::GetWindowDrawList();
dl->AddCircle(c, h * 0.3f, col, 16, 1.5f);
dl->AddLine(ImVec2(c.x - h * 0.48f, c.y), ImVec2(c.x - h * 0.16f, c.y), col, 1.5f), dl->AddLine(ImVec2(c.x + h * 0.16f, c.y), ImVec2(c.x + h * 0.48f, c.y), col, 1.5f);
dl->AddLine(ImVec2(c.x, c.y - h * 0.48f), ImVec2(c.x, c.y - h * 0.16f), col, 1.5f), dl->AddLine(ImVec2(c.x, c.y + h * 0.16f), ImVec2(c.x, c.y + h * 0.48f), col, 1.5f);
if (ImGui::IsItemHovered()) ImGui::SetTooltip("%s", tip);
return pressed;
}
// Rows for what's in a folder (0: the top): its folders, then its objects.
auto App::layerRows(uint32_t parent, int depth) -> void {
const float indent = float(depth) * 14.0f;
// (copies of the ids: rows may change the lists)
std::vector<uint32_t> folders, objects;
for (const Folder& f : scene_.folders)
if (f.parent == parent) folders.push_back(f.id);
for (const Object& o : scene_.objects)
if (o.folder == parent) objects.push_back(o.id);
for (uint32_t id : folders) {
Folder* f = findFolder(id);
if (!f) continue;
const auto inside = objectsIn(id);
ImGui::PushID(int(id) + 1000000);
ImGui::TableNextRow();
ImGui::TableNextColumn();
if (rowToggle("##eye", f->visible ? Icon::Eye : Icon::EyeShut, f->visible, f->visible ? "Hide all in it" : "Show all in it")) showFolder(*f, !f->visible);
ImGui::TableNextColumn();
if (rowToggle("##lock", f->locked ? Icon::Lock : Icon::Unlock, !f->locked, f->locked ? "Unlock all in it" : "Lock all in it")) lockFolder(*f, !f->locked);
ImGui::TableNextColumn();
ImGui::Indent(indent + 1);
if (ImGui::ArrowButton("##open", f->open ? ImGuiDir_Down : ImGuiDir_Right)) f->open = !f->open;
ImGui::SameLine(0, 4);
const bool picked = !inside.empty() && std::all_of(inside.begin(), inside.end(), [&](uint32_t i) { return selected_.count(i) > 0; });
if (renamingFolder_ == id) {
ImGui::SetNextItemWidth(-1);
if (!ImGui::IsAnyItemActive()) ImGui::SetKeyboardFocusHere();
if (ImGui::InputText("##rename", renameBuf_, sizeof renameBuf_, ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_AutoSelectAll)) {
if (renameBuf_[0]) f->name = renameBuf_;
renamingFolder_ = 0, dirty_ = true;
}
if (ImGui::IsItemDeactivated()) renamingFolder_ = 0;
} else {
ImGui::PushStyleColor(ImGuiCol_Text, accentText());
const std::string label = std::format("{} ({})", f->name, inside.size());
if (ImGui::Selectable(label.c_str(), picked, ImGuiSelectableFlags_AllowDoubleClick)) { // a folder is a group: all of it picked
if (mode_ == Mode::Edit) leaveEdit();
if (ImGui::GetIO().KeyCtrl || ImGui::GetIO().KeyShift) selected_.insert(inside.begin(), inside.end());
else selected_ = inside;
if (!inside.empty()) active_ = *inside.rbegin();
activeRef_ = 0;
if (ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left)) renamingFolder_ = id, std::snprintf(renameBuf_, sizeof renameBuf_, "%s", f->name.c_str());
}
ImGui::PopStyleColor();
if (ImGui::BeginDragDropSource()) {
ImGui::SetDragDropPayload("FRY_FOLDER", &id, sizeof id);
ImGui::Text("%s", f->name.c_str());
ImGui::EndDragDropSource();
}
if (ImGui::BeginDragDropTarget()) {
if (const ImGuiPayload* p = ImGui::AcceptDragDropPayload("FRY_OBJECT")) {
const uint32_t oid = *static_cast<const uint32_t*>(p->Data);
moveToFolder(selected_.count(oid) ? selected_ : std::set<uint32_t>{oid}, id);
}
if (const ImGuiPayload* p = ImGui::AcceptDragDropPayload("FRY_FOLDER")) {
const uint32_t fid = *static_cast<const uint32_t*>(p->Data);
if (Folder* g = findFolder(fid); g && !inFolder(id, fid)) pushUndo(), g->parent = id; // (not into itself)
}
ImGui::EndDragDropTarget();
}
if (ImGui::IsItemHovered() && !ImGui::IsMouseDragging(ImGuiMouseButton_Left)) ImGui::SetTooltip("Click: pick all of it (a group). Double-click: rename. Drag things onto it.");
if (ImGui::BeginPopupContextItem("folder")) {
if (ImGui::MenuItem("Go to it")) goTo(inside);
if (ImGui::MenuItem("Pick all of it")) selected_ = inside;
if (ImGui::MenuItem("Rename")) renamingFolder_ = id, std::snprintf(renameBuf_, sizeof renameBuf_, "%s", f->name.c_str());
if (ImGui::MenuItem("Show only this (again: all)")) showOnly(inside);
if (ImGui::MenuItem("A folder inside it")) {
pushUndo();
Folder g;
g.id = scene_.nextId++, g.name = "Folder", g.parent = id;
scene_.folders.push_back(g);
f = findFolder(id), f->open = true;
renamingFolder_ = g.id, std::snprintf(renameBuf_, sizeof renameBuf_, "%s", g.name.c_str());
}
if (ImGui::MenuItem("Take it to the top") && f->parent) pushUndo(), f->parent = 0;
ImGui::Separator();
if (ImGui::MenuItem("Ungroup (keep what's in it)")) ungroup(id);
if (ImGui::MenuItem("Delete it and all in it")) deleteFolder(id);
ImGui::EndPopup();
}
}
ImGui::Unindent(indent + 1);
ImGui::TableNextColumn();
if (goButton("Go to it: the camera comes round to all of it")) goTo(inside);
ImGui::PopID();
if ((f = findFolder(id)) && f->open) layerRows(id, depth + 1);
}
for (uint32_t id : objects) {
Object* op = find(id);
if (!op) continue;
Object& o = *op;
ImGui::PushID(int(o.id));
ImGui::TableNextRow();
ImGui::TableNextColumn();
if (rowToggle("##eye", o.visible ? Icon::Eye : Icon::EyeShut, o.visible, o.visible ? "Shown (click to hide)" : "Hidden (click to show)")) o.visible = !o.visible, dirty_ = true;
ImGui::TableNextColumn();
if (rowToggle("##lock", o.locked ? Icon::Lock : Icon::Unlock, !o.locked, o.locked ? "Locked: can't be moved or changed (click to unlock)" : "Click to lock")) o.locked = !o.locked, dirty_ = true;
ImGui::TableNextColumn();
ImGui::Indent(indent + 1);
if (renaming_ == o.id) {
ImGui::SetNextItemWidth(-1);
if (!ImGui::IsAnyItemActive()) ImGui::SetKeyboardFocusHere();
if (ImGui::InputText("##rename", renameBuf_, sizeof renameBuf_, ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_AutoSelectAll)) {
pushUndo();
if (renameBuf_[0]) o.name = renameBuf_;
renaming_ = 0;
}
if (ImGui::IsItemDeactivated()) renaming_ = 0;
} else {
ImGui::PushStyleColor(ImGuiCol_Text, o.visible ? ImGui::GetStyleColorVec4(ImGuiCol_Text) : ImGui::GetStyleColorVec4(ImGuiCol_TextDisabled));
if (ImGui::Selectable(o.name.c_str(), selected_.count(o.id) > 0, ImGuiSelectableFlags_AllowDoubleClick)) {
if (mode_ == Mode::Edit && o.id != active_) leaveEdit();
if (ImGui::GetIO().KeyCtrl || ImGui::GetIO().KeyShift) selected_.count(o.id) ? (void)selected_.erase(o.id) : (void)selected_.insert(o.id);
else selected_ = {o.id};
active_ = o.id, activeRef_ = 0;
if (ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left)) renaming_ = o.id, std::snprintf(renameBuf_, sizeof renameBuf_, "%s", o.name.c_str());
}
ImGui::PopStyleColor();
if (ImGui::BeginDragDropSource()) {
ImGui::SetDragDropPayload("FRY_OBJECT", &id, sizeof id);
ImGui::Text("%s", selected_.count(id) && selected_.size() > 1 ? std::format("{} objects", selected_.size()).c_str() : o.name.c_str());
ImGui::EndDragDropSource();
}
if (ImGui::IsItemHovered() && !ImGui::IsMouseDragging(ImGuiMouseButton_Left)) ImGui::SetTooltip("Double-click to rename; drag onto a folder; right-click for more");
if (ImGui::BeginPopupContextItem("object")) {
objectMenu(o);
ImGui::EndPopup();
}
}
ImGui::Unindent(indent + 1);
ImGui::TableNextColumn();
if (goButton("Go to it: the camera comes round to it")) goTo({id});
ImGui::PopID();
}
}
// ───────────────────────────── panels ─────────────────────────────
auto App::setupUi() -> void {
keel::ui::setPixelScale(touchScale());
if (iniPath_.empty()) {
touchMode_ = fry_touch.b();
iniPath_ = keel::prefPath() + (touchMode_ ? "layout_phone.ini" : "layout_v3.ini");
ImGui::GetIO().IniFilename = iniPath_.c_str();
if (stdfs::exists(iniPath_)) ImGui::LoadIniSettingsFromDisk(iniPath_.c_str());
}
if (fry_theme.i() != appliedTheme_) appliedTheme_ = fry_theme.i(), keel::ui::setAppearance(keel::ui::Appearance(std::clamp(appliedTheme_, 0, 2)));
if (styled_) return;
styled_ = true;
ImGui::GetStyle().FontScaleDpi = 0.92f; // (the look itself: keel/ui, Niveus)
}
// The least a panel can be and still read right (its words, its rows), by the font's size.
auto App::panelMin(std::string_view name) -> ImVec2 {
const float f = ImGui::GetFontSize();
if (name == "Toolbox") return {15.5f * f, 9 * f};
if (name == "Tool options") return {15.5f * f, 8 * f};
if (name == "Properties") return {23 * f, 12 * f};
if (name == "Layers") return {20 * f, 8 * f};
if (name == "Picture") return {18 * f, 14 * f};
if (name == "Script") return {30 * f, 16 * f};
return {0, 0};
}
// Docked panels kept at their least size: where a split leaves one side smaller, the split
// moves (when the other side has room to give). ImGui's own splitters know only one least
// size for everything. Gives what the node needs.
auto App::keepMinSizes(ImGuiDockNode* n) -> ImVec2 {
if (!n) return {0, 0};
if (n->IsLeafNode()) {
const float f = ImGui::GetFontSize();
ImVec2 need = n->IsCentralNode() ? ImVec2(16 * f, 12 * f) : ImVec2(0, 0);
for (ImGuiWindow* w : n->Windows) need = ImMax(need, panelMin(w->Name));
if (need.y > 0 && !n->IsCentralNode()) need.y += ImGui::GetFrameHeight(); // (its tab)
return need;
}
ImGuiDockNode *a = n->ChildNodes[0], *b = n->ChildNodes[1];
const ImVec2 na = keepMinSizes(a), nb = keepMinSizes(b);
if (!a->IsVisible) return nb;
if (!b->IsVisible) return na;
const int axis = n->SplitAxis;
const float gap = ImGui::GetStyle().DockingSeparatorSize, room = n->Size[axis] - gap;
float sa = a->Size[axis];
if (sa < na[axis] && room - na[axis] >= nb[axis]) sa = na[axis];
else if (room - sa < nb[axis] && room - nb[axis] >= na[axis]) sa = room - nb[axis];
if (sa != a->Size[axis]) a->SizeRef[axis] = sa, b->SizeRef[axis] = room - sa;
ImVec2 need = ImMax(na, nb);
need[axis] = na[axis] + nb[axis] + gap;
return need;
}
auto App::defaultLayout(ImGuiID dock) -> void {
layoutDone_ = true;
ImGuiDockNode* node = ImGui::DockBuilderGetNode(dock);
if (!touch() && !std::exchange(layoutAgain_, false) && node && (node->IsSplitNode() || node->Windows.Size)) return; // (the user's own, from the .ini)
ImGui::DockBuilderRemoveNodeChildNodes(dock);
ImGui::DockBuilderSetNodeSize(dock, ImGui::GetMainViewport()->WorkSize); // (splits are shares of this)
ImGuiID center = dock;
if (touch() && portrait_) { // a phone held upright: the view on top, the panels as tabs under it
const ImGuiID bottom = ImGui::DockBuilderSplitNode(center, ImGuiDir_Down, 0.36f, nullptr, &center);
const ImVec2 size = ImGui::GetMainViewport()->WorkSize;
ImGui::DockBuilderSetNodeSize(bottom, ImVec2(size.x, size.y * 0.36f));
for (const char* w : {"Toolbox", "Tool options", "Properties", "Layers", "Picture"}) ImGui::DockBuilderDockWindow(w, bottom);
ImGui::DockBuilderFinish(dock);
showToolbox_ = true; // (its tab first)
return;
}
if (touch()) { // a phone: tools down the left, the panels on the right (shown when asked for)
ImGuiID left = ImGui::DockBuilderSplitNode(center, ImGuiDir_Left, 0.2f, nullptr, &center);
const ImGuiID leftBottom = ImGui::DockBuilderSplitNode(left, ImGuiDir_Down, 0.45f, nullptr, &left);
const ImGuiID right = ImGui::DockBuilderSplitNode(center, ImGuiDir_Right, 0.36f, nullptr, &center);
ImGui::DockBuilderDockWindow("Toolbox", left);
ImGui::DockBuilderDockWindow("Tool options", leftBottom);
ImGui::DockBuilderDockWindow("Properties", right);
ImGui::DockBuilderDockWindow("Layers", right);
ImGui::DockBuilderDockWindow("Picture", right);
return ImGui::DockBuilderFinish(dock);
}
// (shares of the window, but never less than the panels' least sizes)
const float wide = ImGui::GetMainViewport()->WorkSize.x, leftShare = std::min(0.3f, std::max(0.14f, (panelMin("Toolbox").x + 8) / wide));
const float rightShare = std::min(0.45f, std::max(0.22f, (panelMin("Properties").x + 8) / (wide * (1 - leftShare))));
ImGuiID left = ImGui::DockBuilderSplitNode(center, ImGuiDir_Left, leftShare, nullptr, &center);
const ImGuiID leftBottom = ImGui::DockBuilderSplitNode(left, ImGuiDir_Down, 0.5f, nullptr, &left);
ImGuiID right = ImGui::DockBuilderSplitNode(center, ImGuiDir_Right, rightShare, nullptr, &center);
const ImGuiID rightBottom = ImGui::DockBuilderSplitNode(right, ImGuiDir_Down, 0.66f, nullptr, &right);
const ImGuiID bottom = ImGui::DockBuilderSplitNode(center, ImGuiDir_Down, 0.04f, nullptr, &center);
const ImGuiID picture = ImGui::DockBuilderSplitNode(center, ImGuiDir_Right, 0.45f, nullptr, &center); // (the Paint tab's)
ImGui::DockBuilderDockWindow("Picture", picture);
ImGui::DockBuilderDockWindow("Script", picture);
ImGui::DockBuilderDockWindow("Toolbox", left);
ImGui::DockBuilderDockWindow("Tool options", leftBottom);
ImGui::DockBuilderDockWindow("Layers", right);
ImGui::DockBuilderDockWindow("Properties", rightBottom);
ImGui::DockBuilderDockWindow("Status", bottom);
if (ImGuiDockNode* b = ImGui::DockBuilderGetNode(bottom)) b->SetLocalFlags(ImGuiDockNodeFlags_NoTabBar);
ImGui::DockBuilderFinish(dock);
}
// ───────────────────────────── commands ─────────────────────────────
// Everything that can be done, by name: for the command search, keys of your own, the pies.
auto App::buildCommands() -> void {
commands_.clear();
auto add = [&](std::string id, std::string name, std::string group, std::string keys, std::function<void()> run, std::function<bool()> ok = {}, std::string words = {}) {
commands_.push_back({std::move(id), std::move(name), std::move(group), std::move(keys), std::move(run), std::move(ok), std::move(words)});
};
auto editing = [this] { return mode_ == Mode::Edit; };
auto picked = [this] { return !selected_.empty(); };
auto many = [this] { return selected_.size() >= 2 && mode_ == Mode::Object; };
auto model = [this] { return tab_ == Tab::Model; };
add("file.new", "New", "File", "Ctrl+N", [this] { whenSaved(2); }, {}, "empty start");
add("file.open", "Open...", "File", "Ctrl+O", [this] { whenSaved(3); }, {}, "load fry");
add("file.import", "Import a model (STL, OBJ, 3MF, glTF)...", "File", "Ctrl+Shift+O", [this] { dialog(12); }, {}, "load mesh stl obj 3mf");
add("file.save", "Save", "File", "Ctrl+S", [this] { path_.empty() ? dialog(2) : void(saveFile(path_)); });
add("file.saveas", "Save as...", "File", "Ctrl+Shift+S", [this] { dialog(2); });
add("file.export", "Export (GLB, glTF, OBJ, STL, PLY, 3MF, FBX)...", "File", "Ctrl+E", [this] { dialog(3); }, {}, "stl obj gltf glb ply fbx 3mf print");
add("file.picture", "Save a picture of the view...", "File", "F12", [this] { dialog(5); }, {}, "screenshot render png");
add("file.recover", "Recover autosaved work...", "File", "", [this] { findAutosaves(), showRecover_ = !recover_.empty(); });
add("file.quit", "Quit", "File", "Ctrl+Q", [this] { whenSaved(1); }, {}, "exit close");
add("edit.undo", "Undo", "Edit", "Ctrl+Z", [this] { undo(); }, [this] { return !undo_.empty(); });
add("edit.redo", "Redo", "Edit", "Ctrl+Y", [this] { redo(); }, [this] { return !redo_.empty(); });
add("edit.history", "Undo history", "Edit", "", [this] { showHistory_ = true; }, {}, "steps back");
add("edit.duplicate", "Duplicate", "Edit", "Ctrl+D", [this] { duplicateSelected(); }, [=, this] { return picked() && mode_ == Mode::Object; }, "copy clone");
add("edit.join", "Join into one", "Edit", "Ctrl+J", [this] { joinSelected(); }, many, "merge objects");
add("edit.delete", "Delete", "Edit", "Del", [this] { deleteSelected(); }, {}, "remove erase");
add("edit.shape", "Edit the shape / stop", "Edit", "Tab", [this] { mode_ == Mode::Edit ? leaveEdit() : enterEdit(); }, [=] { return editing() || picked(); }, "edit mode points faces");
add("select.all", "Select all", "Select", "Ctrl+A", [this] { selectAll(); });
add("select.none", "Select none", "Select", "Alt+A", [this] { selectNone(); }, {}, "deselect");
add("select.invert", "Invert the selection", "Select", "Ctrl+I", [this] { invertSelection(); });
add("select.grow", "Select more (grow)", "Select", "Ctrl +", [this] { growSelection(); }, editing);
add("select.shrink", "Select less (shrink)", "Select", "Ctrl -", [this] { shrinkSelection(); }, editing);
add("select.linked", "Select everything joined to it", "Select", "L", [this] { selectLinked(); }, editing, "linked connected");
add("select.similar", "Select similar (faces the same way; objects of the same shape)", "Select", "Shift+G", [this] { selectSimilar(); }, [=] { return editing() || picked(); }, "same normal size copies");
add("select.loop", "Select whole loops (of the picked edges)", "Select", "", [this] { loopsOfSelected(false); }, editing, "edge loop");
add("select.ring", "Select rings (across the picked edges)", "Select", "", [this] { loopsOfSelected(true); }, editing, "edge ring");
for (const auto& [t, n] : std::initializer_list<std::pair<SelShape, const char*>>{{SelShape::Box, "box"}, {SelShape::Brush, "brush"}, {SelShape::Lasso, "lasso"}})
add(std::string("select.with.") + n, std::string("Select with a ") + n, "Select", "", [this, t] { selShape_ = t; });
for (const ShapeRecipe& r : shapeRecipes())
add(std::string("add.") + r.id, std::string("Add ") + (r.starter ? "a starter " : "a ") + r.name, "Add", "", [this, id = std::string(r.id)] { setTab(Tab::Model), addShape(id); }, {},
r.starter ? "starter model" : "shape primitive");
add("add.text", "Add text (3D letters)...", "Add", "", [this] { setTab(Tab::Model), showText_ = true; }, {}, "font letters words label name");
add("add.draw", "Draw a shape", "Add", "D", [this] { if (mode_ == Mode::Edit) leaveEdit(); setTool(Tool::Draw); }, {}, "sketch outline polygon");
add("add.picture", "Add a reference picture...", "Add", "", [this] { dialog(4); }, {}, "image background blueprint");
add("object.goto", "Go to it (the camera)", "Object", "F", [this] { goTo(selected_); }, picked, "frame focus");
add("object.copies", "Make copies (in a row, round, along a path)...", "Object", "", [this] { showCopies_ = true; }, picked, "array repeat pattern circular curve");
add("object.group", "Group into a folder", "Object", "Ctrl+G", [this] { groupSelected(); }, picked);
add("object.add", "Add them together", "Object", "Ctrl+Shift++", [this] { combineSelected(Combine::Add); }, many, "boolean union");
add("object.subtract", "Take the others out of it", "Object", "Ctrl+Shift+-", [this] { combineSelected(Combine::Subtract); }, many, "boolean difference cut");
add("object.overlap", "Keep only where they overlap", "Object", "", [this] { combineSelected(Combine::Overlap); }, many, "boolean intersect");
add("object.thicken", "Make it thick (or hollow)...", "Object", "", [this] { showThicken_ = true; }, picked, "shell solidify wall");
add("object.cleanflat", "Join flat faces side by side", "Object", "", [this] { cleanFlatFaces(); }, picked, "dissolve tidy");
add("object.spin", "Spin (turn its outline round an axis)...", "Object", "", [this] { showSpin_ = true; }, [this] { return !selected_.empty(); }, "lathe screw revolve");
add("tools.measure", "Measure between two points", "Tools", "", [this] {
if (tab_ != Tab::Model && tab_ != Tab::Print) setTab(Tab::Model);
if (mode_ == Mode::Edit) leaveEdit();
printTool_ = PrintTool::Measure, measure_.clear();
say("Measure: click two points (corners catch the mouse); Esc: done");
}, {}, "ruler distance length dimension how far");
add("object.repair", "Repair for printing (close holes, fix faces)", "Print", "", [this] { repairSelected(); }, picked, "fix manifold watertight holes");
add("object.scale", "Print size: scale, fit the plate, fix units...", "Print", "", [this] { setTab(Tab::Print), showPrintSize_ = true; }, picked, "resize fit dimensions percent scaler");
for (const ToolInfo& t : kTools)
add(std::string("tool.") + t.name, std::string("Tool: ") + t.name, "Tools", t.key, [this, tool = t.tool, obj = t.objectMode] {
if (tab_ != Tab::Model) setTab(Tab::Model);
if (!obj && mode_ != Mode::Edit) enterEdit();
setTool(tool);
});
add("shape.subdivide", "Cut every face in four", "Shape", "", [this] { subdivideNow(false); }, editing, "subdivide");
add("shape.smoothall", "Smooth it all (cut and round)", "Shape", "", [this] { subdivideNow(true); }, editing, "subdivision surface");
add("shape.merge", "Merge points", "Shape", "M", [this] { mergeNow(); }, editing, "weld collapse");
add("shape.face", "Make a face", "Shape", "", [this] { makeFaceNow(); }, editing, "fill");
add("shape.flip", "Flip faces", "Shape", "", [this] { flipNow(); }, editing, "normals reverse");
add("shape.smooth", "Smooth points", "Shape", "", [this] { smoothPointsNow(); }, editing, "relax");
add("shape.push", "Push out / pull in...", "Shape", "Alt+S", [this] { startPush(); }, editing, "shrink fatten inflate");
add("shape.bridge", "Bridge two faces", "Shape", "", [this] { bridgeNow(); }, editing, "tunnel connect");
add("shape.soft", "Soft selection on / off", "Shape", "Shift+O", [this] { softSel_ = !softSel_; }, {}, "proportional falloff");
add("shape.separate", "Make into its own object", "Shape", "P", [this] { separateSelected(); }, editing, "separate split");
add("paint.mirror", "Paint both sides (mirrored)", "Paint", "", [this] { paintMirror_ = !paintMirror_, say(paintMirror_ ? "Painting both sides" : "Painting one side"); }, {}, "symmetry symmetric");
add("paint.stencil", "Draw a paint stencil (paint only inside it)", "Paint", "", [this] { setTab(Tab::Paint), drawingStencil_ = true, stencil_.clear(); }, {}, "mask masking tape area");
add("object.cutEditable", "Cut out, editable (the cutters stay, the hole follows them)", "Object", "", [this] { cutEditable(); }, many, "boolean subtract difference hole non-destructive live");
add("shape.crease", "Crease the picked edges (stay sharp when smoothed)", "Shape", "Shift+E", [this] { creaseSelected(); }, editing, "sharp hard edge subdivision smooth");
add("shape.slide", "Slide the points along their edges...", "Shape", "Alt+G", [this] { startSlide(); }, editing, "edge slide vertex slide");
add("shape.mirror", "Mirror editing (both sides change together)", "Shape", "", [this] { liveMirror_ = !liveMirror_, say(liveMirror_ ? "Mirror editing on: both sides change together" : "Mirror editing off"); }, {}, "symmetry symmetric x");
add("view.solid", "Show: solid", "View", "Z", [this] { shading_ = Shading::Solid; });
add("view.rendered", "Show: rendered (sky, sun, shadows)", "View", "Z", [this] { shading_ = Shading::Rendered; });
add("view.wire", "Show: wireframe", "View", "Shift+Z", [this] { shading_ = Shading::Wire; });
add("view.xray", "X-ray on / off", "View", "Alt+Z", [this] { xray_ = !xray_; }, {}, "see through");
add("view.grid", "Grid on / off", "View", "", [this] { showGrid_ = !showGrid_; });
add("view.persp", "View: perspective", "View", "Numpad 5", [this] { leaveFlatView(); });
for (const auto& [v, n, k] : std::initializer_list<std::tuple<View, const char*, const char*>>{
{View::Front, "front", "Numpad 1"}, {View::Back, "back", "Shift+Numpad 1"}, {View::Left, "left side", "Numpad 3"}, {View::Right, "right side", "Shift+Numpad 3"},
{View::Top, "top", "Numpad 7"}, {View::Bottom, "bottom", "Shift+Numpad 7"}})
add(std::string("view.") + n, std::string("View: ") + n, "View", k, [this, v] { setView(v); }, {}, "orthographic camera");
add("view.frame", "Frame the selected", "View", "F", [this] { frameSelected(); }, {}, "zoom focus");
add("view.all", "Frame everything", "View", "Home", [this] { frameAll(); }, {}, "zoom extents");
add("view.only", "Show only the selected (again: all)", "View", "/", [this] { showOnly(selected_); }, picked, "isolate local view hide");
add("view.unhide", "Show everything", "View", "Alt+H", [this] { for (Object& o : scene_.objects) o.visible = true; }, {}, "unhide");
add("view.layout", "Put the panels back as they were", "View", "", [this] { resetLayout(); }, {}, "reset layout workspace default panels");
add("view.camera", "Camera: fly or orbit (switch)", "View", "Shift+C", [this] {
keel::execute(std::format("fry_camera {}", fry_camera.i() == 1 ? 0 : 1));
say(fry_camera.i() == 1 ? "Orbit camera: right drag turns round what you look at, the wheel zooms (Shift+C: back to flying)"
: "Fly camera: right drag turns it where it stands, WASD moves, the wheel goes forward and back (Shift+C: orbit)");
}, {}, "orbit fly navigation blender game turntable");
add("view.workspace", "Workspaces (save the panels as they are)...", "View", "", [this] { showWorkspaces_ = true; }, {}, "layout save panels");
for (int i = 0; i < 3; ++i)
add(std::string("view.look") + char('0' + i), std::string("Appearance: ") + (i == 0 ? "like the desktop" : i == 1 ? "dark" : "light"), "View", "",
[i] { keel::execute(std::format("fry_theme {}", i)); }, {}, "theme colours");
const char* tabs[] = {"Model", "Paint", "Layout", "Render", "Print"};
for (int i = 0; i < 5; ++i)
add(std::string("tab.") + tabs[i], std::string("Go to ") + tabs[i], "Tabs", std::format("Ctrl+{}", i + 1), [this, i] { setTab(Tab(i)); }, {}, i == 1 ? "sculpt texture" : "");
add("script.panel", "The Script panel", "Script", "", [this] { showScript_ = !showScript_; }, {}, "lua code");
add("script.run", "Run the script", "Script", "F5", [this] { runScriptNow(); }, [this] { return currentScript() != nullptr; });
add("script.new", "New script", "Script", "", [this] { addScript("Script", kFirstScript); });
add("script.plugins", "Plug-ins...", "Script", "", [this] { showPlugins_ = true; }, {}, "addons extensions");
add("help.keys", "Keys and mouse (and your own keys)", "Help", "F1", [this] { showHelp_ = true; }, {}, "shortcuts hotkeys keymap bind");
add("help.about", "About Fry3DX", "Help", "", [this] { showAbout_ = true; }, {}, "version");
add("help.search", "Search for a command", "Help", "F3", [this] { openSearch(); }, {}, "find palette");
for (size_t i = 0; i < plugins_.size(); ++i)
if (pluginUsable(i))
for (size_t c = 0; c < plugins_[i].p->commands.size(); ++c) {
const fry::PluginCommand& cmd = plugins_[i].p->commands[c];
add("plugin." + plugins_[i].file + "." + cmd.name, cmd.name + (cmd.settings.empty() ? "" : "..."), "Plug-in: " + plugins_[i].p->name, "", [this, i, c] {
if (i >= plugins_.size() || !pluginUsable(i) || c >= plugins_[i].p->commands.size()) return;
const fry::PluginCommand& cm = plugins_[i].p->commands[c];
if (cm.settings.empty()) return runPluginCommand(i, c, {});
pendingCommand_ = PendingCommand{i, c, {}};
for (const auto& [n, v] : cm.settings) pendingCommand_->values.push_back(v);
}, {}, cmd.help);
}
(void)model;
}
auto App::openSearch() -> void {
buildCommands();
search_.show();
}
auto App::runCommand(const std::string& id) -> void {
for (const fry::Command& c : commands_)
if (c.id == id) {
if (!c.usable()) return say(c.name + ": not now (" + (c.group == "Shape" ? "edit a shape first, Tab" : "pick something first") + ")");
std::erase(recentCommands_, id);
recentCommands_.insert(recentCommands_.begin(), id);
if (recentCommands_.size() > 8) recentCommands_.pop_back();
return c.run();
}
}
// A menu item for a command: its name, its key (your own if you gave it one), greyed when it can't be done now.
auto App::commandItem(const char* id) -> void {
for (const fry::Command& c : commands_)
if (c.id == id) {
const auto mine = myKeys_.find(c.id);
const std::string keys = mine != myKeys_.end() ? fry::chordName(mine->second) : c.keys;
if (ImGui::MenuItem(c.name.c_str(), keys.empty() ? nullptr : keys.c_str(), false, c.usable())) runCommand(c.id);
return;
}
}
auto App::commandSearch() -> void {
if (!search_.open) return;
if (const int i = search_.draw(commands_, recentCommands_); i >= 0) runCommand(commands_[size_t(i)].id);
}
// The pies: the tools (Space), or the views (Shift+Space), round the mouse while it's held.
auto App::pieFrame(ImGuiIO& io) -> void {
const bool released = !pieStays_ && !ImGui::IsKeyDown(ImGuiKey_Space);
std::vector<fry::PieItem> items;
std::vector<std::function<void()>> runs;
if (pie_ == 1) {
for (const ToolInfo& t : kTools)
if (mode_ == Mode::Edit ? t.editMode : t.objectMode)
items.push_back({t.name, t.icon, true, tool_ == t.tool}), runs.push_back([this, tool = t.tool] { setTool(tool); });
items.push_back({mode_ == Mode::Edit ? "Done (objects)" : "Edit the shape", mode_ == Mode::Edit ? Icon::Objects : Icon::Shape, true, false});
runs.push_back([this] { mode_ == Mode::Edit ? leaveEdit() : enterEdit(); });
} else {
const std::pair<View, const char*> views[] = {{View::Top, "Top"}, {View::Right, "Right"}, {View::Front, "Front"}, {View::Perspective, "3D"},
{View::Bottom, "Bottom"}, {View::Back, "Back"}, {View::Left, "Left"}};
for (const auto& [v, n] : views) {
items.push_back({n, Icon::Select, false, view_ == v});
runs.push_back([this, v] { v == View::Perspective ? leaveFlatView() : setView(v); });
}
items.push_back({"Frame", Icon::Select, false, false}), runs.push_back([this] { frameSelected(); });
}
const int got = fry::pieMenu(pie_ == 1 ? "Tools" : "Views", pieAt_, items, released);
if (got == -1) return;
if (got >= 0) runs[size_t(got)]();
pie_ = 0, pieStays_ = false;
(void)io;
}
// Keys of your own: kept in keys.txt (a line each: the command's id, a tab, the key).
auto App::loadMyKeys() -> void {
myKeys_.clear();
std::ifstream in(keel::prefPath() + "keys.txt");
for (std::string line; std::getline(in, line);)
if (const size_t tab = line.find('\t'); tab != std::string::npos)
if (const auto c = fry::parseChord(line.substr(tab + 1))) myKeys_[line.substr(0, tab)] = *c;
}
auto App::saveMyKeys() -> void {
std::ofstream out(keel::prefPath() + "keys.txt");
for (const auto& [id, c] : myKeys_) out << id << '\t' << fry::chordName(c) << '\n';
}
auto App::menus() -> void {
if (ImGui::BeginMenu("File")) {
if (ImGui::MenuItem("New", "Ctrl+N")) whenSaved(2);
if (ImGui::MenuItem("Open...", "Ctrl+O")) whenSaved(3);
if (ImGui::MenuItem("Save", "Ctrl+S")) path_.empty() ? dialog(2) : void(saveFile(path_));
if (ImGui::MenuItem("Save as...", "Ctrl+Shift+S")) dialog(2);
ImGui::Separator();
if (ImGui::MenuItem("Import a model (STL, OBJ, 3MF, glTF)...", "Ctrl+Shift+O")) dialog(12);
if (ImGui::MenuItem("Export (GLB, glTF, OBJ, STL, PLY)...", "Ctrl+E")) dialog(3);
if (ImGui::BeginMenu("Autosave")) {
static const int every[] = {1, 2, 5, 10, 0};
for (int m : every)
if (ImGui::MenuItem(m ? std::format("Every {} minute{}", m, m > 1 ? "s" : "").c_str() : "Off", nullptr, fry_autosave.i() == m))
keel::execute(std::format("fry_autosave {}", m));
ImGui::Separator();
if (ImGui::MenuItem("Recover autosaved work...")) findAutosaves(), showRecover_ = !recover_.empty();
ImGui::EndMenu();
}
if (ImGui::MenuItem("Save a picture of the view...", "F12")) dialog(5);
ImGui::Separator();
if (ImGui::MenuItem("Quit", "Ctrl+Q")) whenSaved(1);
ImGui::EndMenu();
}
if (ImGui::BeginMenu("Edit")) {
if (ImGui::MenuItem("Undo", "Ctrl+Z", false, !undo_.empty())) undo();
if (ImGui::MenuItem("Redo", "Ctrl+Y", false, !redo_.empty())) redo();
commandItem("edit.history");
ImGui::Separator();
if (ImGui::MenuItem("Duplicate", "Ctrl+D", false, mode_ == Mode::Object)) duplicateSelected();
if (ImGui::MenuItem("Join into one", "Ctrl+J", false, mode_ == Mode::Object && selected_.size() > 1)) joinSelected();
if (ImGui::MenuItem("Delete", "Del")) deleteSelected();
ImGui::Separator();
if (ImGui::MenuItem(mode_ == Mode::Edit ? "Stop editing the shape" : "Edit the shape", "Tab")) mode_ == Mode::Edit ? leaveEdit() : enterEdit();
ImGui::EndMenu();
}
if (ImGui::BeginMenu("Select")) {
if (ImGui::MenuItem("All", "Ctrl+A")) selectAll();
if (ImGui::MenuItem("None", "Alt+A")) selectNone();
if (ImGui::MenuItem("Invert", "Ctrl+I")) invertSelection();
ImGui::Separator();
ImGui::BeginDisabled(mode_ != Mode::Edit);
if (ImGui::MenuItem("More (grow)", "Ctrl +")) growSelection();
if (ImGui::MenuItem("Less (shrink)", "Ctrl -")) shrinkSelection();
if (ImGui::MenuItem("Everything joined to it", "L")) selectLinked();
commandItem("select.similar");
commandItem("select.loop");
commandItem("select.ring");
ImGui::MenuItem("A loop: Alt+click or double-click", nullptr, false, false);
ImGui::EndDisabled();
ImGui::Separator();
if (ImGui::MenuItem("Select with a box", nullptr, selShape_ == SelShape::Box)) selShape_ = SelShape::Box;
if (ImGui::MenuItem("Select with a brush", nullptr, selShape_ == SelShape::Brush)) selShape_ = SelShape::Brush;
if (ImGui::MenuItem("Select with a lasso", nullptr, selShape_ == SelShape::Lasso)) selShape_ = SelShape::Lasso;
ImGui::EndMenu();
}
if (ImGui::BeginMenu("Add")) {
addMenuItems();
pluginMenuItems("add");
ImGui::EndMenu();
}
if (ImGui::BeginMenu("Object")) {
const bool many = selected_.size() >= 2, any = !selected_.empty();
if (ImGui::MenuItem("Go to it", "F", false, any)) goTo(selected_);
if (ImGui::MenuItem("Duplicate", "Ctrl+D", false, any)) duplicateSelected();
if (ImGui::MenuItem("Make copies (in a row, round)...", nullptr, false, any)) showCopies_ = true;
if (ImGui::MenuItem("Group into a folder", "Ctrl+G", false, any)) groupSelected();
ImGui::Separator();
ImGui::TextDisabled("Two or more: the last picked is kept");
if (ImGui::MenuItem("Add them together", "Ctrl+Shift++", false, many)) combineSelected(Combine::Add);
if (ImGui::MenuItem("Take the others out of it", "Ctrl+Shift+-", false, many)) combineSelected(Combine::Subtract);
if (ImGui::MenuItem("Cut out, editable", nullptr, false, many)) cutEditable();
if (ImGui::IsItemHovered()) ImGui::SetTooltip("The others cut into the last picked but stay objects: move or change them and the hole follows (Apply makes it for good)");
if (ImGui::MenuItem("Keep only where they overlap", nullptr, false, many)) combineSelected(Combine::Overlap);
if (ImGui::MenuItem("Join (just as they are)", "Ctrl+J", false, many)) joinSelected();
ImGui::Separator();
if (ImGui::MenuItem("Make it thick (or hollow)...", nullptr, false, any)) showThicken_ = true;
commandItem("object.spin");
if (ImGui::MenuItem("Join flat faces side by side", nullptr, false, any)) cleanFlatFaces();
pluginMenuItems("object");
ImGui::EndMenu();
}
if (ImGui::BeginMenu("Shape")) {
const bool ed = mode_ == Mode::Edit;
if (!ed) ImGui::TextDisabled("Edit an object's shape first (Tab)");
ImGui::BeginDisabled(!ed);
if (ImGui::MenuItem("Extrude", "X")) setTool(Tool::Extrude);
if (ImGui::MenuItem("Inset", "I")) setTool(Tool::Inset);
if (ImGui::MenuItem("Round edges", "B")) setTool(Tool::Bevel);
if (ImGui::MenuItem("Loop cut", "C")) setTool(Tool::LoopCut);
ImGui::Separator();
if (ImGui::MenuItem("Cut every face in four")) subdivideNow(false);
if (ImGui::MenuItem("Smooth it all (cut and round)")) subdivideNow(true);
if (ImGui::MenuItem("Merge points", "M")) mergeNow();
if (ImGui::MenuItem("Make a face")) makeFaceNow();
if (ImGui::MenuItem("Flip faces")) flipNow();
ImGui::Separator();
if (ImGui::MenuItem("Smooth points")) smoothPointsNow();
if (ImGui::MenuItem("Push out / pull in...", "Alt+S")) startPush();
if (ImGui::MenuItem("Bridge two faces")) bridgeNow();
ImGui::MenuItem("Soft selection", "Shift+O", &softSel_);
ImGui::EndDisabled();
commandItem("shape.crease");
commandItem("shape.slide");
commandItem("shape.mirror");
ImGui::BeginDisabled(!ed);
if (ImGui::MenuItem("Make into its own object", "P")) separateSelected();
if (ImGui::MenuItem("Delete", "Del")) deleteElements();
ImGui::EndDisabled();
ImGui::EndMenu();
}
if (ImGui::BeginMenu("View")) {
if (ImGui::MenuItem("Solid (for modelling)", "Z", shading_ == Shading::Solid)) shading_ = Shading::Solid;
if (ImGui::MenuItem("Rendered (sky, sun, shadows)", "Z", shading_ == Shading::Rendered)) shading_ = Shading::Rendered;
if (ImGui::MenuItem("Wireframe", "Shift+Z", shading_ == Shading::Wire)) shading_ = Shading::Wire;
ImGui::MenuItem("X-ray (see and pick through)", "Alt+Z", &xray_);
ImGui::MenuItem("Grid", nullptr, &showGrid_);
ImGui::MenuItem("Ground (in Rendered)", nullptr, &scene_.look.ground);
if (ImGui::BeginMenu("Appearance")) {
const char* looks[] = {"Like the desktop", "Dark", "Light"};
for (int i = 0; i < 3; ++i)
if (ImGui::MenuItem(looks[i], nullptr, fry_theme.i() == i)) keel::execute(std::format("fry_theme {}", i));
ImGui::EndMenu();
}
ImGui::Separator();
if (ImGui::MenuItem("Perspective", "Numpad 5", view_ == View::Perspective)) leaveFlatView();
if (ImGui::MenuItem("Front", "Numpad 1", view_ == View::Front)) setView(View::Front);
if (ImGui::MenuItem("Back", "Shift+Numpad 1", view_ == View::Back)) setView(View::Back);
if (ImGui::MenuItem("Left side", "Numpad 3", view_ == View::Left)) setView(View::Left);
if (ImGui::MenuItem("Right side", "Shift+Numpad 3", view_ == View::Right)) setView(View::Right);
if (ImGui::MenuItem("Top", "Numpad 7", view_ == View::Top)) setView(View::Top);
if (ImGui::MenuItem("Bottom", "Shift+Numpad 7", view_ == View::Bottom)) setView(View::Bottom);
ImGui::Separator();
if (ImGui::MenuItem("Frame selected", "F")) frameSelected();
if (ImGui::MenuItem("Frame everything", "Home")) frameAll();
if (ImGui::MenuItem("Show only the selected (again: all)", "/", false, !selected_.empty())) showOnly(selected_);
ImGui::Separator();
if (ImGui::MenuItem("Camera: fly (as in games)", nullptr, fry_camera.i() == 0)) keel::execute("fry_camera 0");
if (ImGui::MenuItem("Camera: orbit (as in Blender)", "Shift+C", fry_camera.i() == 1)) keel::execute("fry_camera 1");
ImGui::Separator();
commandItem("tools.measure");
commandItem("view.workspace");
ImGui::EndMenu();
}
if (ImGui::BeginMenu("Script")) {
ImGui::MenuItem("The Script panel", nullptr, &showScript_);
if (ImGui::MenuItem("Run it", "F5", false, currentScript())) runScriptNow();
if (!scene_.scripts.empty() && ImGui::BeginMenu("This file's scripts")) {
for (size_t i = 0; i < scene_.scripts.size(); ++i)
if (ImGui::MenuItem(scene_.scripts[i].name.c_str(), nullptr, i == script_)) script_ = i, showScript_ = true;
ImGui::EndMenu();
}
ImGui::Separator();
if (ImGui::MenuItem("New script")) addScript("Script", kFirstScript);
if (ImGui::MenuItem("Open a script...")) showScript_ = true, dialog(10);
if (ImGui::MenuItem("Save the script as...", nullptr, false, currentScript())) dialog(11);
exampleScripts();
ImGui::Separator();
if (ImGui::BeginMenu("Plug-ins")) {
bool any = false;
for (size_t i = 0; i < plugins_.size(); ++i)
if (plugins_[i].p)
for (size_t c = 0; c < plugins_[i].p->commands.size(); ++c)
if (plugins_[i].p->commands[c].menu == "script") pluginMenuItem(i, c), any = true;
if (any) ImGui::Separator();
if (ImGui::MenuItem("Plug-ins...")) showPlugins_ = true;
if (ImGui::MenuItem("Open the plug-ins folder")) openPluginsFolder();
if (ImGui::MenuItem("Load them again")) loadPlugins();
ImGui::EndMenu();
}
if (ImGui::MenuItem("What scripts can do")) showScript_ = showScriptHelp_ = true;
ImGui::EndMenu();
}
if (ImGui::BeginMenu("Help")) {
if (ImGui::MenuItem("Keys and mouse", "F1")) showHelp_ = true;
commandItem("help.search");
if (ImGui::MenuItem("About Fry3DX")) showAbout_ = true;
ImGui::EndMenu();
}
}
auto App::menuBar() -> void {
if (!ImGui::BeginMainMenuBar()) return;
if (haveLogo_) {
const float h = ImGui::GetFrameHeight() - 4;
ImGui::SetCursorPosY(ImGui::GetCursorPosY() + 1);
logoImage(h);
}
ImGui::PushFont(keel::ui::font(keel::ui::Font::Bold), 0.0f), ImGui::TextColored(accentText(), "Fry3DX"), ImGui::PopFont();
if (!touch()) menus();
else if (ImGui::BeginMenu("Menu")) { // (a phone: one menu, the others inside it)
menus();
ImGui::EndMenu();
}
const std::string file = (path_.empty() ? "Untitled" : fileName(path_)) + (dirty_ ? " *" : "");
// The tabs: what you're doing (as wide as there's room for between the menus and the file's
// name; the pictures alone when it's tight).
{
const char* names[] = {"Model", "Paint", "Layout", "Render", "Print"};
const Icon icons[] = {Icon::Objects, Icon::PaintBrush, Icon::Layout, Icon::Render, Icon::Print};
const char* tips[] = {"Make the shape (Ctrl+1)", "Paint pictures onto it (Ctrl+2)", "Change how its picture is laid out: move, turn and size its frames (Ctrl+3)",
"Light it and save pictures of it (Ctrl+4)", "Get it ready for a 3D printer: size, checks, the printer's plate (Ctrl+5)"};
const float h = ImGui::GetFrameHeight(), from = ImGui::GetCursorPosX() + 20.0f;
const float room = ImGui::GetWindowWidth() - from - (touch() ? 8.0f : ImGui::CalcTextSize(file.c_str()).x + 32.0f);
float tw = std::min(touch() ? 72.0f : 92.0f, room / 5 - 4);
const bool words = tw >= h + 2 + ImGui::CalcTextSize("Layout").x + 6;
if (!words) tw = h + 4;
ImGui::SetCursorPosX(std::max(from, std::min((ImGui::GetWindowWidth() - (tw + 4) * 5) * 0.5f, from + room - (tw + 4) * 5)));
for (int i = 0; i < 5; ++i) {
if (i) ImGui::SameLine(0, 4);
ImGui::PushID(i);
if (wideButton("##tab", icons[i], words ? names[i] : "", int(tab_) == i, tw, words ? tips[i] : std::format("{}: {}", names[i], tips[i]).c_str(), h)) setTab(Tab(i));
ImGui::PopID();
}
}
if (touch()) return ImGui::EndMainMenuBar(); // (no room on a phone)
ImGui::SameLine(ImGui::GetWindowWidth() - ImGui::CalcTextSize(file.c_str()).x - 16);
ImGui::TextDisabled("%s", file.c_str());
ImGui::EndMainMenuBar();
}
auto App::addMenuItems() -> void {
ImGui::SeparatorText("Shapes");
for (const ShapeRecipe& r : shapeRecipes())
if (!r.starter && ImGui::MenuItem(r.name)) addShape(r.id);
ImGui::SeparatorText("Starter models");
for (const ShapeRecipe& r : shapeRecipes())
if (r.starter && ImGui::MenuItem(r.name)) addShape(r.id);
ImGui::Separator();
if (ImGui::MenuItem("Draw a shape", "D")) {
if (mode_ == Mode::Edit) leaveEdit();
setTool(Tool::Draw);
}
if (ImGui::MenuItem("Reference picture...")) dialog(4);
commandItem("add.text");
}
// How the last item's key looks: filled when it's the one in use, sunk while held.
auto App::keyState(bool on) -> keel::ui::KeyState {
using keel::ui::KeyState;
return on ? KeyState::On : ImGui::IsItemActive() ? KeyState::Pressed : ImGui::IsItemHovered() ? KeyState::Hovered : KeyState::Normal;
}
// A square button with a picture on it (the accent when it's the one in use).
auto App::iconButton(const char* id, Icon icon, bool on, const char* tip, float size) -> bool {
const ImVec2 p = ImGui::GetCursorScreenPos();
const bool hit = ImGui::InvisibleButton(id, ImVec2(size, size));
const keel::ui::KeyState k = keyState(on);
ImDrawList* dl = ImGui::GetWindowDrawList();
keel::ui::drawKey(dl, p, ImVec2(p.x + size, p.y + size), 7.0f, k);
const float sink = k == keel::ui::KeyState::Pressed ? 1.0f : 0.0f;
drawIcon(dl, icon, ImVec2(p.x + size * 0.14f, p.y + size * 0.14f + sink), size * 0.72f, keel::ui::keyText(k));
const bool hov = ImGui::IsItemHovered();
if (hov && tip) ImGui::SetTooltip("%s", tip);
return hit;
}
// A wide one, with words beside the picture.
auto App::wideButton(const char* id, Icon icon, const char* label, bool on, float width, const char* tip, float h) -> bool {
const ImVec2 p = ImGui::GetCursorScreenPos();
const bool hit = ImGui::InvisibleButton(id, ImVec2(width, h));
const keel::ui::KeyState k = keyState(on);
ImDrawList* dl = ImGui::GetWindowDrawList();
keel::ui::drawKey(dl, p, ImVec2(p.x + width, p.y + h), 7.0f, k);
const float sink = k == keel::ui::KeyState::Pressed ? 1.0f : 0.0f;
drawIcon(dl, icon, ImVec2(p.x + h * 0.15f, p.y + h * 0.13f + sink), h * 0.74f, keel::ui::keyText(k));
dl->AddText(ImVec2(p.x + h + 2, p.y + (h - ImGui::GetFontSize()) * 0.5f + sink), keel::ui::keyText(k), label);
const bool hov = ImGui::IsItemHovered();
if (hov && tip) ImGui::SetTooltip("%s", tip);
return hit;
}
auto App::toolbox() -> void {
if (std::exchange(showToolbox_, false)) ImGui::SetNextWindowFocus();
ImGui::SetNextWindowSizeConstraints(panelMin("Toolbox"), ImVec2(FLT_MAX, FLT_MAX));
ImGui::Begin("Toolbox", nullptr, ImGuiWindowFlags_NoCollapse);
const float w = ImGui::GetContentRegionAvail().x;
if (tab_ == Tab::Paint) {
paintToolbox(w);
return ImGui::End();
}
if (tab_ == Tab::Layout) {
layoutToolbox(w);
return ImGui::End();
}
if (tab_ == Tab::Render || tab_ == Tab::Print) {
const Tool tools[] = {Tool::Select, Tool::Move, Tool::Rotate, Tool::Scale};
grid(4, 38.0f, [&](int i) {
const ToolInfo& t = kTools[int(tools[i])];
const std::string id = std::format("##{}", t.name), tip = std::format("{} ({})\n{}", t.name, t.key, t.hint);
if (iconButton(id.c_str(), t.icon, tool_ == t.tool, tip.c_str())) setTool(t.tool);
});
ImGui::Spacing();
if (tab_ == Tab::Print) printToolbox(w);
else if (wideButton("##save", Icon::Picture, "Save a picture", false, w, "Saves what the view shows, without the panels or gizmos (F12)")) dialog(5);
return ImGui::End();
}
// The mode: whole objects, or the shape of one.
if (wideButton("##objects", Icon::Objects, "Objects", mode_ == Mode::Object, (w - 5) / 2, "Work with whole objects")) leaveEdit();
ImGui::SameLine(0, 5);
if (wideButton("##shape", Icon::Shape, "Shape", mode_ == Mode::Edit, (w - 5) / 2, "Edit the selected object's shape: its points, edges and faces (Tab, or double-click it)")) enterEdit();
if (mode_ == Mode::Edit) {
const Icon icons[] = {Icon::Points, Icon::Edges, Icon::Faces};
const char* tips[] = {"Points (1)", "Edges (2)", "Faces (3)"};
const char* names[] = {"Points", "Edges", "Faces"};
const float third = (w - 10) / 3;
for (int i = 0; i < 3; ++i) {
if (i) ImGui::SameLine(0, 5);
ImGui::PushID(i);
if (wideButton("##elem", icons[i], names[i], int(elem_) == i, third, tips[i])) elem_ = Elem(i), clearElements();
ImGui::PopID();
}
}
ImGui::Spacing();
// The tools, as pictures (hover for the name and key).
std::vector<const ToolInfo*> tools;
for (const ToolInfo& t : kTools)
if ((mode_ == Mode::Object && t.objectMode) || (mode_ == Mode::Edit && t.editMode)) tools.push_back(&t);
grid(int(tools.size()) + 1, 38.0f, [&](int i) {
if (i == int(tools.size())) {
if (iconButton("##add", Icon::Add, false, "Add a shape or a starter model")) ImGui::OpenPopup("add");
return;
}
const ToolInfo& t = *tools[size_t(i)];
const std::string id = std::format("##{}", t.name), tip = std::format("{} ({})\n{}", t.name, t.key, t.hint);
if (iconButton(id.c_str(), t.icon, tool_ == t.tool, tip.c_str())) setTool(t.tool);
});
if (ImGui::BeginPopup("add")) {
addMenuItems();
ImGui::EndPopup();
}
// Mouse tools from plug-ins (fry.tool): by name, as plug-ins load again.
if (mode_ == Mode::Object) {
bool first = true;
for (size_t i = 0; i < plugins_.size(); ++i)
if (pluginUsable(i))
for (const fry::PluginTool& t : plugins_[i].p->tools) {
if (std::exchange(first, false)) ImGui::SeparatorText("Plug-in tools");
const bool on = pluginTool_ == std::pair(plugins_[i].file, t.name);
if (ImGui::Selectable(std::format("{}##{}", t.name, plugins_[i].file).c_str(), on, 0, ImVec2(w, touch() ? 34.0f : 0.0f)))
on ? setTool(Tool::Select) : void((pluginTool_ = {plugins_[i].file, t.name}, tool_ = Tool::Select, say(t.name + ": click in the view (Esc stops)")));
if (ImGui::IsItemHovered()) ImGui::SetTooltip("%s%s(%s)", t.help.c_str(), t.help.empty() ? "" : "\n", plugins_[i].p->name.c_str());
}
}
ImGui::Spacing();
if (pluginTool_.first.empty()) // (a plug-in tool: its row shows it's on)
for (const ToolInfo& t : kTools)
if (t.tool == tool_) ImGui::TextColored(accentText(), "%s", t.name);
ImGui::End();
}
// The plug-in tool that's on: which plug-in and which of its tools (none: -1).
auto App::pluginToolAt() const -> std::pair<int, int> {
for (size_t i = 0; i < plugins_.size(); ++i)
if (plugins_[i].file == pluginTool_.first && pluginUsable(i))
for (size_t k = 0; k < plugins_[i].p->tools.size(); ++k)
if (plugins_[i].p->tools[k].name == pluginTool_.second) return {int(i), int(k)};
return {-1, -1};
}
// A plug-in tool's click: the spot on what's under the mouse, or on the ground.
auto App::clickPluginTool(ImVec2 mouse) -> void {
const auto [i, k] = pluginToolAt();
if (i < 0) return pluginTool_ = {}, say("That plug-in tool isn't loaded any more");
const Ray ray = mouseRay(mouse);
glm::vec3 at, n(0, 0, 1);
uint32_t onto = 0;
const Hit h = pickObject(ray, 0, true);
if (const Object* o = h.object ? find(h.object) : nullptr) {
at = ray.origin + ray.dir * h.t, onto = o->id;
n = glm::normalize(glm::transpose(glm::inverse(glm::mat3(objectMatrix(*o)))) * faceNormal(o->mesh, h.face));
} else if (auto g = hitPlane(ray, glm::vec3(0.0f), n)) at = *g;
else return;
pushUndo();
bool frame = false;
fry::ScriptHost host{&scene_, &selected_, &active_, [this](const std::string& t) { scriptLine(t); }, [&] { frame = true; }};
const fry::ScriptResult r = plugins_[size_t(i)].p->click(host, size_t(k), at, n, onto);
finishRun(r, pluginTool_.second, frame);
}
auto App::paintToolbox(float w) -> void {
const float half = (w - ImGui::GetStyle().ItemSpacing.x) * 0.5f;
if (wideButton("##colour-side", Icon::PaintBrush, "Colour", !sculpting_, half, "Paint colours on it (Tab)")) sculpting_ = false, endSculpt();
ImGui::SameLine();
if (wideButton("##shape-side", Icon::Sculpt, "Sculpt", sculpting_, half, "Push its surface about like clay (Tab)")) sculpting_ = true, endStroke();
ImGui::Spacing();
if (sculpting_) {
grid(int(std::size(kSculptTools)), 38.0f, [&](int i) {
const SculptToolInfo& t = kSculptTools[i];
const std::string id = std::format("##{}", t.name), tip = std::format("{} ({})\n{}", t.name, t.key, t.hint);
if (iconButton(id.c_str(), t.icon, sculptBrush_ == t.brush, tip.c_str())) sculptBrush_ = t.brush;
});
for (const SculptToolInfo& t : kSculptTools)
if (t.brush == sculptBrush_) ImGui::TextColored(accentText(), "%s", t.name);
return;
}
grid(int(std::size(kPaintTools)), 38.0f, [&](int i) {
const PaintToolInfo& t = kPaintTools[i];
const std::string id = std::format("##{}", t.name), tip = std::format("{} ({})\n{}", t.name, t.key, t.hint);
if (iconButton(id.c_str(), t.icon, paintTool_ == t.tool, tip.c_str())) paintTool_ = t.tool;
});
ImGui::Spacing();
// The colour, big, and a few to pick from.
ImGui::ColorButton("##colour", ImVec4(paintColor_.r, paintColor_.g, paintColor_.b, 1.0f), ImGuiColorEditFlags_NoTooltip, ImVec2(w, 34));
static const glm::vec3 palette[] = {{0.08f, 0.08f, 0.09f}, {0.95f, 0.95f, 0.95f}, {0.55f, 0.55f, 0.57f}, {0.85f, 0.2f, 0.12f}, {1.0f, 0.55f, 0.1f}, {0.98f, 0.85f, 0.2f},
{0.3f, 0.7f, 0.25f}, {0.15f, 0.45f, 0.85f}, {0.45f, 0.25f, 0.7f}, {0.45f, 0.3f, 0.18f}, {0.75f, 0.6f, 0.45f}, {0.95f, 0.6f, 0.7f}};
grid(int(std::size(palette)), 20.0f, [&](int i) {
ImGui::PushID(i);
if (ImGui::ColorButton("##p", ImVec4(palette[i].r, palette[i].g, palette[i].b, 1.0f), 0, ImVec2(20, 20))) paintColor_ = glm::vec4(palette[i], paintColor_.a);
ImGui::PopID();
});
for (const PaintToolInfo& t : kPaintTools)
if (t.tool == paintTool_) ImGui::TextColored(accentText(), "%s", t.name);
}
auto App::sculptOptions(float w) -> void {
for (const SculptToolInfo& t : kSculptTools)
if (t.brush == sculptBrush_) ImGui::SeparatorText(t.name), ImGui::TextWrapped("%s", t.hint);
ImGui::Spacing();
ImGui::SetNextItemWidth(w);
ImGui::SliderFloat("##size", &sculptPx_, 4.0f, 400.0f, "size %.0f px", ImGuiSliderFlags_Logarithmic);
if (sculptBrush_ != SculptBrush::Grab) {
ImGui::SetNextItemWidth(w);
ImGui::SliderFloat("##strength", &sculptStrength_, 0.02f, 1.0f, "strength %.2f");
}
ImGui::Checkbox("Same on both sides (X)", &sculptMirror_);
if (ImGui::IsItemHovered()) ImGui::SetTooltip("What you do on its left is done on its right too");
if (Object* o = selected_.size() == 1 ? find(active_) : nullptr) {
ImGui::SeparatorText(o->name.c_str());
ImGui::TextDisabled("%zu points", o->mesh.verts.size());
size_t after = 0;
for (const auto& f : o->mesh.faces) after += f.size();
ImGui::BeginDisabled(after > 400000 || o->locked);
if (ImGui::Button("Finer, for small details", ImVec2(w, 0))) {
pushUndo();
if (o->hasFinish()) o->mesh = finishedMesh(*o), o->mirror = 0, o->round = 0, o->smoothLevels = 0;
handMade(*o);
subdivide(o->mesh, false);
touched(o->id);
}
ImGui::EndDisabled();
if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) ImGui::SetTooltip("Each face split in four: the same shape, more points to push about");
if (ImGui::Button("Smooth all of it", ImVec2(w, 0)) && !o->locked) {
pushUndo();
handMade(*o);
const SculptMesh sm(o->mesh);
const glm::vec3 mid = (boundsMin(o->mesh) + boundsMax(o->mesh)) * 0.5f;
sculptDab(o->mesh, sm, SculptBrush::Smooth, {mid, glm::distance(boundsMin(o->mesh), boundsMax(o->mesh)) * 2.0f, 0.5f});
touched(o->id);
}
}
ImGui::Spacing();
ImGui::TextDisabled("Ctrl: the other way Shift: smooth\n[ and ]: brush size 1-6: brushes");
}
auto App::paintOptions(float w) -> void {
if (sculpting_) return sculptOptions(w);
for (const PaintToolInfo& t : kPaintTools)
if (t.tool == paintTool_) ImGui::SeparatorText(t.name);
if (paintTool_ == PaintTool::Brush || paintTool_ == PaintTool::Eraser) {
ImGui::SetNextItemWidth(w);
ImGui::SliderFloat("##size", &brushPx_, 1.0f, 300.0f, "size %.0f px", ImGuiSliderFlags_Logarithmic);
ImGui::SetNextItemWidth(w);
ImGui::SliderFloat("##hard", &hardness_, 0.0f, 1.0f, "hard edge %.2f");
ImGui::SetNextItemWidth(w);
ImGui::SliderFloat("##strength", &paintColor_.a, 0.02f, 1.0f, "strength %.2f");
ImGui::Checkbox("Both sides (mirrored, X)", &paintMirror_);
if (ImGui::IsItemHovered()) ImGui::SetTooltip("What you paint on one side goes on the other too, mirrored (left and right: the object's own Y)");
ImGui::SeparatorText("Stencil");
if (stencil_.size() >= 3) {
ImGui::Checkbox("Paint only inside it", &stencilOn_);
if (ImGui::Button("Draw it again", ImVec2(w * 0.5f - 2, 0))) drawingStencil_ = true, stencil_.clear();
ImGui::SameLine(0, 4);
if (ImGui::Button("Take it off", ImVec2(w * 0.5f - 2, 0))) stencil_.clear(), stencilOn_ = false;
} else {
if (ImGui::Button(drawingStencil_ ? "Drawing: drag round the area..." : "Draw a stencil", ImVec2(w, 0))) drawingStencil_ = !drawingStencil_, stencil_.clear();
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Drag round an area on the screen: paint goes only inside it (it stays put on the screen as you turn the view)");
}
}
if (paintTool_ == PaintTool::Fill) {
ImGui::SetNextItemWidth(w);
ImGui::SliderFloat("##tol", &fillTolerance_, 0.0f, 1.0f, "how alike %.2f");
if (ImGui::IsItemHovered()) ImGui::SetTooltip("How different a colour can be and still be filled");
}
if (paintTool_ == PaintTool::Brush || paintTool_ == PaintTool::Fill || paintTool_ == PaintTool::Picker) {
ImGui::SetNextItemWidth(w);
ImGui::ColorPicker3("##picker", &paintColor_.x, ImGuiColorEditFlags_NoSidePreview | ImGuiColorEditFlags_NoSmallPreview | ImGuiColorEditFlags_PickerHueBar);
}
if (paintTool_ == PaintTool::Eraser) ImGui::TextWrapped("Paints the object's plain colour back (its colour in the Model tab).");
if (paintTool_ == PaintTool::Picture) {
if (ImGui::Button("Paste (Ctrl+V)", ImVec2(w, 0))) pasteFromClipboard();
if (ImGui::Button("Add a picture from a file...", ImVec2(w, 0))) dialog(6);
if (PictureLayer* l = editLayer()) {
Object* o = find(ledit_.object);
ImGui::SeparatorText(l->name.c_str());
if (ImGui::Button("Lock it in place (Enter)", ImVec2(w, 0))) lockLayer();
if (ImGui::Button(ledit_.fresh ? "Take it away (Esc)" : "Delete it (Del)", ImVec2(w, 0))) ledit_.fresh ? cancelFloating() : deleteLayer(*o, ledit_.index);
ImGui::SetNextItemWidth(w);
undoable([&] { return ImGui::SliderFloat("##op", &l->opacity, 0.0f, 1.0f, "see-through %.2f"); });
if (l->sticker) {
float size[2] = {l->width, l->height};
ImGui::SetNextItemWidth(w);
if (undoable([&] { return ImGui::DragFloat2("##wh", size, 0.002f, 0.002f, 100.0f, "%.3f m"); })) l->width = size[0], l->height = size[1];
} else if (o && o->picture) {
if (ImGui::Button("Cover the whole picture", ImVec2(w, 0))) {
pushUndo();
const float W = float(o->picture->w), H = float(o->picture->h);
l->corners = {glm::vec2(0, 0), glm::vec2(W, 0), glm::vec2(W, H), glm::vec2(0, H)};
}
if (ImGui::Button("Square it up again", ImVec2(w, 0))) {
pushUndo();
glm::vec2 c(0.0f);
for (const glm::vec2& p : l->corners) c += p * 0.25f;
const float across = (glm::distance(l->corners[0], l->corners[1]) + glm::distance(l->corners[3], l->corners[2])) * 0.5f;
const glm::vec2 half(across * 0.5f, across * 0.5f * float(l->image->h) / float(std::max(l->image->w, 1)));
l->corners = {c - half, glm::vec2(c.x + half.x, c.y - half.y), c + half, glm::vec2(c.x - half.x, c.y + half.y)};
}
}
ImGui::Separator();
}
ImGui::TextDisabled("New pictures go");
int where = pasteOnSurface_ ? 0 : 1;
ImGui::SetNextItemWidth(w);
if (ImGui::Combo("##where", &where, "On the model (a sticker)\0On the flat picture\0")) pasteOnSurface_ = where == 0;
ImGui::TextWrapped(pasteOnSurface_ ? "Copy a picture in any app (GIMP, a browser...) and paste it. Drag it round the model: over an edge it bends like a sticker. "
"Corners size it (Shift: stretch), the round handle turns it (Ctrl: steps). Enter locks it as a layer; click it in the Picture panel to move it again."
: "Copy a picture in any app and paste it. In the Picture panel drag its corners where you want them: it bends to fit "
"(Shift keeps its shape; drag inside to move it). Enter locks it as a layer; click it there to move it again.");
}
}
auto App::softChoice(float w) -> void {
if (mode_ != Mode::Edit) return;
ImGui::Checkbox("Soft selection (Shift+O)", &softSel_);
ImGui::Checkbox("Mirror editing (across X)", &liveMirror_);
if (ImGui::IsItemHovered()) ImGui::SetTooltip("A symmetric shape stays so: move a point, its twin on the other side moves too");
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Points near the selection follow it, less the further they are");
if (!softSel_) return;
ImGui::SetNextItemWidth(w);
ImGui::DragFloat("##reach", &softReach_, 0.002f, 0.001f, 1000.0f, "reaches %.3f m");
ImGui::TextDisabled("(the wheel while dragging too)");
}
auto App::toolOptions() -> void {
ImGui::SetNextWindowSizeConstraints(panelMin("Tool options"), ImVec2(FLT_MAX, FLT_MAX));
ImGui::Begin("Tool options", nullptr, ImGuiWindowFlags_NoCollapse);
const float w = ImGui::GetContentRegionAvail().x;
if (tab_ == Tab::Paint) {
paintOptions(w);
return ImGui::End();
}
if (tab_ == Tab::Layout) {
layoutOptions(w);
return ImGui::End();
}
if ((tab_ == Tab::Print && printTool_ != PrintTool::None) || printTool_ == PrintTool::Measure) {
printOptions(w);
return ImGui::End();
}
const char* name = "";
for (const ToolInfo& t : kTools)
if (t.tool == tool_) name = t.name;
ImGui::SeparatorText(name);
auto orientChoice = [&] {
ImGui::TextDisabled("Arrows point");
int o = int(orient());
const char* items = mode_ == Mode::Edit ? "The object's way\0The world's way\0Out of the faces\0" : "The object's way\0The world's way\0";
ImGui::SetNextItemWidth(w);
if (ImGui::Combo("##orient", &o, items)) orient() = Orient(o);
};
auto snapChoice = [&](bool angle) {
ImGui::Checkbox("Snap", &snap_);
if (ImGui::IsItemHovered()) ImGui::SetTooltip("In steps (holding Ctrl does the opposite)");
if (!snap_) return;
ImGui::SetNextItemWidth(w);
if (angle) return void(ImGui::DragFloat("##snapangle", &snapAngle_, 0.5f, 1.0f, 90.0f, "every %.0f deg"));
if (tool_ == Tool::Move) {
ImGui::SetNextItemWidth(w);
ImGui::Combo("##snapkind", &snapKind_, "To steps\0To points\0To edges' middles\0To faces' middles\0");
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Points, middles: the arrows' point goes to the one nearest the mouse (on other shapes, or what isn't picked)");
if (snapKind_) return;
ImGui::SetNextItemWidth(w);
}
ImGui::DragFloat("##snapmove", &snapMove_, 0.001f, 0.001f, 10.0f, "every %.3f m");
};
switch (tool_) {
case Tool::Select: {
ImGui::TextDisabled("Drag to select with");
const Icon icons[] = {Icon::Box, Icon::Brush, Icon::Lasso};
const char* tips[] = {"A box", "A brush: paint over what you want", "A lasso: draw round it"};
for (int i = 0; i < 3; ++i) {
if (i) ImGui::SameLine(0, 5);
ImGui::PushID(i);
if (iconButton("##shape", icons[i], int(selShape_) == i, tips[i], 34.0f)) selShape_ = SelShape(i);
ImGui::PopID();
}
if (selShape_ == SelShape::Brush) {
ImGui::SetNextItemWidth(w);
ImGui::SliderFloat("##brush", &brushRadius_, 4.0f, 200.0f, "brush %.0f px");
}
ImGui::Checkbox("See through (X-ray)", &xray_);
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Select things behind others too (Alt+Z)");
break;
}
case Tool::Move:
orientChoice();
snapChoice(false);
softChoice(w);
break;
case Tool::Rotate: {
orientChoice();
ImGui::TextDisabled("Turn around");
int p = rotatePivot_ == Pivot::Origin ? 1 : 0;
ImGui::SetNextItemWidth(w);
if (ImGui::Combo("##rpivot", &p, "The middle\0The origin\0")) rotatePivot_ = p ? Pivot::Origin : Pivot::Middle;
snapChoice(true);
softChoice(w);
break;
}
case Tool::Scale: {
if (mode_ == Mode::Edit) orientChoice();
ImGui::TextDisabled("What stays put");
int p = scalePivot_ == Pivot::Opposite ? 0 : scalePivot_ == Pivot::Middle ? 1 : scalePivot_ == Pivot::Bottom ? 2 : 3;
ImGui::SetNextItemWidth(w);
if (ImGui::Combo("##spivot", &p, "The other side\0The middle\0The bottom\0The origin\0"))
scalePivot_ = p == 0 ? Pivot::Opposite : p == 1 ? Pivot::Middle : p == 2 ? Pivot::Bottom : Pivot::Origin;
if (ImGui::IsItemHovered())
ImGui::SetTooltip("The other side: drag a side, the opposite side stays (like stretching in a paint program).\nThe middle: both sides move.\nThe bottom: it stays standing on the ground.");
snapChoice(false);
softChoice(w);
break;
}
case Tool::Draw:
ImGui::SetNextItemWidth(w);
ImGui::DragFloat("##thick", &drawThickness_, 0.001f, 0.0f, 10.0f, "thickness %.3f m");
ImGui::TextWrapped("Drawn on the face you start on, or on %s.",
view_ == View::Perspective || view_ == View::Top || view_ == View::Bottom ? "the ground (a side view draws upright)" : "the plane you look at");
ImGui::TextDisabled("Drawn on an object:");
ImGui::SetNextItemWidth(w);
ImGui::Combo("##drawon", &drawOnMode_, "A new object on it\0Added to it (raised)\0Cut into it\0");
snapChoice(false);
if (!drawPts_.empty() && ImGui::Button("Finish (Enter)", ImVec2(w, 0))) finishShape();
break;
case Tool::Extrude:
ImGui::SetNextItemWidth(w);
ImGui::DragFloat("##ext", &extrudeAmount_, 0.001f, -10, 10, "%.3f m");
if (ImGui::Button("Extrude by that", ImVec2(w, 0))) extrudeNow(extrudeAmount_);
snapChoice(false);
break;
case Tool::Inset:
ImGui::SetNextItemWidth(w);
ImGui::SliderFloat("##ins", &insetAmount_, 0.01f, 0.99f, "%.2f of the way in");
if (ImGui::Button("Inset by that", ImVec2(w, 0))) insetNow(insetAmount_);
break;
case Tool::Bevel:
ImGui::SetNextItemWidth(w);
ImGui::DragFloat("##bw", &bevelWidth_, 0.001f, 0.0f, 10.0f, "width %.3f m");
ImGui::SetNextItemWidth(w);
ImGui::SliderInt("##bs", &bevelSteps_, 1, 10, bevelSteps_ == 1 ? "1 step (a flat cut)" : "%d steps round");
if (ImGui::Button("Round them", ImVec2(w, 0))) bevelNow();
break;
case Tool::LoopCut:
ImGui::SetNextItemWidth(w);
ImGui::SliderInt("##cuts", &cuts_, 1, 16, cuts_ == 1 ? "1 cut" : "%d cuts");
ImGui::TextWrapped("Cuts go across four-sided faces, all the way round.");
break;
case Tool::Knife: {
ImGui::Checkbox("Cut right through", &knifeThrough_);
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Through everything in the line's way, the back too (else only what you can see).\nThe line goes on past its ends.");
if (knifeThrough_) {
ImGui::TextDisabled("Then");
ImGui::SetNextItemWidth(w);
ImGui::Combo("##after", &knifeAfter_, "Just add the edges\0Pieces of the one object\0Each piece its own object\0Delete the smaller piece\0");
if (knifeAfter_ > 0) {
ImGui::TextDisabled("Inside, where it's cut");
int fill = knifeFill_ ? 0 : 1;
ImGui::SetNextItemWidth(w);
if (ImGui::Combo("##fill", &fill, "Filled (solid)\0Left open (hollow)\0")) knifeFill_ = fill == 0;
}
}
ImGui::TextWrapped("Click points along the cut, or drag a straight line. Ctrl: at 45 degree steps. Enter or double-click cuts, Esc lets go. "
"Each face it crosses is cut from edge to edge.");
if (knifePts_.size() >= 2 && ImGui::Button("Cut (Enter)", ImVec2(w, 0))) {
std::vector<ImVec2> pts = knifePts_;
knifePts_.clear();
knifeApply(active_, pts);
}
break;
}
case Tool::Hole: {
ImGui::SetNextItemWidth(w);
ImGui::Combo("##shape", &holeShape_, "Round\0Rectangle\0Triangle\0Hexagon (for nuts)\0");
const HoleShape shape = HoleShape(holeShape_);
// Ready-made sizes for 3D prints: screws go through round holes, nuts sit in hexagons
// (a little room added, as prints come out a touch tight).
struct Fit {
const char* name;
float across, deep; // mm
};
static const Fit screws[] = {{"M2 screw (2.4 mm)", 2.4f, 0}, {"M2.5 screw (2.9 mm)", 2.9f, 0}, {"M3 screw (3.4 mm)", 3.4f, 0}, {"M4 screw (4.5 mm)", 4.5f, 0},
{"M5 screw (5.5 mm)", 5.5f, 0}, {"M6 screw (6.6 mm)", 6.6f, 0}, {"M8 screw (9 mm)", 9.0f, 0}};
static const Fit nuts[] = {{"M2 nut (4 mm, 1.6 thick)", 4.0f, 1.6f}, {"M2.5 nut (5 mm, 2 thick)", 5.0f, 2.0f}, {"M3 nut (5.5 mm, 2.4 thick)", 5.5f, 2.4f},
{"M4 nut (7 mm, 3.2 thick)", 7.0f, 3.2f}, {"M5 nut (8 mm, 4 thick)", 8.0f, 4.0f}, {"M6 nut (10 mm, 5 thick)", 10.0f, 5.0f},
{"M8 nut (13 mm, 6.5 thick)", 13.0f, 6.5f}};
if (shape == HoleShape::Round || shape == HoleShape::Hexagon) {
const bool nut = shape == HoleShape::Hexagon;
ImGui::SetNextItemWidth(w);
if (ImGui::BeginCombo("##fit", nut ? "Size for a nut..." : "Size for a screw...")) {
for (const Fit& f : nut ? std::span<const Fit>(nuts) : std::span<const Fit>(screws))
if (ImGui::Selectable(f.name)) {
holeSize_ = (f.across + (nut ? holeRoom_ * 1000 : 0)) / 1000;
if (nut) holeMode_ = 1, holeDepth_ = (f.deep + 0.2f) / 1000;
else holeMode_ = 0;
}
ImGui::EndCombo();
}
if (nut) {
float room = holeRoom_ * 1000;
ImGui::SetNextItemWidth(w);
if (ImGui::SliderFloat("##room", &room, 0.0f, 0.8f, "+ %.2f mm room")) holeRoom_ = room / 1000;
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Added to a nut's size so it pushes in (0.2 to 0.4 mm suits most printers)");
}
}
if (shape == HoleShape::Round) {
ImGui::SetNextItemWidth(w);
ImGui::SliderInt("##sides", &holeSides_, 6, 96, "%d sides round");
}
const char* acrossName = shape == HoleShape::Round ? "%.2f mm across" : shape == HoleShape::Rectangle ? "%.2f mm wide" : shape == HoleShape::Triangle ? "%.2f mm sides" : "%.2f mm across flats";
float across = holeSize_ * 1000, tall = holeTall_ * 1000;
ImGui::SetNextItemWidth(w);
if (ImGui::DragFloat("##size", &across, 0.1f, 0.1f, 100000.0f, acrossName)) holeSize_ = across / 1000;
if (shape == HoleShape::Rectangle) {
ImGui::SetNextItemWidth(w);
if (ImGui::DragFloat("##tall", &tall, 0.1f, 0.1f, 100000.0f, "%.2f mm high")) holeTall_ = tall / 1000;
}
if (shape != HoleShape::Round) {
ImGui::SetNextItemWidth(w);
ImGui::SliderFloat("##turn", &holeTurn_, -180.0f, 180.0f, "turned %.0f degrees");
}
ImGui::TextDisabled("Cut");
ImGui::SetNextItemWidth(w);
ImGui::Combo("##mode", &holeMode_, "All the way through\0A pocket\0Only the outline (a new face)\0");
if (holeMode_ == 1) {
float deep = holeDepth_ * 1000;
ImGui::SetNextItemWidth(w);
if (ImGui::DragFloat("##depth", &deep, 0.1f, 0.1f, 100000.0f, "%.2f mm deep")) holeDepth_ = deep / 1000;
}
ImGui::TextWrapped(holeMode_ == 2 ? "Press on a face and drag out the size, or just click. Nothing's taken away: the outline is cut into the face, "
"and the new face inside it is picked, ready to Extrude, Bevel or paint."
: "Press on a face and drag out the size, or just click (the size above). It has to fit inside the face%s. "
"Round edges in Properties rounds its rim too.",
holeMode_ == 0 ? ", and the face behind" : "");
break;
}
}
ImGui::End();
}
auto App::layersPanel() -> void {
ImGui::SetNextWindowSizeConstraints(panelMin("Layers"), ImVec2(FLT_MAX, FLT_MAX));
ImGui::Begin("Layers", nullptr, ImGuiWindowFlags_NoCollapse);
// Along the top: a new folder, the picked ones into one.
if (ImGui::SmallButton("+ Folder")) {
pushUndo();
Folder f;
f.id = scene_.nextId++, f.name = "Folder";
scene_.folders.push_back(f);
renamingFolder_ = f.id, std::snprintf(renameBuf_, sizeof renameBuf_, "%s", f.name.c_str());
}
if (ImGui::IsItemHovered()) ImGui::SetTooltip("A new folder: drag things onto it");
ImGui::SameLine();
ImGui::BeginDisabled(selected_.empty());
if (ImGui::SmallButton("Group (Ctrl+G)")) groupSelected();
ImGui::EndDisabled();
if (ImGui::IsItemHovered(ImGuiHoveredFlags_AllowWhenDisabled)) ImGui::SetTooltip("The picked objects into a new folder: picked and moved together");
if (ImGui::BeginTable("objects", 4, ImGuiTableFlags_RowBg | ImGuiTableFlags_ScrollY)) {
ImGui::TableSetupColumn("eye", ImGuiTableColumnFlags_WidthFixed, 22);
ImGui::TableSetupColumn("lock", ImGuiTableColumnFlags_WidthFixed, 22);
ImGui::TableSetupColumn("name");
ImGui::TableSetupColumn("go", ImGuiTableColumnFlags_WidthFixed, 22);
layerRows(0, 0);
for (Reference& ref : scene_.references) {
ImGui::PushID(int(ref.id));
ImGui::TableNextRow();
ImGui::TableNextColumn();
if (rowToggle("##eye", ref.visible ? Icon::Eye : Icon::EyeShut, ref.visible, ref.visible ? "Shown (click to hide)" : "Hidden (click to show)")) ref.visible = !ref.visible;
ImGui::TableNextColumn();
ImGui::TableNextColumn();
const std::string label = "Picture: " + stdfs::path(ref.path).filename().string();
if (ImGui::Selectable(label.c_str(), activeRef_ == ref.id)) activeRef_ = ref.id, selected_.clear(), leaveEdit();
ImGui::TableNextColumn();
ImGui::PopID();
}
ImGui::EndTable();
}
// (dropped below the list: out of its folder, to the top)
ImGui::InvisibleButton("##top", ImVec2(std::max(ImGui::GetContentRegionAvail().x, 1.0f), std::max(ImGui::GetContentRegionAvail().y, 8.0f)));
if (ImGui::BeginDragDropTarget()) {
if (const ImGuiPayload* p = ImGui::AcceptDragDropPayload("FRY_OBJECT")) {
const uint32_t oid = *static_cast<const uint32_t*>(p->Data);
moveToFolder(selected_.count(oid) ? selected_ : std::set<uint32_t>{oid}, 0);
}
if (const ImGuiPayload* p = ImGui::AcceptDragDropPayload("FRY_FOLDER"))
if (Folder* g = findFolder(*static_cast<const uint32_t*>(p->Data))) pushUndo(), g->parent = 0;
ImGui::EndDragDropTarget();
}
ImGui::End();
}
auto App::paintProperties(float w) -> void {
Object* o = selected_.empty() ? nullptr : find(active_);
if (sculpting_) { // (its look, while you shape it: what it's made of shows how the light runs over it)
if (!o) return ImGui::TextWrapped("Brush over an object to sculpt it.\n\nA shape with few points is made finer first, keeping its shape. Tab goes back to painting colours.");
ImGui::TextColored(accentText(), "%s", o->name.c_str());
ImGui::TextDisabled("%zu points, %zu faces", o->mesh.verts.size(), o->mesh.faces.size());
ImGui::SeparatorText("Look");
materialPicker(*o);
undoable([&] { return ImGui::ColorEdit3("Colour", &o->color.x); });
if (ImGui::Checkbox("Smooth shading", &o->smooth)) pushUndo(), touched(o->id);
return;
}
if (!o) {
ImGui::TextWrapped("Click an object to paint on it.\n\nIts surface gets laid out flat on a picture (the Picture panel), which you can paint on too, "
"or put pictures onto: copy one in any app and press Ctrl+V.");
return;
}
ImGui::TextColored(accentText(), "%s", o->name.c_str());
if (!o->picture) {
int size = pictureSize_ <= 512 ? 0 : pictureSize_ <= 1024 ? 1 : pictureSize_ <= 2048 ? 2 : 3;
ImGui::SetNextItemWidth(w);
if (ImGui::Combo("##psize", &size, "512 x 512\0001024 x 1024\0002048 x 2048\0004096 x 4096\0")) pictureSize_ = 512 << size;
if (ImGui::Button("Start painting it", ImVec2(w, 0))) readyToPaint(o->id);
ImGui::TextDisabled("(or just paint on it)");
return;
}
ImGui::TextDisabled("Picture %d x %d", o->picture->w, o->picture->h);
if (o->hasFinish()) ImGui::TextWrapped("It's had rounding or smoothing added since: the picture shows again when you paint (they become part of the shape).");
ImGui::Checkbox("Show the layout lines", &showUvLines_);
// The pictures put on it, top first: click one to move it (again), the eye hides it.
ImGui::SeparatorText("Pictures on it (layers)");
if (o->layers.empty()) ImGui::TextDisabled("None yet: paste one (Ctrl+V)");
int move = -1, by = 0, drop = -1, merge = -1;
for (int i = int(o->layers.size()) - 1; i >= 0; --i) {
PictureLayer& l = o->layers[size_t(i)];
const bool on = ledit_.object == o->id && ledit_.index == i;
ImGui::PushID(i);
if (rowToggle("##eye", l.visible ? Icon::Eye : Icon::EyeShut, l.visible, l.visible ? "Hide it" : "Show it")) pushUndo(), l.visible = !l.visible;
ImGui::SameLine();
if (ImGui::Selectable(std::format("{}{}", l.name, on ? " (moving)" : l.sticker ? "" : " (flat)").c_str(), on, 0, ImVec2(w - 92, 0)))
on ? lockLayer() : unlockLayer(o->id, i);
ImGui::SameLine(w - 62);
ImGui::BeginDisabled(i == int(o->layers.size()) - 1);
if (ImGui::ArrowButton("up", ImGuiDir_Up)) move = i, by = 1;
ImGui::EndDisabled();
ImGui::SameLine(0, 2);
ImGui::BeginDisabled(i == 0);
if (ImGui::ArrowButton("down", ImGuiDir_Down)) move = i, by = -1;
ImGui::EndDisabled();
ImGui::SameLine(0, 2);
if (ImGui::SmallButton("x")) drop = i;
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Delete it");
if (ImGui::BeginPopupContextItem("menu")) {
ImGui::SetNextItemWidth(180);
undoable([&] { return ImGui::SliderFloat("##op", &l.opacity, 0.0f, 1.0f, "see-through %.2f"); });
if (ImGui::MenuItem("Paint it in for good")) merge = i;
if (ImGui::MenuItem("Delete")) drop = i;
ImGui::EndPopup();
}
ImGui::PopID();
}
if (move >= 0) pushUndo(), std::swap(o->layers[size_t(move)], o->layers[size_t(move + by)]), ledit_ = {};
if (drop >= 0) deleteLayer(*o, drop);
if (merge >= 0) mergeLayer(*o, merge);
ImGui::Spacing();
if (ImGui::Button("Fill it all with the colour", ImVec2(w, 0))) {
Image& img = changePicture(*o);
img = makeImage(img.w, img.h, glm::vec4(glm::vec3(paintColor_), 1.0f));
paint_.image.reset();
}
if (ImGui::Button("Save the picture as PNG...", ImVec2(w, 0))) dialog(7);
if (ImGui::Button("Lay it out again", ImVec2(w, 0))) {
pushUndo();
o->uvs = autoUnwrap(o->mesh);
touched(o->id);
}
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Lays its surface out flat on the picture again (what's painted won't fit it any more)");
if (ImGui::Button("Remove the picture", ImVec2(w, 0))) {
pushUndo();
o->picture.reset(), o->uvs.clear();
touched(o->id);
}
ImGui::Spacing();
ImGui::TextWrapped("Tip: paint last. Changing the shape's faces (extrude, knife...) lays it out again, and what's painted moves.");
}
auto App::renderProperties(float w) -> void {
Look& k = scene_.look;
auto slider = [&](const char* label, float* v, float lo, float hi, const char* fmt) {
if (undoable([&] { return ImGui::SliderFloat(label, v, lo, hi, fmt); })) dirty_ = true;
};
ImGui::SeparatorText("Sun");
slider("Round", &k.sunTurn, 0, 360, "%.0f deg");
slider("Up", &k.sunHeight, 2, 90, "%.0f deg");
slider("Strength", &k.sunStrength, 0, 2, "%.2f");
undoable([&] { return ImGui::ColorEdit3("Sun colour", &k.sunColor.x); });
ImGui::SeparatorText("Round it");
if (ImGui::Checkbox("Sky", &k.sky)) dirty_ = true;
if (!k.sky) undoable([&] { return ImGui::ColorEdit3("Background", &k.background.x); });
if (ImGui::Checkbox("Ground", &k.ground)) dirty_ = true;
if (k.ground) undoable([&] { return ImGui::ColorEdit3("Ground colour", &k.groundColor.x); });
ImGui::Checkbox("Grid", &renderGrid_);
ImGui::SeparatorText("Look");
slider("Brightness", &k.exposure, 0.2f, 3.0f, "%.2f");
slider("Shade in corners", &k.ao, 0, 1, "%.2f");
slider("Soft shadows", &k.shadowSoft, 0, 4, "%.2f");
slider("Glow", &k.bloom, 0, 0.3f, "%.3f");
slider("Colour", &k.saturation, 0, 2, "%.2f");
slider("Dark edges", &k.vignette, 0, 1, "%.2f");
slider("Sharpen", &k.sharpen, 0, 1, "%.2f");
if (ImGui::Button("Back to how it was", ImVec2(w, 0))) pushUndo(), k = Look{};
if (ImGui::Button("Save a picture (F12)", ImVec2(w, 0))) dialog(5);
if (Object* o = selected_.size() == 1 ? find(active_) : nullptr) {
ImGui::SeparatorText(o->name.c_str());
materialPicker(*o);
undoable([&] { return ImGui::ColorEdit3("Colour", &o->color.x); });
undoable([&] { return ImGui::SliderFloat("Metal", &o->metal, 0, 1); });
undoable([&] { return ImGui::SliderFloat("Rough", &o->rough, 0, 1); });
ImGui::TextDisabled("(metal and rough go with it into games)");
}
}
// The Paint tab's picture: the selected object's, flat, to paint on and place pictures on.
auto App::picturePanel() -> void {
ImGui::SetNextWindowSizeConstraints(panelMin("Picture"), ImVec2(FLT_MAX, FLT_MAX));
ImGui::Begin("Picture", nullptr, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse);
Object* o = selected_.empty() ? nullptr : find(active_);
if (!o || !o->picture) {
if (tab_ == Tab::Layout) {
ImGui::TextWrapped(o ? "It has no picture yet, so nothing's laid out." : "Click an object: how its picture is laid out shows here.");
if (o && ImGui::Button("Lay it out (and start its picture)")) readyToPaint(o->id);
return ImGui::End();
}
ImGui::TextWrapped(sculpting_ ? "Sculpting changes its shape, not its picture. Tab goes back to painting colours."
: o ? "Paint on it (or press Start painting it in Properties) and its picture shows here." : "Click an object to paint it: its picture shows here.");
return ImGui::End();
}
uploadPicture(*o, !paint_.active);
const int W = o->picture->w, H = o->picture->h;
const ImVec2 origin = ImGui::GetCursorScreenPos(), avail = ImGui::GetContentRegionAvail();
if (avail.x < 16 || avail.y < 16) return ImGui::End();
if (picZoom_ <= 0 || picFor_ != o->id) {
picZoom_ = std::min(avail.x / float(W), avail.y / float(H)) * 0.96f;
picPan_ = ImVec2((avail.x - float(W) * picZoom_) * 0.5f, (avail.y - float(H) * picZoom_) * 0.5f), picFor_ = o->id;
}
ImGui::InvisibleButton("canvas", avail, ImGuiButtonFlags_MouseButtonLeft | ImGuiButtonFlags_MouseButtonMiddle | ImGuiButtonFlags_MouseButtonRight);
const bool hovered = ImGui::IsItemHovered();
ImGuiIO& io = ImGui::GetIO();
auto toScreen = [&](glm::vec2 p) { return ImVec2(origin.x + picPan_.x + p.x * picZoom_, origin.y + picPan_.y + p.y * picZoom_); };
const glm::vec2 mouse((io.MousePos.x - origin.x - picPan_.x) / picZoom_, (io.MousePos.y - origin.y - picPan_.y) / picZoom_);
if (hovered && io.MouseWheel != 0) { // zoom about the mouse
const float z = std::clamp(picZoom_ * std::pow(1.2f, io.MouseWheel), 0.05f, 64.0f);
picPan_ = ImVec2(io.MousePos.x - origin.x - mouse.x * z, io.MousePos.y - origin.y - mouse.y * z), picZoom_ = z;
}
if (ImGui::IsItemActive() && (ImGui::IsMouseDown(ImGuiMouseButton_Middle) || ImGui::IsMouseDown(ImGuiMouseButton_Right)))
picPan_.x += io.MouseDelta.x, picPan_.y += io.MouseDelta.y;
ImDrawList* dl = ImGui::GetWindowDrawList();
dl->PushClipRect(origin, ImVec2(origin.x + avail.x, origin.y + avail.y), true);
dl->AddRectFilled(origin, ImVec2(origin.x + avail.x, origin.y + avail.y), IM_COL32(24, 24, 28, 255));
uiImage(dl, paintTex_[o->id], toScreen({0, 0}), toScreen({float(W), float(H)}));
dl->AddRect(toScreen({0, 0}), toScreen({float(W), float(H)}), IM_COL32(0, 0, 0, 255));
if (tab_ == Tab::Layout) {
if (o->uvsFit()) layoutCanvas(*o, dl, toScreen, mouse, hovered, W, H);
dl->PopClipRect();
return ImGui::End();
}
if (showUvLines_ && o->uvsFit())
for (const auto& face : o->uvs) {
std::vector<ImVec2> pts;
for (const glm::vec2& q : face) pts.push_back(toScreen(q * glm::vec2(W, H)));
dl->AddPolyline(pts.data(), int(pts.size()), IM_COL32(255, 255, 255, 60), ImDrawFlags_Closed, 1.0f);
}
PictureLayer* el = ledit_.object == o->id ? editLayer() : nullptr;
if (el && !el->sticker) {
ImVec2 q[4];
for (int i = 0; i < 4; ++i) q[i] = toScreen(el->corners[size_t(i)]);
if (hovered && ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
ledit_.drag = -1;
for (int i = 0; i < 4; ++i)
if (std::abs(io.MousePos.x - q[i].x) < 10 && std::abs(io.MousePos.y - q[i].y) < 10) ledit_.drag = i;
if (ledit_.drag < 0 && insidePolygon(io.MousePos, {q[0], q[1], q[2], q[3]})) ledit_.drag = 4;
if (ledit_.drag >= 0) pushUndo();
else lockLayer();
ledit_.grab = mouse, ledit_.startCorners = el->corners;
}
if (ledit_.drag >= 0 && ImGui::IsMouseDown(ImGuiMouseButton_Left)) {
const glm::vec2 d = mouse - ledit_.grab;
const int i = ledit_.drag;
if (i == 4)
for (int k = 0; k < 4; ++k) el->corners[size_t(k)] = ledit_.startCorners[size_t(k)] + d;
else if (io.KeyShift) { // bigger or smaller, the opposite corner staying
const glm::vec2 opp = ledit_.startCorners[size_t((i + 2) % 4)];
const float k = glm::length(mouse - opp) / std::max(glm::length(ledit_.startCorners[size_t(i)] - opp), 1e-3f);
for (int j = 0; j < 4; ++j) el->corners[size_t(j)] = opp + (ledit_.startCorners[size_t(j)] - opp) * k;
} else
el->corners[size_t(i)] = ledit_.startCorners[size_t(i)] + d;
}
if (!ImGui::IsMouseDown(ImGuiMouseButton_Left)) ledit_.drag = -1;
for (int i = 0; i < 4; ++i) q[i] = toScreen(el->corners[size_t(i)]);
dl->AddPolyline(q, 4, kAccent, ImDrawFlags_Closed, 2.0f);
for (int i = 0; i < 4; ++i) {
const bool hot = ledit_.drag == i || (std::abs(io.MousePos.x - q[i].x) < 10 && std::abs(io.MousePos.y - q[i].y) < 10);
dl->AddRectFilled(ImVec2(q[i].x - 6, q[i].y - 6), ImVec2(q[i].x + 6, q[i].y + 6), hot ? kHot : IM_COL32(255, 255, 255, 240));
dl->AddRect(ImVec2(q[i].x - 6, q[i].y - 6), ImVec2(q[i].x + 6, q[i].y + 6), IM_COL32(20, 20, 25, 255));
}
} else {
const bool onPicture = mouse.x >= 0 && mouse.y >= 0 && mouse.x < float(W) && mouse.y < float(H);
const glm::vec2 uv = mouse / glm::vec2(W, H);
// Which layer is on top under the mouse (0: the painting).
int under = 0;
if (const auto it = owner_.find(o->id); onPicture && it != owner_.end() && it->second.size() == size_t(W) * size_t(H))
under = it->second[size_t(int(mouse.y)) * size_t(W) + size_t(int(mouse.x))];
if (hovered && under && !paint_.active) ImGui::SetTooltip("%s: click to move it", o->layers[size_t(under - 1)].name.c_str());
if (hovered && onPicture && ImGui::IsMouseClicked(ImGuiMouseButton_Left) && (under || el)) {
if (under) unlockLayer(o->id, under - 1); // (clicking a placed picture here unlocks it)
else lockLayer();
} else if (hovered && onPicture && ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
if (paintTool_ == PaintTool::Picker || io.KeyAlt) pickColor(*o, uv);
else if (paintTool_ == PaintTool::Fill) fillAt(*o, uv);
else if (paintTool_ == PaintTool::Brush || paintTool_ == PaintTool::Eraser) {
beginStroke(*o, true);
paint_.stroke.dab(*paint_.image, mouse, brushPx_ / picZoom_, hardness_);
paint_.last2D = mouse, paint_.haveLast = true;
}
}
if (paint_.active && paint_.in2D) {
if (!ImGui::IsMouseDown(ImGuiMouseButton_Left)) endStroke();
else {
const float r = brushPx_ / picZoom_, gap = glm::distance(mouse, paint_.last2D);
const int steps = std::max(1, int(std::ceil(gap / std::max(r * 0.3f, 0.5f))));
for (int i = 1; i <= steps; ++i) paint_.stroke.dab(*paint_.image, glm::mix(paint_.last2D, mouse, float(i) / float(steps)), r, hardness_);
paint_.last2D = mouse;
uploaded_[o->id].dirty = true;
}
}
if (hovered && (paintTool_ == PaintTool::Brush || paintTool_ == PaintTool::Eraser)) dl->AddCircle(io.MousePos, brushPx_, IM_COL32(255, 255, 255, 200), 40, 1.5f);
}
dl->PopClipRect();
ImGui::End();
}
auto App::propertiesPanel() -> void {
ImGui::SetNextWindowSizeConstraints(panelMin("Properties"), ImVec2(FLT_MAX, FLT_MAX));
ImGui::Begin("Properties", nullptr, ImGuiWindowFlags_NoCollapse);
const float w = ImGui::GetContentRegionAvail().x;
if (tab_ == Tab::Paint) {
paintProperties(w);
return ImGui::End();
}
if (tab_ == Tab::Render) {
renderProperties(w);
return ImGui::End();
}
if (tab_ == Tab::Layout) {
layoutProperties(w);
return ImGui::End();
}
if (tab_ == Tab::Print) {
printProperties(w);
return ImGui::End();
}
if (Reference* ref = activeRef_ && selected_.empty() ? findRef(activeRef_) : nullptr) {
ImGui::TextWrapped("%s", ref->path.c_str());
int axis = int(ref->axis);
if (ImGui::Combo("Facing", &axis, "Front view\0Side view\0Top view\0")) pushUndo(), ref->axis = Axis(axis);
undoable([&] { return ImGui::DragFloat2("Middle (m)", &ref->offset.x, 0.005f); });
undoable([&] { return ImGui::DragFloat("Width (m)", &ref->width, 0.005f, -100.0f, 100.0f, "%.3f"); });
ImGui::TextDisabled("A minus width flips it.");
undoable([&] { return ImGui::SliderFloat("See-through", &ref->opacity, 0.05f, 1.0f); });
if (ImGui::Checkbox("Only in its own view", &ref->ownViewOnly)) dirty_ = true;
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Shown only looking straight at it (front, side or top): out of the way in the 3D view and the others");
if (ImGui::Button("Remove picture", ImVec2(w, 0))) deleteSelected();
ImGui::End();
return;
}
if (Object* o = editing()) {
editProperties(*o, w);
ImGui::End();
return;
}
if (selected_.empty()) {
ImGui::TextWrapped("Nothing selected.\n\nClick an object to select it, or add one with + in the toolbox (or the Add menu): "
"shapes and starter models, with sizes you can change. Draw shape (D) turns an outline you click into a solid.");
ImGui::End();
return;
}
if (selected_.size() > 1) {
ImGui::Text("%zu objects selected", selected_.size());
glm::vec3 col = find(active_) ? find(active_)->color : glm::vec3(0.8f);
if (undoable([&] { return ImGui::ColorEdit3("Colour (all)", &col.x); }))
for (uint32_t id : selected_)
if (Object* o = find(id)) o->color = col, dirty_ = true;
if (ImGui::Button("Join into one (Ctrl+J)", ImVec2(w, 0))) joinSelected();
ImGui::End();
return;
}
Object* o = find(*selected_.begin());
if (!o) {
ImGui::End();
return;
}
ImGui::BeginDisabled(o->locked);
char name[128];
std::snprintf(name, sizeof name, "%s", o->name.c_str());
if (undoable([&] { return ImGui::InputText("Name", name, sizeof name); }) && name[0]) o->name = name;
// A library shape: its own sizes, until its shape's edited by hand.
if (const ShapeRecipe* r = findRecipe(o->recipe)) {
ImGui::SeparatorText(std::format("{} settings", r->name).c_str());
bool changed = false;
o->settings.resize(r->settings.size());
for (size_t i = 0; i < r->settings.size(); ++i) {
const ShapeSetting& s = r->settings[i];
const float speed = s.whole ? 0.1f : std::max(0.001f, (s.max - s.min) * 0.0005f);
changed |= undoable([&] { return ImGui::DragFloat(s.name, &o->settings[i], speed, s.min, s.max, s.whole ? "%.0f" : "%.3f"); });
}
if (changed) o->mesh = makeFromRecipe(*r, o->settings), touched(o->id);
ImGui::TextDisabled("(These go once you edit the shape by hand.)");
}
ImGui::SeparatorText("Place");
undoable([&] { return ImGui::DragFloat3("Position (m)", &o->position.x, 0.005f, 0, 0, "%.3f"); });
glm::vec3 euler = toEuler(o->rotation);
if (undoable([&] { return ImGui::DragFloat3("Turn (deg)", &euler.x, 0.5f, 0, 0, "%.1f"); })) o->rotation = fromEuler(euler);
if (undoable([&] { return ImGui::DragFloat3("Size", &o->scale.x, 0.005f, 0, 0, "%.3f"); })) touched(o->id);
const glm::vec3 lo = boundsMin(shownMesh(*o)) * glm::abs(o->scale), hi = boundsMax(shownMesh(*o)) * glm::abs(o->scale);
// Its size itself, typed (the scale worked out from it): 0.25 makes it 25 cm, whatever it was.
glm::vec3 dims = hi - lo;
const glm::vec3 was = dims;
if (undoable([&] { return ImGui::DragFloat3("Dimensions (m)", &dims.x, 0.002f, 0.0001f, 1e5f, "%.4g"); })) {
int k = -1;
for (int i = 0; i < 3; ++i)
if (std::abs(dims[i] - was[i]) > 1e-9f) k = i;
if (k >= 0 && was[k] > 1e-7f && dims[k] > 1e-7f) {
const float f = dims[k] / was[k];
if (keepProportions_) o->scale *= f;
else o->scale[k] *= f;
touched(o->id);
}
}
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Across, deep, high: type a size and it's made that big");
ImGui::Checkbox("Keep its proportions", &keepProportions_);
ImGui::SeparatorText("Look");
materialPicker(*o);
undoable([&] { return ImGui::ColorEdit3("Colour", &o->color.x); });
undoable([&] { return ImGui::SliderFloat("Metal", &o->metal, 0, 1); });
undoable([&] { return ImGui::SliderFloat("Rough", &o->rough, 0, 1); });
if (ImGui::Checkbox("Smooth shading", &o->smooth)) pushUndo(), touched(o->id);
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Round surfaces look round; edges sharper than the angle stay sharp");
if (o->smooth) {
ImGui::SameLine();
ImGui::SetNextItemWidth(-1);
if (undoable([&] { return ImGui::SliderFloat("##angle", &o->smoothAngle, 1, 180, "creases > %.0f deg"); })) touched(o->id);
}
// Finishing touches that stay changeable: rounded edges, smoothing, a mirrored half.
ImGui::SeparatorText("Round, smooth, mirror");
if (undoable([&] { return ImGui::DragFloat("Round edges", &o->round, 0.001f, 0.0f, 10.0f, o->round > 0 ? "%.3f m" : "off"); })) {
if (o->round > 0 && o->roundSteps > 1) o->smooth = true;
touched(o->id);
}
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Rounds off every sharp edge and corner (drag right)");
if (o->round > 0) {
if (undoable([&] { return ImGui::SliderInt("Steps round", &o->roundSteps, 1, 8); })) touched(o->id);
if (undoable([&] { return ImGui::SliderFloat("Edges sharper than", &o->roundAngle, 1, 179, "%.0f deg"); })) touched(o->id);
}
if (undoable([&] { return ImGui::SliderInt("Smooth out", &o->smoothLevels, 0, 3, o->smoothLevels ? "%d times" : "off"); })) {
if (o->smoothLevels) o->smooth = true;
touched(o->id);
}
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Cuts every face into smaller ones and rounds the whole shape (like clay)");
if (o->smoothLevels && ImGui::Checkbox("Keep sharp edges sharp", &o->smoothKeepSharp)) pushUndo(), touched(o->id);
ImGui::TextDisabled("Mirror across");
for (int a = 0; a < 3; ++a) {
ImGui::SameLine();
bool on = o->mirror & (1 << a);
if (ImGui::Checkbox(a == 0 ? "X" : a == 1 ? "Y" : "Z", &on)) pushUndo(), o->mirror ^= 1 << a, touched(o->id);
}
if (o->hasFinish() && ImGui::Button("Make it part of the shape", ImVec2(w, 0))) applyFinish(*o);
if (o->hasFinish() && ImGui::IsItemHovered()) ImGui::SetTooltip("Bake the rounding, smoothing and mirror into the points (so you can edit them)");
if (const Object* t = fry::cutTarget(scene_, *o)) { // (an editable cutter)
ImGui::SeparatorText("Cut");
ImGui::TextColored(accentText(), "Cuts into %s", t->name.c_str());
ImGui::TextDisabled("Move it, turn it, change its shape: the hole follows.");
const uint32_t target = t->id, me = o->id;
if (ImGui::Button("Apply: make the cut for good", ImVec2(w, 0))) return applyCuts(target, me);
if (ImGui::Button("Stop cutting (keep it as an object)", ImVec2(w, 0))) pushUndo(), o->cuts = 0, dirty_ = true;
} else if (cutKeys_.count(o->id)) {
int n = 0;
for (const Object& c : scene_.objects) n += c.cuts == o->id && isCutter(c);
ImGui::SeparatorText("Cut");
ImGui::TextDisabled("%d editable cut%s in it", n, n == 1 ? "" : "s");
if (ImGui::Button(n == 1 ? "Apply: make the cut for good" : "Apply: make them all for good", ImVec2(w, 0))) return applyCuts(o->id);
if (ImGui::Button("Pick the cutters", ImVec2(w, 0))) {
selected_.clear();
for (const Object& c : scene_.objects)
if (c.cuts == o->id) selected_.insert(c.id), active_ = c.id;
}
}
ImGui::SeparatorText("Do");
if (ImGui::Button("Edit shape (Tab)", ImVec2(w, 0))) enterEdit();
if (ImGui::Button("Apply turn and size", ImVec2(w, 0))) applyTransform(*o);
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Bake them into the shape: turn becomes 0, size 1");
if (ImGui::Button("Origin to middle", ImVec2((w - 6) / 2, 0))) originToMiddle(*o);
ImGui::SameLine(0, 6);
if (ImGui::Button("Origin to bottom", ImVec2(-1, 0))) originToBottom(*o);
if (ImGui::Button("Flip X", ImVec2((w - 12) / 3, 0))) mirror(*o, 0);
ImGui::SameLine(0, 6);
if (ImGui::Button("Flip Y", ImVec2((w - 12) / 3, 0))) mirror(*o, 1);
ImGui::SameLine(0, 6);
if (ImGui::Button("Flip Z", ImVec2(-1, 0))) mirror(*o, 2);
ImGui::EndDisabled();
if (ImGui::Button(o->locked ? "Unlock" : "Lock", ImVec2((w - 6) / 2, 0))) o->locked = !o->locked;
ImGui::SameLine(0, 6);
if (ImGui::Button("Delete", ImVec2(-1, 0))) deleteSelected();
ImGui::End();
}
// A material to start from: sets colour, metal and rough in one go (each a little ball of it).
// Yours (saved here, or from plug-ins and scripts) first; "Save its look as a material" adds one.
auto App::materialPicker(Object& o) -> void {
auto matches = [&](const MaterialPreset& m) {
return std::abs(m.metal - o.metal) < 0.01f && std::abs(m.rough - o.rough) < 0.01f &&
(m.keepColor || glm::all(glm::lessThan(glm::abs(m.color - o.color), glm::vec3(0.01f))));
};
const MaterialPreset* now = nullptr;
for (const MaterialPreset& m : materialPresets())
if (matches(m)) now = &m;
for (const MaterialPreset& m : ownMaterials())
if (matches(m)) now = &m;
ImGui::SetNextItemWidth(ImGui::CalcItemWidth());
if (ImGui::BeginCombo("Material", now ? now->name.c_str() : "(its own)", ImGuiComboFlags_HeightLarge)) {
std::optional<std::string> remove;
auto item = [&](const MaterialPreset& m, bool own) {
const ImVec2 p = ImGui::GetCursorScreenPos();
const float h = ImGui::GetTextLineHeight();
ImGui::PushID(m.id.c_str());
ImGui::PushID(own);
if (ImGui::Selectable("##m", now == &m, 0, ImVec2(0, h))) pushUndo(), applyMaterial(o, m), touched(o.id);
if (own && m.from.empty() && ImGui::BeginPopupContextItem()) {
if (ImGui::MenuItem("Remove it")) remove = m.id;
ImGui::EndPopup();
}
if (own && ImGui::IsItemHovered())
ImGui::SetTooltip("%s", m.from.empty() ? "Yours (right-click to remove)" : ("From " + m.from).c_str());
ImGui::PopID();
ImGui::PopID();
// A ball: its colour, darker round the edge, a highlight as sharp as it's smooth.
const glm::vec3 c = m.keepColor ? o.color : m.color;
const ImVec2 mid(p.x + h * 0.5f, p.y + h * 0.5f);
ImDrawList* dl = ImGui::GetWindowDrawList();
dl->AddCircleFilled(mid, h * 0.45f, ImGui::ColorConvertFloat4ToU32(ImVec4(c.r * 0.55f, c.g * 0.55f, c.b * 0.55f, 1)));
dl->AddCircleFilled(ImVec2(mid.x - h * 0.05f, mid.y - h * 0.05f), h * 0.36f, ImGui::ColorConvertFloat4ToU32(ImVec4(c.r, c.g, c.b, 1)));
dl->AddCircleFilled(ImVec2(mid.x - h * 0.14f, mid.y - h * 0.14f), h * (0.06f + 0.1f * m.rough), IM_COL32(255, 255, 255, int(230 * (1.0f - m.rough * 0.8f))));
dl->AddText(ImVec2(p.x + h * 1.4f, p.y), ImGui::GetColorU32(ImGuiCol_Text), m.name.c_str());
};
if (!ownMaterials().empty()) {
ImGui::SeparatorText("Yours");
for (const MaterialPreset& m : ownMaterials()) item(m, true);
ImGui::SeparatorText("Fry3DX's");
}
for (const MaterialPreset& m : materialPresets()) item(m, false);
ImGui::Separator();
if (ImGui::Selectable("Save its look as a material...")) nameMaterial_ = true, materialName_.clear(), materialKeepColor_ = false;
ImGui::EndCombo();
if (remove && removeOwnMaterial(*remove)) saveOwnMaterials();
}
if (std::exchange(nameMaterial_, false)) ImGui::OpenPopup("Save as a material");
ImGui::SetNextWindowSize(ImVec2(340, 0));
if (ImGui::BeginPopupModal("Save as a material", nullptr, ImGuiWindowFlags_NoResize)) {
ImGui::TextWrapped("Its colour, metal and rough as one of your materials, in the picker for every file.");
if (ImGui::IsWindowAppearing()) ImGui::SetKeyboardFocusHere();
ImGui::SetNextItemWidth(-FLT_MIN);
inputString("##name", materialName_, "Its name (\"Teal plastic\")");
ImGui::Checkbox("Only how metal and rough (keep each object's colour)", &materialKeepColor_);
const bool taken = std::any_of(materialPresets().begin(), materialPresets().end(), [&](const MaterialPreset& m) { return m.id == materialId(materialName_); });
if (taken) ImGui::TextColored(roleColor(keel::ui::Role::DangerText), "That's one of Fry3DX's own: another name");
ImGui::BeginDisabled(materialId(materialName_).empty() || taken);
pushAccent();
const bool save = ImGui::Button("Save", ImVec2(120, 0)) || ImGui::IsKeyPressed(ImGuiKey_Enter, false);
popAccent();
ImGui::EndDisabled();
ImGui::SameLine();
if (save && !materialId(materialName_).empty() && !taken) {
addOwnMaterial({materialId(materialName_), materialName_, o.color, o.metal, o.rough, materialKeepColor_, ""});
saveOwnMaterials();
say("Saved \"" + materialName_ + "\": it's in the Material picker now");
ImGui::CloseCurrentPopup();
}
if (ImGui::Button("Cancel", ImVec2(120, 0))) ImGui::CloseCurrentPopup();
ImGui::EndPopup();
}
}
auto App::editProperties(Object& o, float w) -> void {
ImGui::Text("Editing the shape of %s", o.name.c_str());
ImGui::TextDisabled("%zu points, %zu faces", o.mesh.verts.size(), o.mesh.faces.size());
if (o.hasFinish()) ImGui::TextDisabled("(its rounding and smoothing show again when you're done)");
const std::set<int> pts = selectedPoints();
if (!pts.empty()) {
// Where the selection's middle is (in the world); typing moves it there.
const glm::vec3 c = pivotOfSelection();
glm::vec3 at = c;
if (undoable([&] { return ImGui::DragFloat3("Middle (m)", &at.x, 0.002f, 0, 0, "%.3f"); })) {
const glm::mat4 m = objectMatrix(o), local = glm::inverse(m) * glm::translate(glm::mat4(1.0f), at - c) * m;
for (int v : pts) o.mesh.verts[size_t(v)] = glm::vec3(local * glm::vec4(o.mesh.verts[size_t(v)], 1.0f));
handMade(o);
touched(o.id);
}
}
ImGui::SeparatorText("Faces");
ImGui::SetNextItemWidth(w * 0.45f);
ImGui::DragFloat("##ext", &extrudeAmount_, 0.001f, -10, 10, "%.3f m");
ImGui::SameLine();
if (ImGui::Button("Extrude", ImVec2(-1, 0))) extrudeNow(extrudeAmount_);
ImGui::SetNextItemWidth(w * 0.45f);
ImGui::SliderFloat("##ins", &insetAmount_, 0.01f, 0.99f, "%.2f");
ImGui::SameLine();
if (ImGui::Button("Inset", ImVec2(-1, 0))) insetNow(insetAmount_);
if (ImGui::Button("Flip", ImVec2((w - 6) / 2, 0))) flipNow();
ImGui::SameLine(0, 6);
if (ImGui::Button("Make face", ImVec2(-1, 0))) makeFaceNow();
if (ImGui::Button("Bridge two faces", ImVec2(w, 0))) bridgeNow();
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Two faces with as many corners: taken out and joined by a tunnel");
if (ImGui::Button("Make into its own object (P)", ImVec2(w, 0))) separateSelected();
ImGui::SeparatorText("Edges");
ImGui::SetNextItemWidth(w * 0.45f);
ImGui::DragFloat("##bw", &bevelWidth_, 0.001f, 0.0f, 10.0f, "%.3f m");
ImGui::SameLine();
ImGui::SetNextItemWidth(w * 0.2f);
ImGui::DragInt("##bs", &bevelSteps_, 0.1f, 1, 10);
ImGui::SameLine();
if (ImGui::Button("Round", ImVec2(-1, 0))) bevelNow();
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Round the selected edges (or the edges round the selected faces): width, steps");
ImGui::SeparatorText("Points");
if (ImGui::Button("Merge to middle (M)", ImVec2(w, 0))) mergeNow();
if (ImGui::Button("Smooth", ImVec2((w - 6) / 2, 0))) smoothPointsNow();
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Even out bumps: each point towards its neighbours");
ImGui::SameLine(0, 6);
if (ImGui::Button("Push / pull (Alt+S)", ImVec2(-1, 0))) startPush();
ImGui::SetNextItemWidth(w * 0.45f);
ImGui::DragFloat("##md", &mergeDistance_, 0.0001f, 0.0f, 1.0f, "%.4f m");
ImGui::SameLine();
if (ImGui::Button("Merge close", ImVec2(-1, 0))) {
pushUndo();
const int gone = mergeByDistance(o.mesh, mergeDistance_);
changedShape(o);
say(std::format("{} points merged", gone));
}
ImGui::SeparatorText("Whole shape");
if (ImGui::Button("Cut in four", ImVec2((w - 6) / 2, 0))) subdivideNow(false);
ImGui::SameLine(0, 6);
if (ImGui::Button("Smooth it", ImVec2(-1, 0))) subdivideNow(true);
ImGui::SeparatorText("Select");
if (ImGui::Button("All", ImVec2((w - 12) / 3, 0))) selectAllElements();
ImGui::SameLine(0, 6);
if (ImGui::Button("None", ImVec2((w - 12) / 3, 0))) clearElements();
ImGui::SameLine(0, 6);
if (ImGui::Button("Invert", ImVec2(-1, 0))) invertSelection();
if (ImGui::Button("More", ImVec2((w - 12) / 3, 0))) growSelection();
ImGui::SameLine(0, 6);
if (ImGui::Button("Less", ImVec2((w - 12) / 3, 0))) shrinkSelection();
ImGui::SameLine(0, 6);
if (ImGui::Button("Joined", ImVec2(-1, 0))) selectLinked();
ImGui::Separator();
if (ImGui::Button("Delete (Del)", ImVec2(w, 0))) deleteElements();
if (ImGui::Button("Done (Tab)", ImVec2(w, 0))) leaveEdit();
}
auto App::statusBar() -> void {
ImGui::Begin("Status", nullptr, ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoScrollbar);
if (now() - messageAt_ < 4.0) ImGui::TextColored(accentText(), "%s", message_.c_str());
else if (tab_ == Tab::Layout) {
for (const LayToolInfo& t : kLayTools)
if (t.tool == layTool_)
ImGui::TextDisabled("%s: %s · Tab: frames or corners Right drag: look (pan in the Picture panel) F1: all keys", t.name, t.hint);
} else if ((tab_ == Tab::Print && printTool_ != PrintTool::None) || printTool_ == PrintTool::Measure) {
ImGui::TextDisabled(printTool_ == PrintTool::Measure ? "Measure: click two points on the model (corners catch the mouse); a third click starts again · M (Print) or Esc: done"
: "Lay flat: click the face it should stand on: it turns so that face is down, on the bed · L: done");
} else if (tab_ == Tab::Paint && sculpting_) {
for (const SculptToolInfo& t : kSculptTools)
if (t.brush == sculptBrush_) ImGui::TextDisabled("%s: %s · Shift: smooth X: both sides Tab: colour Right drag: look F1: all keys", t.name, t.hint);
} else if (tab_ == Tab::Paint) {
for (const PaintToolInfo& t : kPaintTools)
if (t.tool == paintTool_) ImGui::TextDisabled("%s: %s · Right drag: look Wheel: forward / back (zoom in the Picture panel) F1: all keys", t.name, t.hint);
} else
for (const ToolInfo& t : kTools)
if (t.tool == tool_)
ImGui::TextDisabled("%s: %s · %s F1: all keys", t.name, t.hint,
fry_camera.i() == 1 ? "Right drag: orbit Middle drag: pan Wheel: zoom Shift+C: fly"
: "Right drag + WASD: look and move Alt+right: orbit Wheel: forward / back Shift+C: orbit");
ImGui::End();
}
// The view's corner: which way you're looking, buttons to look straight at a side, and
// handles to drag to orbit, pan and zoom (for a touchpad or a pen).
auto App::viewButtons() -> void {
const ImVec2 at(viewMax_.x - 10, viewMin_.y + 10);
ImGui::SetNextWindowPos(at, ImGuiCond_Always, ImVec2(1, 0));
ImGui::SetNextWindowBgAlpha(0.55f);
ImGui::Begin("##views", nullptr, ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoFocusOnAppearing |
ImGuiWindowFlags_NoNav | ImGuiWindowFlags_NoDocking);
static const char* names[] = {"Perspective", "Front", "Back", "Left", "Right", "Top", "Bottom"};
static const char* shadings[] = {"Solid", "Rendered", "Wireframe"};
ImGui::TextColored(accentText(), "%s", names[int(view_)]);
ImGui::SameLine();
ImGui::TextDisabled("%s%s", shadings[int(shading_)], xray_ ? ", X-ray" : "");
for (int i = 1; i < 7; ++i) {
if (i != 1 && i != 4) ImGui::SameLine(0, 3);
if (ImGui::Button(names[i], ImVec2(56, 0))) setView(View(i));
}
if (ImGui::Button("3D", ImVec2(56, 0))) leaveFlatView();
ImGui::SameLine(0, 3);
if (ImGui::Button("Frame", ImVec2(56, 0))) frameSelected();
ImGui::SameLine(0, 3);
if (ImGui::Button(xray_ ? "Solid" : "X-ray", ImVec2(56, 0))) xray_ = !xray_;
const ImVec2 d = ImGui::GetIO().MouseDelta;
ImGui::Button("Orbit", ImVec2(56, 0));
if (ImGui::IsItemActive()) orbitBy(d);
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Drag to orbit");
ImGui::SameLine(0, 3);
ImGui::Button("Pan", ImVec2(56, 0));
if (ImGui::IsItemActive()) panBy(d);
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Drag to pan");
ImGui::SameLine(0, 3);
ImGui::Button("Zoom", ImVec2(56, 0));
if (ImGui::IsItemActive()) dist_ = std::clamp(dist_ * std::pow(1.01f, d.y), 0.01f, 5000.0f);
if (ImGui::IsItemHovered()) ImGui::SetTooltip("Drag up and down to zoom");
if (tab_ != Tab::Render && ImGui::Button(shading_ == Shading::Rendered ? "Show: Solid" : "Show: Rendered", ImVec2(56 * 3 + 6, 0)))
shading_ = shading_ == Shading::Rendered ? Shading::Solid : Shading::Rendered;
ImGui::End();
}
} // namespace fryapp
Reference in a new issue View git blame Copy permalink