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.h

1543 lines
77 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

// Fry3DX — Frying 3D Extreme (the app: its state and what it does, declared; defined in app*.cpp). A 3D modeller that works the way you'd expect: pick a tool from the
// toolbox, click and drag. The view in the middle is drawn by the engine's renderer: plain
// and clear while you model (Solid), or properly lit (Rendered). The panels are Dear ImGui.
//
// fry3dx [file.fry]
#pragma once
#include "bvh.h"
#include "commands.h"
#include "icons.h"
#include "mesh.h"
#include "scene.h"
#include "script.h"
#include "sculpt.h"
#include "shapes.h"
#include "import.h"
#include "text.h"
#include <SDL3/SDL.h>
#include <core/cvar.h>
#include <core/sysinfo.h>
#include <core/log.h>
#include <engine.h>
#include <fs/vfs.h>
#include <render/renderer.h>
#include <render/screenshot.h>
#include <ui/ui.h>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <glm/gtx/matrix_decompose.hpp>
#include <glm/gtx/quaternion.hpp>
#include <imgui.h>
#include <imgui_internal.h>
#include <stb_image.h>
#include <stb_image_write.h>
#include <algorithm>
#include <bit>
#include <cmath>
#include <cstring>
#include <filesystem>
#include <format>
#include <chrono>
#include <ctime>
#include <fstream>
#include <functional>
#include <future>
#include <map>
#include <mutex>
#include <memory>
#include <optional>
#include <span>
using namespace fry;
namespace stdfs = std::filesystem;
namespace fryapp {
inline double now() { return double(SDL_GetTicks()) / 1000.0; } // (seconds; works before the UI exists)
constexpr float kUnits = 39.37f; // the engine's units (inches) in a metre: the view renders in them
constexpr float kPi = 3.14159265358979f;
enum class Mode { Object, Edit };
enum class Tool { Select, Move, Rotate, Scale, Draw, Extrude, Inset, Bevel, LoopCut, Knife, Hole };
enum class Tab { Model, Paint, Layout, Render, Print };
enum class LayTool { Select, Move, Rotate, Scale };
enum class PrintTool { None, Measure, LayFlat };
enum class PaintTool { Brush, Eraser, Fill, Picker, Picture };
enum class Elem { Vertex, Edge, Face };
enum class View { Perspective, Front, Back, Left, Right, Top, Bottom };
enum class Orient { Local, World, Normal };
// which way the gizmo's arrows point
enum class Pivot { Middle, Origin, Opposite, Bottom }; // what stays put when turning / sizing
enum class Shading { Solid, Rendered, Wire };
enum class SelShape { Box, Brush, Lasso };
struct ToolInfo {
Tool tool;
Icon icon;
const char* name;
const char* key;
const char* hint;
bool objectMode, editMode;
};
const ToolInfo kTools[] = {
{Tool::Select, Icon::Select, "Select", "Q", "Click to select; drag round things. Objects: Shift adds, Ctrl takes away. Shape: Ctrl adds/takes one, Shift+click a whole loop, Shift+Ctrl+click an edge ring.", true, true},
{Tool::Move, Icon::Move, "Move", "W", "Drag an arrow to move along it, the square to move freely. Hold Ctrl to snap.", true, true},
{Tool::Rotate, Icon::Rotate, "Rotate", "E", "Drag a ring to turn about it; the outer ring turns it as you see it. Ctrl: 15 degree steps.", true, true},
{Tool::Scale, Icon::Scale, "Scale", "R", "Drag a side's handle to stretch it (the other side stays, or see Tool options); hold Shift to stretch both sides from the middle. Middle: all ways.", true, true},
{Tool::Draw, Icon::Draw, "Draw shape", "D", "Click points round a shape (on the ground, or on any face of an object); click the first point (or press Enter) to finish. Esc cancels.", true, false},
{Tool::Extrude, Icon::Extrude, "Extrude", "X", "Select faces, then drag the arrow to pull them out (along the way they face).", false, true},
{Tool::Inset, Icon::Inset, "Inset", "I", "Select faces, then drag the handle to make a smaller face inside each.", false, true},
{Tool::Bevel, Icon::Bevel, "Round edges", "B", "Select edges (or faces), then drag the round handle to round them off.", false, true},
{Tool::LoopCut, Icon::LoopCut, "Loop cut", "C", "Point at an edge: the cut shows across. Click to cut there.", false, true},
{Tool::Knife, Icon::Knife, "Knife", "K", "Click points along where to cut, or drag a straight line. Enter or double-click cuts. Cutting right through: Tool options.", false, true},
{Tool::Hole, Icon::Hole, "Hole", "O", "Press on a face and drag out the size: round, rectangle, triangle or hexagon (nuts); all the way through, a pocket, or only its outline (a new face).", true, true},
};
struct PaintToolInfo {
PaintTool tool;
Icon icon;
const char* name;
const char* key;
const char* hint;
};
struct LayToolInfo {
LayTool tool;
Icon icon;
const char* name;
const char* key;
const char* hint;
};
const LayToolInfo kLayTools[] = {
{LayTool::Select, Icon::Select, "Select", "Q", "Click frames (or corners) to pick them, Shift adds; drag round them to pick many. Clicking the model picks its frame too."},
{LayTool::Move, Icon::Move, "Move", "W", "Drag frames (or corners) about the picture."},
{LayTool::Rotate, Icon::Rotate, "Turn", "E", "Drag round to turn what's picked (Ctrl: 15 degree steps)."},
{LayTool::Scale, Icon::Scale, "Size", "R", "Drag out or in to make what's picked bigger or smaller (Shift: only across or only up)."},
};
// Printers' build plates (mm, across x deep x high) and what's printed with.
struct PrinterInfo {
const char* name;
float x, y, z;
};
const PrinterInfo kPrinters[] = {
{"Prusa MK4 / MK4S", 250, 210, 220}, {"Prusa Core One", 250, 220, 270}, {"Prusa MINI+", 180, 180, 180}, {"Bambu Lab X1 / P1 / P2", 256, 256, 256},
{"Bambu Lab A1", 256, 256, 256}, {"Bambu Lab A1 mini", 180, 180, 180}, {"Creality Ender 3 (V2, V3)", 220, 220, 250}, {"Creality K1", 220, 220, 250},
{"Elegoo Neptune 4", 225, 225, 265}, {"Anycubic Kobra 3", 250, 250, 260}, {"Your own size", 0, 0, 0},
};
struct MaterialInfo {
const char* name;
float density; // g/cm3
};
// What the Script panel starts with.
inline const char* kFirstScript = R"(-- A script builds or changes the scene. F5 or Ctrl+Enter runs it;
-- Ctrl+Z takes back everything it did. The ? button lists what there is.
local legs = 6
for i = 1, legs do
local a = math.rad(i * 360 / legs)
local leg = fry.add("cylinder", {radius = 0.03, height = 0.7, color = "#c47a3c"})
leg.position = {math.cos(a) * 0.45, math.sin(a) * 0.45, 0}
end
local top = fry.add("cylinder", {radius = 0.6, height = 0.05, sides = 48, color = "#d9a066"})
top.position = {0, 0, 0.7}
fry.frame()
)";
const MaterialInfo kMaterials[] = {{"PLA", 1.24f}, {"PETG", 1.27f}, {"ABS", 1.04f}, {"ASA", 1.07f}, {"TPU", 1.21f}, {"Nylon", 1.14f}, {"Resin", 1.12f}};
struct SculptToolInfo {
SculptBrush brush;
Icon icon;
const char* name;
const char* key;
const char* hint;
};
const SculptToolInfo kSculptTools[] = {
{SculptBrush::Draw, Icon::Sculpt, "Raise", "1", "Builds the surface up where you brush. Ctrl digs in instead."},
{SculptBrush::Inflate, Icon::Inflate, "Puff out", "2", "Swells it out all round, like blowing it up. Ctrl shrinks it."},
{SculptBrush::Smooth, Icon::Smooth, "Smooth", "3", "Evens out bumps. Hold Shift with any brush to smooth."},
{SculptBrush::Flatten, Icon::Flatten, "Flatten", "4", "Presses it flat, like a palette knife."},
{SculptBrush::Pinch, Icon::Pinch, "Pinch", "5", "Pulls it in towards the middle of the brush: sharp creases and ridges. Ctrl pushes apart."},
{SculptBrush::Grab, Icon::Grab, "Grab", "6", "Take hold of a patch and drag it where it should be."},
};
const PaintToolInfo kPaintTools[] = {
{PaintTool::Brush, Icon::PaintBrush, "Brush", "B", "Paint on the model or on the flat picture. Alt+click picks a colour; [ and ] change the size."},
{PaintTool::Eraser, Icon::Eraser, "Eraser", "E", "Paints its plain colour back."},
{PaintTool::Fill, Icon::Fill, "Fill", "G", "Fills the patch of about the same colour where you click."},
{PaintTool::Picker, Icon::Picker, "Pick colour", "I", "Click to take a colour from the model or the picture."},
{PaintTool::Picture, Icon::Picture, "Place a picture", "Ctrl+V", "Paste a picture (copied in any app) or add one from a file, then drag its corners to fit. Enter places it."},
};
inline glm::vec3 forwardOf(float yaw, float pitch) {
const float y = glm::radians(yaw), p = glm::radians(pitch);
return {std::cos(p) * std::cos(y), std::cos(p) * std::sin(y), -std::sin(p)};
}
// The engine's view-projection (render/renderer.cpp), in metres.
inline glm::mat4 viewProjection(const glm::vec3& eye, float yaw, float pitch, float fov, float aspect, glm::vec2 shift, glm::vec2 nearFar) {
const glm::vec3 f = forwardOf(yaw, pitch);
glm::mat4 view = glm::lookAt(eye * kUnits, eye * kUnits + f, glm::vec3(0, 0, 1));
glm::mat4 proj = glm::perspective(glm::radians(fov), aspect, nearFar.x, nearFar.y);
proj[1][1] *= -1.0f;
proj[2][0] -= shift.x, proj[2][1] -= shift.y;
return proj * view * glm::scale(glm::mat4(1.0f), glm::vec3(kUnits));
}
struct Ray {
glm::vec3 origin, dir;
};
// Möller–Trumbore; t along the ray, or nothing.
inline std::optional<glm::vec3> hitPlane(const Ray& r, const glm::vec3& point, const glm::vec3& normal) {
const float d = glm::dot(r.dir, normal);
if (std::abs(d) < 1e-8f) return std::nullopt;
const float t = glm::dot(point - r.origin, normal) / d;
return t > 0 ? std::optional<glm::vec3>(r.origin + r.dir * t) : std::nullopt;
}
// Where along the line (from `p`, along unit `axis`) the ray passes closest.
inline float closestOnAxis(const Ray& r, const glm::vec3& p, const glm::vec3& axis) {
const glm::vec3 w = p - r.origin;
const float b = glm::dot(axis, r.dir), d = glm::dot(axis, w), e = glm::dot(r.dir, w);
const float den = 1.0f - b * b;
return den < 1e-6f ? 0.0f : (b * e - d) / den;
}
inline float distToSegment(ImVec2 p, ImVec2 a, ImVec2 b) {
const float vx = b.x - a.x, vy = b.y - a.y, len = vx * vx + vy * vy;
const float t = len > 0 ? std::clamp(((p.x - a.x) * vx + (p.y - a.y) * vy) / len, 0.0f, 1.0f) : 0.0f;
const float dx = a.x + vx * t - p.x, dy = a.y + vy * t - p.y;
return std::sqrt(dx * dx + dy * dy);
}
inline std::string lower(std::string s) {
std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return char(std::tolower(c)); });
return s;
}
inline bool insidePolygon(ImVec2 p, const std::vector<ImVec2>& poly) {
bool in = false;
for (size_t i = 0, j = poly.size() - 1; i < poly.size(); j = i++)
if ((poly[i].y > p.y) != (poly[j].y > p.y) && p.x < (poly[j].x - poly[i].x) * (p.y - poly[i].y) / (poly[j].y - poly[i].y) + poly[i].x) in = !in;
return in;
}
inline float snapTo(float v, float step) { return step > 0 ? std::round(v / step) * step : v; }
using Axes = std::array<glm::vec3, 3>;
inline glm::vec3 inFrame(const Axes& a, const glm::vec3& p) { return {glm::dot(p, a[0]), glm::dot(p, a[1]), glm::dot(p, a[2])}; }
inline glm::vec3 fromFrame(const Axes& a, const glm::vec3& c) { return a[0] * c.x + a[1] * c.y + a[2] * c.z; }
const ImU32 kAxisCol[3] = {IM_COL32(235, 70, 70, 255), IM_COL32(110, 210, 80, 255), IM_COL32(70, 130, 245, 255)};
const ImU32 kHot = IM_COL32(255, 225, 90, 255);
constexpr ImU32 kAccent = IM_COL32(255, 120, 40, 255);
// The UI's colours: Niveus's roles, in the appearance that's showing (keel/ui).
inline ImVec4 roleColor(keel::ui::Role r) { return ImGui::ColorConvertU32ToFloat4(keel::ui::color(r)); }
inline ImVec4 accentText() { return roleColor(keel::ui::Role::AccentText); }
// The one button that does it, filled with the accent (until popAccent).
inline void pushAccent() {
using keel::ui::Role;
ImGui::PushStyleColor(ImGuiCol_Button, roleColor(Role::Accent));
ImGui::PushStyleColor(ImGuiCol_ButtonHovered, roleColor(Role::AccentHover));
ImGui::PushStyleColor(ImGuiCol_ButtonActive, roleColor(Role::AccentActive));
ImGui::PushStyleColor(ImGuiCol_Text, roleColor(Role::OnAccent));
}
inline void popAccent() { ImGui::PopStyleColor(4); }
// An object as it'll be printed: where it stands, with its finish, checked (kept until it changes).
struct PrintInfo {
uint64_t key = ~0ull;
Mesh world;
PrintCheck check;
glm::vec3 lo{0.0f}, hi{0.0f};
keel::ModelId overhang{};
bool hasOverhang = false;
// Walls too thin to print: how thick at each face (worked out again only when its shape or
// size changes: moving or turning it doesn't), how many under the least, the thinnest.
uint64_t thickKey = ~0ull;
std::vector<float> thick;
int thinFaces = 0;
float thinnest = 1e30f;
keel::ModelId thin{};
// The slice preview's layer: where it was cut, and for which shape (kept beside what it's of).
mutable uint64_t sliceKey = ~0ull;
mutable float sliceZ = -1;
mutable std::vector<std::pair<glm::vec3, glm::vec3>> slice;
};
extern keel::Cvar fry_printer;
extern keel::Cvar fry_bed_x;
extern keel::Cvar fry_bed_y;
extern keel::Cvar fry_bed_z;
extern keel::Cvar fry_touch;
extern keel::Cvar fry_uiscale;
extern keel::Cvar fry_uisize;
extern keel::Cvar fry_theme;
extern keel::Cvar fry_movespeed;
extern keel::Cvar fry_camera;
extern keel::Cvar fry_pluginsoff;
extern keel::Cvar fry_autosave;
class App : public keel::Game {public:
explicit App(std::string path) : startPath_(std::move(path)) {}
const char* name() const override { return "Fry3DX"; } // (its settings folder, and bin/Fry3DX/)
const char* title() const override { return "Fry3DX"; }
bool wantsCursor() const override { return true; }
bool dockingUi() const override { return true; }
// "Spiral_stairs" is "Spiral stairs" (typed in the console).
static bool sameCommand(const std::string& name, std::string typed);
void init() override;
// Going into the background: the work is saved now (a phone may close the app while it's
// away, to free memory), and a phone's next start carries on with it, view and all.
std::string resumeFile() const { return keel::prefPath() + "resume.txt"; }
void onBackground() override;
void resumeWork();
void frame(double) override { autosave(); }
bool allowQuit() override;
void shutdown() override {
if (autosaveJob_.valid()) autosaveJob_.wait();
}
void onEscape() override;
void render(keel::Renderer& r) override;
private:
// ── The document ──
Scene scene_;
std::string startPath_, path_;
bool dirty_ = false;
// An undo step. Its objects without their shapes (points, faces, painting's layout): those are
// kept apart and shared with the steps before and after where they're the same, so a step
// that moved one thing doesn't copy every shape in the scene again.
struct Shape {
std::shared_ptr<const Mesh> mesh;
std::shared_ptr<const std::vector<std::vector<glm::vec2>>> uvs;
};
struct Snapshot {
Scene scene;
std::map<uint32_t, Shape> shapes;
std::set<uint32_t> selected;
uint32_t active;
Mode mode;
std::set<int> verts, faces;
std::set<std::pair<int, int>> edges;
std::string label; // (what was done after it: the message said then)
double at = 0;
};
std::vector<Snapshot> undo_, redo_;
std::map<uint32_t, Shape> lastShapes_; // (each object's shape as last kept: the next step shares it if it's the same)
Snapshot snapshot(std::string label, double at);
std::vector<Snapshot> redoKept_; // (what redo had before the last undo point: back if that step is dropped)
Mode mode_ = Mode::Object;
Tool tool_ = Tool::Move;
Elem elem_ = Elem::Face;
std::set<uint32_t> selected_;
uint32_t active_ = 0;
// the object last picked (edited in shape editing)
uint32_t activeRef_ = 0; // a reference picture picked in the Layers panel
std::set<int> selVerts_, selFaces_;
std::set<std::pair<int, int>> selEdges_;
// ── Tabs: modelling, painting pictures onto it, making a picture of it ──
Tab tab_ = Tab::Model;
// ── The view ──
keel::Renderer* r_ = nullptr;
glm::vec2 shift_{0.0f}; // (the view's middle on the screen: it sits between the panels)
View view_ = View::Perspective;
glm::vec3 target_{0, 0, 0.4f};
float yaw_ = -135.0f, pitch_ = 25.0f, dist_ = 4.0f, fov_ = 50.0f;
glm::vec2 nearFar_{2.0f, 16384.0f};
std::map<uint32_t, std::pair<uint64_t, float>> radii_; // (each object's mesh: how far it reaches from its place)
ImVec2 viewMin_{0, 0}, viewMax_{1, 1};
glm::mat4 vp_{1.0f};
glm::vec3 eye_{0.0f};
bool orbiting_ = false, panning_ = false, looking_ = false; // (looking: right drag turns the camera where it stands)
float nearest_ = 1.0f; // (how far the nearest thing is from the eye, m: worked out with the view)
bool xray_ = false, showGrid_ = true, renderGrid_ = false;
std::string appliedLook_;
keel::ModelId ground_{};
bool haveGround_ = false;
Shading shading_ = Shading::Solid;
// ── Tools ──
bool snap_ = false;
int snapKind_ = 0; // (moving: 0 steps, 1 points, 2 edges' middles, 3 faces' middles)
float snapMove_ = 0.05f, snapAngle_ = 15.0f, snapScale_ = 0.1f;
float drawThickness_ = 0.05f, extrudeAmount_ = 0.1f, insetAmount_ = 0.2f, mergeDistance_ = 0.001f;
float bevelWidth_ = 0.05f;
int bevelSteps_ = 3, cuts_ = 1;
Orient orientObject_ = Orient::Local, orientEdit_ = Orient::Normal;
Pivot rotatePivot_ = Pivot::Middle, scalePivot_ = Pivot::Opposite;
SelShape selShape_ = SelShape::Box;
float brushRadius_ = 30.0f;
std::vector<glm::vec3> drawPts_;
// Drawing on an object: the plane of the face the first point went on, and what's made with it
// (0 a new object standing on it, 1 added to it, 2 cut into it).
glm::vec3 drawOnP_{0.0f}, drawOnN_{0.0f, 0.0f, 1.0f};
uint32_t drawOnto_ = 0;
int drawOnMode_ = 0;
struct Drag {
bool active = false;
int handle = -1; // 0-2 an axis, 3 free / even / about the view, 4-6 an axis's other end
Tool tool = Tool::Select;
Axes axes{};
glm::vec3 pivot{0.0f}, anchor{0.0f}, handlePoint{0.0f};
ImVec2 startMouse{0, 0};
float startT = 0.0f, startDist = 0.0f, startMid = 0.0f; // (the handle's way from what stays put; from the middle)
glm::vec3 startHit{0.0f};
Scene before;
std::set<std::pair<int, int>> bevelEdges;
std::vector<std::pair<int, float>> soft; // points near the selection that follow it, and how much
std::string typed; // (a number typed while dragging: exactly that much)
} drag_;
// Soft selection (shape editing): points within `softReach_` of the selection follow it, less
// the further they are (Blender's proportional editing, Maya's soft select).
bool softSel_ = false;
float softReach_ = 0.3f;
// Push out / pull in (Alt+S): the points and the shape as it was when it started.
bool showPush_ = false;
float pushBy_ = 0.0f;
std::set<int> pushPts_;
Mesh pushFrom_;
uint32_t pushObject_ = 0;
bool boxing_ = false, painting_ = false, lassoing_ = false, tapDraw_ = false;
ImVec2 boxStart_{0, 0};
std::vector<ImVec2> lasso_;
std::pair<int, int> cutHover_{-1, -1};
// The knife: points clicked on the screen (or a straight drag).
std::vector<ImVec2> knifePts_;
bool knifeDown_ = false;
ImVec2 knifePress_{0, 0};
bool knifeThrough_ = false, knifeFill_ = true;
int knifeAfter_ = 1; // cut right through, then: 0 just the lines, 1 pieces of the one object, 2 objects of their own, 3 the smaller ones gone
// Holes: pressed on a face, dragged out to size.
// (sizes in metres where it stands: across = a round's width, a rectangle's width, a triangle's
// side, a hexagon's flats; tall: a rectangle's height)
float holeSize_ = 0.2f, holeTall_ = 0.1f, holeDepth_ = 0.1f, holeTurn_ = 0.0f, holeRoom_ = 0.0003f;
int holeShape_ = 0, holeSides_ = 32; // a HoleShape
int holeMode_ = 0;
// 0 all the way through, 1 a pocket, 2 the outline only (a new face)
struct HoleDrag {
bool active = false;
uint32_t object = 0;
int face = -1;
glm::vec3 centre{0.0f}; // (the object's own space)
float radius = 0.0f;
ImVec2 press{0, 0};
} hole_;
// ── Painting ──
PaintTool paintTool_ = PaintTool::Brush;
glm::vec4 paintColor_{0.85f, 0.25f, 0.1f, 1.0f}; // a: how strong
float brushPx_ = 16.0f, hardness_ = 0.5f, fillTolerance_ = 0.15f;
int pictureSize_ = 1024;
bool showUvLines_ = true;
struct PaintStroke {
bool active = false, in2D = false, haveLast = false, waiting = false; // waiting: pressed off the object, starts when the brush gets to it
uint32_t object = 0;
std::shared_ptr<Image> image; // (the object's picture: a copy made for this stroke)
Stroke stroke;
glm::vec3 last{0.0f};
glm::vec2 last2D{0.0f};
} paint_;
// Sculpting (the Paint tab's Shape side): brushes that push the surface about like clay.
bool sculpting_ = false;
SculptBrush sculptBrush_ = SculptBrush::Draw;
float sculptStrength_ = 0.5f, sculptPx_ = 60.0f; // (its own brush size: sculpting wants a bigger one than painting)
bool paintMirror_ = false, stencilOn_ = false, drawingStencil_ = false;
std::vector<ImVec2> stencil_; // (on the screen)
bool sculptMirror_ = false; // the same on the other side (left and right: the object's Y)
struct SculptStroke {
bool active = false, haveLast = false, waiting = false;
uint32_t object = 0;
std::unique_ptr<SculptMesh> mesh;
glm::vec3 last{0.0f};
// Grab: where it was taken hold of (the world), and what (the object's own space).
glm::vec3 start{0.0f};
std::vector<std::pair<int, float>> held[2];
std::vector<glm::vec3> from[2];
} sculpt_;
// A picture layer unlocked to be moved: which, and what's being dragged (a corner 0-3, 4 the
// whole of it, 5 the turning handle) from where.
struct LayerEdit {
uint32_t object = 0;
int index = -1, drag = -1;
bool fresh = false; // (just pasted: Esc takes it away again)
glm::vec2 grab{0.0f}, offset{0.0f};
std::array<glm::vec2, 4> startCorners{};
PictureLayer start;
} ledit_;
bool pasteOnSurface_ = true;
uint32_t renamingFolder_ = 0;
// Touch (set when it starts: fry_touch).
bool touchMode_ = false, portrait_ = false, showToolbox_ = false, panelsOpen_ = false, viewsOpen_ = false, shiftLatch_ = false, ctrlLatch_ = false, touchOrbit_ = false;
struct Gesture {
bool two = false, longDone = false, rightUp = false;
ImVec2 mid{}, downPos{};
float spread = 1;
double downAt = -1;
} gest_;
std::string captureUri_; // (a picture of the view going into a picked file)
struct CopiesSetting {
int count = 3, axis = 2;
bool round = false, joined = false, path = false, follow = true; // (path: along the last picked object)
glm::vec3 step{0.3f, 0.0f, 0.0f}, centre{0.0f};
float angle = 360.0f;
} copies_;
bool showCopies_ = false, showThicken_ = false, thicknessOut_ = false;
float thickness_ = 0.002f;
// The Layout tab: what's picked (frames, or corners as face and corner) and what's dragged.
struct LayoutState {
uint32_t object = 0;
bool corners = false;
std::set<int> frames;
std::set<std::pair<int, int>> points;
int drag = 0; // 1 moving / turning / sizing, 2 a box
glm::vec2 grab{0.0f}, centre{0.0f};
ImVec2 boxFrom{};
std::vector<std::vector<glm::vec2>> start;
std::shared_ptr<const Image> startPicture;
double remapAt = 0;
} lay_;
LayTool layTool_ = LayTool::Move;
bool layKeepPaint_ = true, layChecker_ = false;
// The Print tab.
PrintTool printTool_ = PrintTool::None;
std::vector<glm::vec3> measure_;
bool measureSnap_ = true, showOverhangs_ = true, sizing_ = false, showThin_ = true, showLayer_ = false;
int layer_ = 1;
float layerHeight_ = 0.0002f; // (m)
float minWall_ = 0.0008f; // (m: the thinnest wall that prints well, twice a 0.4 mm nozzle)
float overhangDeg_ = 45.0f, infill_ = 15.0f;
int material_ = 0;
std::map<uint32_t, PrintInfo> printInfos_;
keel::ModelId bed_{};
glm::vec3 bedFor_{0.0f};
// Closing, New or Open with changes not saved: asked first (askSave_), then done; afterSave_:
// what to do once the Save it chose has finished (0 nothing, 1 quit, 2 new, 3 open).
int askSave_ = 0, afterSave_ = 0; // (what to do then: 1 quit, 2 new, 3 open..., 4 open dropped_)
std::string dropped_;
bool dialogCancelled_ = false;
// Autosave: a copy packed small in the background every fry_autosave minutes while there are
// changes, kept until saved or closed properly; offered back after a crash.
std::string autosavePath_;
uint64_t edits_ = 0, autosavedEdits_ = 0;
double lastAutosave_ = 0;
std::future<bool> autosaveJob_;
std::vector<std::string> recover_;
bool showRecover_ = false;
std::map<uint32_t, std::vector<uint8_t>> owner_; // which layer shows at each pixel
struct Uploaded {
uint64_t stamp = 0;
double at = 0;
bool dirty = false;
};
std::map<uint32_t, Uploaded> uploaded_;
std::map<uint32_t, keel::TextureId> paintTex_;
float picZoom_ = 0.0f; // the Picture panel: screen pixels a picture pixel, and where its corner is
ImVec2 picPan_{0, 0};
uint32_t picFor_ = 0;
// ── Saving a picture of the view (cropped to it, without the gizmos) ──
int captureFrames_ = 0;
std::string capturePath_;
// ── GPU side ──
std::map<uint32_t, std::pair<keel::ModelId, uint64_t>> models_; // object id → its model, the state built
std::map<uint32_t, uint64_t> versions_;
uint64_t versionClock_ = 1;
struct Shown {
uint64_t version = 0; // (the shape key it was made for)
bool mirrorOnly = false;
Mesh mesh;
std::shared_ptr<const fry::TriangleTree> tree; // (made with it, when it was made on another thread)
std::future<std::pair<Mesh, std::shared_ptr<const fry::TriangleTree>>> coming; // (a big one being made on another thread)
uint64_t comingVersion = 0;
bool comingMirror = false;
};
std::map<uint32_t, Shown> shown_;
struct Picture {
bool ok = false;
float aspect = 1.0f;
};
std::map<std::string, Picture> pictures_;
keel::TextureId logo_{};
bool logoTried_ = false, haveLogo_ = false;
// ── UI ──
int appliedTheme_ = -1;
// The Script panel: the script being written, where it's from, what it printed.
bool showScript_ = false, showScriptHelp_ = false;
size_t script_ = 0; // the file's script shown in the Script panel
std::string scriptPath_; // where it was last saved or opened from (Save as starts there)
// Plug-ins (Script > Plug-ins): each file, whether it's on, and how loading it went.
struct PluginEntry {
std::string path, file, error;
bool bundled = false, on = true;
std::unique_ptr<fry::Plugin> p;
};
std::vector<PluginEntry> plugins_;
bool showPlugins_ = false;
std::pair<std::string, std::string> pluginTool_; // (the plug-in tool that's on: its file and name)
std::string pluginFilter_;
// ── Commands: found by typing, on keys of your own, round the mouse ──
std::vector<fry::Command> commands_;
fry::CommandSearch search_;
std::vector<std::string> recentCommands_;
std::map<std::string, fry::Chord> myKeys_; // (a command's id: the key you gave it)
int pie_ = 0;
// 1: the tools round the mouse (Space held), 2: the views (Shift+Space)
ImVec2 pieAt_{0, 0};
bool pieStays_ = false; // (opened from the menu or console: until a click)
std::string settingKey_;
bool showHistory_ = false;
// ── Workspaces: the panels as they were, kept under a name ──
bool showWorkspaces_ = false, layoutAgain_ = false;
std::string pendingLayout_;
char workspaceName_[64] = "My workspace";
// (the command waiting for its new key, in Keys and mouse)
// A plug-in's command waiting for its settings (the form), and a material being named.
struct PendingCommand {
size_t plugin = 0, command = 0;
std::vector<double> values;
};
std::optional<PendingCommand> pendingCommand_;
bool nameMaterial_ = false;
std::string materialName_;
bool materialKeepColor_ = false;
std::vector<std::pair<std::string, bool>> scriptLog_; // (line, an error)
bool scriptLogToBottom_ = false;
bool styled_ = false, layoutDone_ = false, showHelp_ = false, showAbout_ = false;
std::string iniPath_, message_;
double messageAt_ = -100.0;
char renameBuf_[128] = "";
uint32_t renaming_ = 0;
std::mutex dialogMutex_;
std::string dialogResult_;
int dialogKind_ = 0; // 1 open, 2 save, 3 export, 4 reference picture, 5 picture of the view, 6 a picture to paint on, 7 save the painted picture
int pendingKind_ = 0, dialogFilter_ = -1;
// ───────────────────────────── document ─────────────────────────────
Object* find(uint32_t id);
Reference* findRef(uint32_t id);
Object* editing() { return mode_ == Mode::Edit ? find(active_) : nullptr; }
void touched(uint32_t id) { versions_[id] = ++versionClock_, dirty_ = true, ++edits_; }
// What decides the shape an object shows, as a number: its points and faces, its finishing
// touches, creases, cuts, shading and painting's layout (not where it is). Worked out again
// only when it's been touched: moving a smoothed object doesn't smooth it again each frame.
struct ShapeKey {
uint64_t version = 0, key = 0;
};
std::map<uint32_t, ShapeKey> shapeKeys_;
uint64_t shapeKey(const Object& o);
void touchAll() {
for (const Object& o : scene_.objects) versions_[o.id] = ++versionClock_;
}
// Its shape has been changed by hand: the library settings no longer apply.
void handMade(Object& o) { o.recipe.clear(), o.settings.clear(); }
void say(std::string text);
void pushUndo();
// The undo point just made, dropped (what it was for didn't happen): redo as it was before.
void dropUndo();
// Back to the undo point just made, and it dropped.
void takeBack();
void restore(Snapshot& s);
void undo();
void redo();
void newScene();
Object& addObject(const std::string& base, Mesh mesh);
std::string uniqueName(const std::string& base);
// A shape from the library, standing on the ground under the middle of the view.
void addShape(const std::string& id, bool undoable = true);
void deleteSelected();
void duplicateSelected();
// The selected objects become one (the last picked keeps its place, look and name).
void joinSelected();
// The selected faces become an object of their own.
void separateSelected();
// ───────────────────────────── files ─────────────────────────────
// ── Files a phone's file picker gives (content://...): read and written through SDL ──
static bool isUri(const std::string& p) { return p.starts_with("content://"); }
// A file's name as shown (a picked file's: from the end of its address, decoded).
static std::string fileName(const std::string& p);
// A picked file copied to a file of our own to read ("" if it couldn't be).
static std::string fromUri(const std::string& uri, const std::string& name);
// A file of ours written into the picked one.
static bool toUri(const std::string& local, const std::string& uri);
static std::string tempFile(const std::string& name);
void openFile(const std::string& picked);
bool saveFile(std::string path);
static std::string sizeText(uintmax_t n) {
return n < 10240 ? std::format("{} bytes", n) : n < 10 << 20 ? std::format("{} KB", n >> 10) : std::format("{:.1f} MB", double(n) / 1048576.0);
}
static std::vector<uint8_t> pngBytes(const Image& im);
void exportFile(std::string path, int filter = -1, const std::string& asExt = "");
// ── Closing with changes, autosave ──
// New, Open, Quit: asks about saving first if there are changes.
void whenSaved(int action);
void doAfterAsking(int action);
// A file dropped on the window (or opened with Fry3DX from the desktop): a .fry opens (after
// asking about changes), a script goes in the Script panel, a picture goes on as a reference
// (or, in the Paint tab, as a sticker on the model).
void onFileDropped(const std::string& path) override;
void saveQuestion();
std::string autosaveDir() const { return keel::prefPath() + "autosave/"; }
// Every fry_autosave minutes (when there are changes and nothing's being dragged): a copy
// packed as small as it goes, in the background.
void autosave(bool force = false);
// Its autosave isn't needed (saved, or closed on purpose).
void dropAutosave();
// Autosaves left behind (it didn't close properly): offered back. Only the newest 15 are
// kept; older ones are deleted.
void findAutosaves();
void recoverWindow();
// A picture of the 3D view only (no panels, gizmos or outlines): the screen is saved a few
// frames on, with those hidden, then cut down to the view.
void savePicture(std::string path);
bool capturing() const { return captureFrames_ > 0; }
void captureStep();
static bool loadImageFile(const std::string& path, Image& out);
static bool writePng(const std::string& path, const Image& im) { return stbi_write_png(path.c_str(), im.w, im.h, 4, im.px.data(), im.w * 4) != 0; }
void addPicture(const std::string& path);
// SDL's own file dialogs (the desktop's): the answer comes back later, maybe on another thread.
void dialog(int kind);
void takeDialogResult();
// ───────────────────────────── modes and tools ─────────────────────────────
void setTool(Tool t);
void enterEdit();
void leaveEdit();
void clearElements() { selVerts_.clear(), selFaces_.clear(), selEdges_.clear(); }
void selectAllElements();
void selectAll();
void selectNone();
// The points the selection covers, whichever kind is picked.
std::set<int> selectedPoints();
// Selects (in the current kind) what these points cover.
void selectPoints(const std::set<int>& pts);
void growSelection() {
if (Object* o = editing()) selectPoints(growVerts(o->mesh, selectedPoints()));
}
void shrinkSelection();
// Like the picked: faces that face the same way, edges as long, points with as many edges.
void selectSimilar();
// The picked edges' whole loops (or the rings across them).
void loopsOfSelected(bool ring);
void selectLinked() {
if (Object* o = editing()) selectPoints(linkedVerts(o->mesh, selectedPoints()));
}
void invertSelection();
// The edges a rounding would work on: those selected, or round the selected faces, or between
// selected points.
std::set<std::pair<int, int>> edgesToRound();
void deleteElements();
// After a change that renumbers things: nothing selected, the shape is hand-made now.
void changedShape(Object& o, bool keepSelection = false);
void extrudeNow(float amount);
void insetNow(float amount);
void bevelNow();
void subdivideNow(bool smooth);
void cutAt(Object& o, std::pair<int, int> edge);
void makeFaceNow();
void mergeNow();
void smoothPointsNow();
void startPush();
void pushWindow();
void bridgeNow();
void flipNow();
// Rotation and scale baked into the points (so the object's turn is none and its size is 1).
void applyTransform(Object& o);
void applyFinish(Object& o);
void originToMiddle(Object& o);
void originToBottom(Object& o);
void mirror(Object& o, int axis);
// ───────────────────────────── tabs ─────────────────────────────
void setTab(Tab t);
Shading shading() const { return tab_ == Tab::Render ? Shading::Rendered : shading_; }
// ───────────────────────────── the knife and holes ─────────────────────────────
// Snapped to steps of 45 degrees from the last point while Ctrl is held.
ImVec2 knifeEnd(const ImGuiIO& io) const;
static Mesh subMesh(const Mesh& m, const std::set<int>& faces);
// A new object like `from` (its look, place and finish), with another shape.
uint32_t objectLike(uint32_t from, Mesh mesh, const std::string& name);
void knifeApply(uint32_t id, std::vector<ImVec2> pts);
static float objectScale(const Object& o) { return std::max(std::cbrt(std::abs(glm::determinant(glm::mat3(objectMatrix(o))))), 1e-6f); }
// How wide (across) a shape is when it reaches `reach` from its middle (dragging it out).
float holeAcrossFor(float reach) const {
return HoleShape(holeShape_) == HoleShape::Triangle || HoleShape(holeShape_) == HoleShape::Hexagon ? reach * std::sqrt(3.0f) : reach * 2.0f;
}
// The outline, `across` wide in the object's own size (a rectangle keeps its proportions).
std::vector<glm::vec3> holeShapeOutline(const Object& o, int face, const glm::vec3& centre, float across) const;
void applyHole(uint32_t id, int face, const glm::vec3& centre, float across);
// The hole tool's outline under the mouse (or being dragged out), in the world.
std::vector<glm::vec3> holePreview(const ImGuiIO& io);
// Where the mouse is on a face's plane (the object's own space).
std::optional<glm::vec3> onFacePlane(const Object& o, int face, ImVec2 mouse);
// ───────────────────────────── painting ─────────────────────────────
// The object ready to be painted: its rounding and smoothing made part of it, its surface laid
// out on a picture (made the plain colour of it at first).
Object* readyToPaint(uint32_t id);
// The object's picture, copied so this change can be undone; the copy is now the object's.
Image& changePicture(Object& o);
void beginStroke(Object& o, bool in2D);
void endStroke();
// Where on its picture a ray hits an object (0..1), or nothing.
std::optional<glm::vec2> uvUnder(const Object& o, const Ray& ray);
// One dab of the brush on the model: on every face near it, into the picture where that face
// lies (so it carries on across the seams between pieces of the layout).
// One dab of paint at a point of the object (the world), on the faces towards `eye` (the
// mirrored dab: towards the eye mirrored). The stencil: only where the surface shows inside
// it on the screen (the mirrored dab: where its mirror image does, `back` taking it there).
void dab3D(Object& o, const glm::vec3& at, float radius, const glm::vec3* eyeAt = nullptr, const glm::mat4* back = nullptr);
// The brush at a point of the view: starts a stroke on what's there, or carries one on.
void paintAt(ImVec2 mouse, bool start);
void pickColor(const Object& o, glm::vec2 uv);
void fillAt(Object& o, glm::vec2 uv);
// ── Sculpting ──
// The object ready to sculpt: its finishing touches made part of it, and made finer (the same
// shape) if it has too few points to push about.
Object* readyToSculpt(uint32_t id);
void endSculpt();
// The brush at a point of the view: starts a stroke on what's there, or carries one on.
void sculptAt(ImVec2 mouse, bool start, bool ctrl, bool shift);
void sculptViewport(const ImGuiIO& io);
// ── Picture layers ──
PictureLayer* editLayer();
// A picture put on the selected object as a new layer, unlocked to be moved: a sticker on the
// surface in the middle of the view, or pinned onto the flat picture.
void startFloating(Image img);
void floatFromFile(const std::string& path);
void pasteFromClipboard();
// Enter: it stays where it is, a layer (click it in the Picture panel to move it again).
void lockLayer();
void unlockLayer(uint32_t object, int index);
// Esc: a picture just pasted goes again; one unlocked is locked again.
void cancelFloating();
void deleteLayer(Object& o, int i);
// The layer painted into the painting for good (it can't be moved after).
void mergeLayer(Object& o, int i);
// The handles of a sticker being moved, in the world: its corners (top-left, top-right,
// bottom-right, bottom-left), its turning handle, its middle — on its face's plane.
bool stickerHandles(const Object& o, const PictureLayer& l, std::array<glm::vec3, 6>& out);
int stickerHandle(const Object& o, const PictureLayer& l, ImVec2 mouse);
// Moving a sticker on the model: it slides over the surface (onto other faces too), its
// corners size it, its handle turns it.
void stickerMouse(const ImGuiIO& io);
// A cheap fingerprint of what the object's picture shows (its painting, its layers, its shape).
uint64_t pictureStamp(const Object& o);
// The object's picture on the graphics card (its painting with its layers on top): sent again
// when it changes — while painting or dragging, at most 20 times a second.
void uploadPicture(const Object& o, bool now_ = false);
// ───────────────────────────── the Layout tab ─────────────────────────────
// The frames an object's faces are laid out in on its picture, moved, turned and sized by
// hand (whole frames, or their corners); what's painted goes with them unless you say not.
// What's picked, as (face, corner) pairs of its layout.
std::vector<std::pair<int, int>> layoutPicked(const Object& o, const std::vector<std::vector<int>>& islands) const;
// A corner and every other on the same point of the model at the same place on the picture.
std::set<std::pair<int, int>> layoutCorner(const Object& o, int f, int c) const;
void layoutSelectAll();
// The picked corners moved by `to` (picture pixels), painting carried along if wanted.
void layoutChange(Object& o, const std::vector<std::vector<glm::vec2>>& from, const std::shared_ptr<const Image>& picture,
const std::vector<std::pair<int, int>>& picked, const std::function<glm::vec2(glm::vec2)>& to, bool final);
// Buttons' changes (turn, flip, straighten): about the middle of what's picked.
void layoutApply(const std::function<glm::vec2(glm::vec2, glm::vec2)>& to);
void layoutStraighten();
// Laid out again by itself, what's painted carried over onto the new layout.
void layoutAgain(Object& o);
template <class F>
void layoutCanvas(Object& o, ImDrawList* dl, F toScreen, glm::vec2 mouse, bool hovered, int W, int H) {
const ImGuiIO& io = ImGui::GetIO();
if (lay_.object != o.id) lay_ = {}, lay_.object = o.id;
const glm::vec2 size{float(W), float(H)};
const auto islands = uvIslands(o.mesh, o.uvs);
std::vector<int> islandOf(o.mesh.faces.size(), -1);
for (size_t i = 0; i < islands.size(); ++i)
for (int f : islands[i]) islandOf[size_t(f)] = int(i);
auto screen = [&](int f, int c) { return toScreen(o.uvs[size_t(f)][size_t(c)] * size); };
auto faceUnder = [&]() {
for (size_t f = 0; f < o.mesh.faces.size(); ++f) {
std::vector<ImVec2> poly;
for (size_t c = 0; c < o.uvs[f].size(); ++c) poly.push_back(screen(int(f), int(c)));
if (insidePolygon(io.MousePos, poly)) return int(f);
}
return -1;
};
auto cornerUnder = [&]() {
std::pair<int, int> best{-1, -1};
float d = 9.0f;
for (size_t f = 0; f < o.uvs.size(); ++f)
for (size_t c = 0; c < o.uvs[f].size(); ++c) {
const ImVec2 q = screen(int(f), int(c));
if (const float e = std::hypot(q.x - io.MousePos.x, q.y - io.MousePos.y); e < d) d = e, best = {int(f), int(c)};
}
return best;
};
const auto picked = layoutPicked(o, islands);
std::set<int> pickedFaces;
for (auto [f, c] : picked) pickedFaces.insert(f);
// Pressing: pick (what's under it, or a box), then move / turn / size what's picked.
if (hovered && ImGui::IsMouseClicked(ImGuiMouseButton_Left) && !lay_.drag) {
bool hit = false, wasPicked = false;
if (lay_.corners) {
const auto [f, c] = cornerUnder();
if (f >= 0) {
const auto same = layoutCorner(o, f, c);
hit = true, wasPicked = lay_.points.count({f, c}) > 0;
if (io.KeyShift && wasPicked)
for (auto p : same) lay_.points.erase(p);
else {
if (!io.KeyShift && !wasPicked) lay_.points.clear();
lay_.points.insert(same.begin(), same.end());
}
}
} else if (const int f = faceUnder(); f >= 0) {
const int i = islandOf[size_t(f)];
hit = true, wasPicked = lay_.frames.count(i) > 0;
if (io.KeyShift && wasPicked) lay_.frames.erase(i);
else {
if (!io.KeyShift && !wasPicked) lay_.frames.clear();
lay_.frames.insert(i);
}
}
const bool anything = !lay_.frames.empty() || !lay_.points.empty();
const bool transform = layTool_ != LayTool::Select && anything && !(io.KeyShift && hit) && (hit || layTool_ != LayTool::Move);
if (transform) {
pushUndo();
lay_.drag = 1, lay_.grab = mouse, lay_.start = o.uvs, lay_.startPicture = o.picture;
glm::vec2 lo(1e30f), hi(-1e30f);
for (auto [f, c] : layoutPicked(o, islands)) lo = glm::min(lo, o.uvs[size_t(f)][size_t(c)] * size), hi = glm::max(hi, o.uvs[size_t(f)][size_t(c)] * size);
lay_.centre = (lo + hi) * 0.5f;
} else if (!hit) {
if (!io.KeyShift) lay_.frames.clear(), lay_.points.clear();
lay_.drag = 2, lay_.boxFrom = io.MousePos;
}
}
if (lay_.drag == 1) {
const glm::vec2 g = lay_.grab - lay_.centre, m = mouse - lay_.centre;
std::function<glm::vec2(glm::vec2)> to;
if (layTool_ == LayTool::Move || layTool_ == LayTool::Select) {
const glm::vec2 d = mouse - lay_.grab;
to = [d](glm::vec2 p) { return p + d; };
message_ = std::format("Moved {:.0f}, {:.0f} px", d.x, d.y);
} else if (layTool_ == LayTool::Rotate) {
float a = std::atan2(m.y, m.x) - std::atan2(g.y, g.x);
if (io.KeyCtrl) a = glm::radians(snapTo(glm::degrees(a), 15.0f));
const glm::vec2 c = lay_.centre;
to = [a, c](glm::vec2 p) { return c + glm::vec2(std::cos(a) * (p - c).x - std::sin(a) * (p - c).y, std::sin(a) * (p - c).x + std::cos(a) * (p - c).y); };
message_ = std::format("Turned {:.0f} degrees", glm::degrees(a));
} else {
glm::vec2 k(glm::length(m) / std::max(glm::length(g), 1.0f));
if (io.KeyShift) // (only across or only up: whichever the drag goes along more)
k = std::abs(g.x) > std::abs(g.y) ? glm::vec2(m.x / (std::abs(g.x) > 1 ? g.x : 1.0f), 1.0f) : glm::vec2(1.0f, m.y / (std::abs(g.y) > 1 ? g.y : 1.0f));
const glm::vec2 c = lay_.centre;
to = [k, c](glm::vec2 p) { return c + (p - c) * k; };
message_ = std::format("Size {:.0f}% x {:.0f}%", k.x * 100, k.y * 100);
}
messageAt_ = now();
const bool done = !ImGui::IsMouseDown(ImGuiMouseButton_Left);
layoutChange(o, lay_.start, lay_.startPicture, layoutPicked(o, islands), to, done);
if (done) lay_.drag = 0, lay_.startPicture.reset();
}
// Drawing: every face's outline, what's picked filled; corners as dots.
const ImU32 fill = (kAccent & 0x00FFFFFF) | 0x38000000;
for (size_t f = 0; f < o.mesh.faces.size(); ++f) {
std::vector<ImVec2> pts;
for (size_t c = 0; c < o.uvs[f].size(); ++c) pts.push_back(screen(int(f), int(c)));
const bool on = pickedFaces.count(int(f)) && !lay_.corners;
if (on)
for (const auto& t : triangulate(o.mesh, int(f))) {
ImVec2 q[3];
for (int k = 0; k < 3; ++k) q[k] = pts[size_t(std::find(o.mesh.faces[f].begin(), o.mesh.faces[f].end(), t[size_t(k)]) - o.mesh.faces[f].begin())];
dl->AddTriangleFilled(q[0], q[1], q[2], fill);
}
dl->AddPolyline(pts.data(), int(pts.size()), on ? kAccent : IM_COL32(255, 255, 255, 150), ImDrawFlags_Closed, on ? 2.0f : 1.2f);
}
if (lay_.corners) {
const auto hot = cornerUnder();
for (size_t f = 0; f < o.uvs.size(); ++f)
for (size_t c = 0; c < o.uvs[f].size(); ++c) {
const ImVec2 q = screen(int(f), int(c));
const bool on = lay_.points.count({int(f), int(c)}) > 0;
dl->AddCircleFilled(q, on ? 4.5f : 3.0f, on ? kAccent : hot == std::pair{int(f), int(c)} ? kHot : IM_COL32(255, 255, 255, 200));
}
} else if (hovered && !lay_.drag)
if (const int f = faceUnder(); f >= 0 && !lay_.frames.count(islandOf[size_t(f)]))
for (int g : islands[size_t(islandOf[size_t(f)])]) {
std::vector<ImVec2> pts;
for (size_t c = 0; c < o.uvs[size_t(g)].size(); ++c) pts.push_back(screen(g, int(c)));
dl->AddPolyline(pts.data(), int(pts.size()), kHot, ImDrawFlags_Closed, 1.5f);
}
if (lay_.drag == 1 && layTool_ != LayTool::Move && layTool_ != LayTool::Select) { // (the middle it turns or sizes about)
const ImVec2 c = toScreen(lay_.centre);
dl->AddCircle(c, 6, kAccent, 16, 2.0f);
dl->AddLine(c, io.MousePos, (kAccent & 0x00FFFFFF) | 0x90000000, 1.0f);
}
if (lay_.drag == 2) { // a box to pick with
const ImVec2 a = lay_.boxFrom, b = io.MousePos;
dl->AddRectFilled(ImVec2(std::min(a.x, b.x), std::min(a.y, b.y)), ImVec2(std::max(a.x, b.x), std::max(a.y, b.y)), IM_COL32(255, 120, 40, 30));
dl->AddRect(ImVec2(std::min(a.x, b.x), std::min(a.y, b.y)), ImVec2(std::max(a.x, b.x), std::max(a.y, b.y)), kAccent);
if (!ImGui::IsMouseDown(ImGuiMouseButton_Left)) {
auto in = [&](ImVec2 q) { return q.x >= std::min(a.x, b.x) && q.x <= std::max(a.x, b.x) && q.y >= std::min(a.y, b.y) && q.y <= std::max(a.y, b.y); };
for (size_t f = 0; f < o.uvs.size(); ++f)
for (size_t c = 0; c < o.uvs[f].size(); ++c)
if (in(screen(int(f), int(c)))) {
if (lay_.corners) lay_.points.insert({int(f), int(c)});
else lay_.frames.insert(islandOf[f]);
}
lay_.drag = 0;
}
}
}
// In the 3D view: clicking the model picks the frame its face is in (Shift: add).
void layoutViewport(const ImGuiIO& io);
void layoutOverlay(ImDrawList* dl);
void layoutToolbox(float w);
void layoutOptions(float w);
void layoutProperties(float w);
// ───────────────────────────── the Print tab ─────────────────────────────
glm::vec3 bedSize() const;
const PrintInfo& printInfo(const Object& o);
std::vector<Object*> printTargets();
void drawPrintBed(keel::Renderer& r, const keel::ModelLighting& light);
void putOnBed();
void middleOfBed();
// Everything picked made `mm` big along `axis`, keeping its shape, standing where it stood.
void printResize(int axis, float mm);
// Everything picked made `k` times as big, standing where it stood.
void printScale(float k);
// The scaler: by a share, to fit the plate, or from the wrong units (a model made in inches,
// centimetres or metres comes in 25.4, 10 or 1000 times off).
float scalePercent_ = 100.0f;
void printScaler(float w);
void printSizeWindow();
void printToolbox(float w);
void printOptions(float w);
void printViewport(const ImGuiIO& io);
// Where the mouse is on the model (a corner if near one), or on the bed.
std::optional<glm::vec3> measurePoint(ImVec2 mouse);
// The slice preview: where the printer goes round at the chosen layer, over the model.
void layerOverlay(ImDrawList* dl);
void printOverlay(ImDrawList* dl, const ImGuiIO& io);
void printProperties(float w);
// ───────────────────────────── layers: folders and going to things ─────────────────────────────
Folder* findFolder(uint32_t id);
bool inFolder(uint32_t folder, uint32_t within);
std::set<uint32_t> objectsIn(uint32_t folder);
// The camera brought round to these (as framing them, but keeping the way it looks).
void goTo(const std::set<uint32_t>& ids);
// The picked objects into a new folder (Ctrl+G): a group, picked and moved together.
void groupSelected();
// Ungrouped: what's inside goes up a level, the folder goes.
void ungroup(uint32_t id);
void deleteFolder(uint32_t id);
// A folder's eye or lock: all in it the same.
void showFolder(Folder& f, bool on);
void lockFolder(Folder& f, bool on);
void moveToFolder(const std::set<uint32_t>& ids, uint32_t folder);
// Only these shown (again: everything shown).
void showOnly(const std::set<uint32_t>& ids);
void folderMenu(uint32_t into, const std::set<uint32_t>& ids, int depth = 0);
// What a right-click on an object (or the picked ones) offers.
void objectMenu(Object& o);
// A row's show / hide or lock button: the picture of how it is now, dim when it's the usual way.
bool rowToggle(const char* id, Icon icon, bool usual, const char* tip);
// The ⌖ button at the end of a row: brings the camera to it.
bool goButton(const char* tip);
// Rows for what's in a folder (0: the top): its folders, then its objects.
void layerRows(uint32_t parent, int depth);
// ───────────────────────────── combining, copies, thickness ─────────────────────────────
// The last picked object with the others added, taken out of it, or only where they overlap
// kept; the others go.
void combineSelected(Combine op);
void makeCopies();
void copiesWindow();
void thickenActive();
// A model made elsewhere: each of its objects, standing on the ground in the middle of the view.
void importFile(const std::string& file);
// ── Spin: an outline turned round an axis (a vase, a wheel, a ring), or a screw ──
bool showSpin_ = false, spinWorld_ = false, spinKeep_ = false;
int spinAxis_ = 2, spinSteps_ = 48;
float spinDegrees_ = 360.0f, spinRise_ = 0.0f;
void spinWindow();
void spinSelected();
// ── Text as a shape ──
bool showText_ = false;
char textBuf_[512] = "Fry3DX";
int textFont_ = 2, textAlign_ = 0;
float textHeight_ = 0.05f, textDepth_ = 0.01f, textSpacing_ = 0.0f;
bool textStanding_ = false;
std::string textFontFile_; // (a font of your own, picked from a file)
static constexpr const char* kFonts[] = {"Instrument Sans", "Instrument Sans (semi-bold)", "Instrument Sans (bold)", "JetBrains Mono"};
static constexpr const char* kFontFiles[] = {"fonts/InstrumentSans-Regular.ttf", "fonts/InstrumentSans-SemiBold.ttf", "fonts/InstrumentSans-Bold.ttf", "fonts/JetBrainsMono-Regular.ttf"};
void textWindow();
void addText();
void thickenWindow();
void cleanFlatFaces();
// ───────────────────────────── touch: phones and tablets ─────────────────────────────
// A phone: everything drawn bigger, the side panels only when asked for, a bar of big buttons
// at the bottom (undo, Shift and Ctrl that stay down, editing the shape...), and fingers:
// one drags the view round (or a tool's arrows), two move it and pinch to zoom, holding one
// still is a right-click.
bool touch() const { return touchMode_; }
// How much bigger than its pixels the UI is drawn.
float touchScale() const;
void touchFrame(ImGuiIO& io);
// The bar along the bottom of the view: big buttons, in rows if the view's narrow.
void touchBar();
// ───────────────────────────── the camera ─────────────────────────────
glm::vec3 viewDir() const { return forwardOf(yaw_, pitch_); }
float viewHeight() const { return 2.0f * dist_ * std::tan(glm::radians(fov_) * 0.5f); } // metres across the view's height at the target
void setView(View v);
void leaveFlatView();
void frameBox(glm::vec3 lo, glm::vec3 hi);
void frameAll();
void frameSelected();
bool mouseInView(const ImGuiIO& io) const;
void orbitBy(ImVec2 d);
void panBy(ImVec2 d);
void updateCamera(ImGuiIO& io);
// Where the eye is and how the view maps to the screen, from the camera as it is now: again
// just before drawing, so the model and the lines over it agree (a touch can turn it between).
void settleView();
// How near and far the view draws (units), going by how far away it looks: close up to a
// 5 mm part, or out to see a whole town, the same share of the depth's precision.
glm::vec2 nearFar();
// World point → screen (false behind the eye).
// The window and its view are up (commands given at the start run before the first frame).
bool viewReady() const { return ImGui::GetCurrentContext() && viewMax_.x - viewMin_.x > 1 && viewMax_.y - viewMin_.y > 1; }
bool project(const glm::vec3& p, ImVec2& out) const;
Ray mouseRay(ImVec2 m) const;
// How many metres a pixel is, at a point.
float pixelSize(const glm::vec3& at) const;
// ───────────────────────────── what's shown ─────────────────────────────
// The mesh as seen: with its rounding, smoothing and mirror — but while its shape is being
// edited, only the mirror (the rest would hide the points you're moving).
// Editable cuts show (but not while its own shape's being edited: the points you move).
// A big one (smoothed into many faces, cut) is made on another thread: what was shown stays
// till it's ready, so the window doesn't stop.
const Mesh& shownMesh(const Object& o);
// The key of the mesh actually shown (the one before, while a new one's being made).
uint64_t meshKey(const Object& o, const Mesh& mesh);
// Each object something's cut out of, and what its cutters are (their shapes, where they are):
// a change, and it's made again (the caches follow its version).
std::map<uint32_t, uint64_t> cutKeys_;
std::map<uint32_t, glm::mat4> followAt_; // (where each cut object and cutter was last frame)
void followCuts();
bool isCutter(const Object& o) const { return fry::cutTarget(scene_, o) != nullptr; }
// Editable cut: the last picked has the others cut out of it, and they stay objects to move.
void cutEditable();
// The cut made for good: one cutter (or all of what's cut out of it) into the shape, gone.
void applyCuts(uint32_t target, uint32_t only = 0);
// ───────────────────────────── picking ─────────────────────────────
struct Hit {
uint32_t object = 0;
int face = -1;
float t = 1e30f;
};
// base: against its own mesh (face numbers of that), not the rounded or smoothed one shown.
Hit pickObject(const Ray& ray, uint32_t only = 0, bool base = false);
// Each object's triangles in the world, in a tree of boxes: made again only when it changes
// (its shape, where it is), not each time something's picked.
struct Tree { // (in the object's own space: moving it doesn't make it again)
uint64_t version = 0;
size_t faces = 0;
std::shared_ptr<const fry::TriangleTree> tree;
};
std::map<std::pair<uint32_t, bool>, Tree> trees_; // (an object's own mesh, or the one shown)
const fry::TriangleTree& treeOf(const Object& o, const Mesh& mesh);
// Can the eye see this point of the object (nothing of it in the way)?
bool visible(const Object& o, const glm::vec3& world);
// Whether the eye can see an object's point (nothing of it in between): each tried when it's
// first asked about, kept till the object or the view changes. (Only what's drawn is asked:
// the outline's points, not every point of a big mesh, as the view turns.)
struct Visibility {
uint64_t version = 0;
glm::vec3 eye{1e30f};
glm::mat4 vp{0.0f}, matrix{0.0f};
glm::vec3 eyeIn{0.0f}; // (the eye in the object's own space)
std::vector<char> point; // 0 not tried yet, 1 seen, 2 hidden
};
std::map<std::pair<uint32_t, bool>, Visibility> visibility_; // (an object's own mesh, or the one shown)
bool seen(const Object& o, const Mesh& mesh, int i);
// Each edge of a mesh and the (first two) faces it's on, with the faces' normals: worked out
// again only when the mesh changes.
struct Adjacency {
uint64_t version = 0;
size_t verts = 0, faces = 0;
std::vector<std::array<int, 4>> edges; // a, b, a face, the other (or -1)
std::vector<glm::vec4> plane;
// each face's normal, and its distance along it
};
std::map<std::pair<uint32_t, bool>, Adjacency> adjacency_;
const Adjacency& adjacencyOf(const Object& o, const Mesh& mesh);
bool pointSeen(const Object& o, int v) { return xray_ || seen(o, o.mesh, v); }
// The edge of the edited object nearest the mouse on screen (that can be seen), or (-1, -1).
std::pair<int, int> nearestEdge(Object& o, ImVec2 mouse, float within);
void clickSelect(const ImGuiIO& io);
// A whole loop: of edges (points), or a ring of faces, through the edge under the mouse.
void loopSelect(const ImGuiIO& io, bool ring = false);
// Selects what's on screen inside a shape (a box, a lasso, the brush).
void regionSelect(const std::function<bool(ImVec2)>& inside, bool add, bool remove, bool clearFirst);
// ───────────────────────────── the gizmo ─────────────────────────────
bool hasSelection();
// Every point of the selection, in the world.
std::vector<glm::vec3> selectionPoints();
glm::vec3 pivotOfSelection();
// The selection's box, in a gizmo's axes.
std::pair<glm::vec3, glm::vec3> selectionBox(const Axes& a);
glm::vec3 selectionMiddle(const Axes& a);
Orient& orient() { return mode_ == Mode::Edit ? orientEdit_ : orientObject_; }
// The gizmo's axes: the object's own (turning with it), the world's, or (shape editing) the
// way the selected faces face — so "up" on a side face is out of that face.
Axes gizmoAxes();
// The extrude / inset handle: the selected faces' middle, their normal.
bool faceHandle(glm::vec3& at, glm::vec3& normal);
// The round-edges handle: off to the right of the selection's middle.
bool bevelHandle(ImVec2& centre, ImVec2& handle);
// The scale box's handles: 0-2 the far side along each axis, 4-6 the near side, 3 the middle.
// (Pushed out a little where the box is flat, so they don't sit on top of each other.)
glm::vec3 scaleHandle(const Axes& a, glm::vec3 lo, glm::vec3 hi, int h);
// Which handle is under the mouse (-1 none).
int hoverHandle(ImVec2 mouse);
glm::vec3 originPoint();
glm::vec3 rotatePivot(const Axes& a) { return rotatePivot_ == Pivot::Origin ? originPoint() : selectionMiddle(a); }
void startDrag(const ImGuiIO& io, int handle);
// The points within reach of the selection (in the world: the object's size counts), each with
// how much it follows: a grid of the selected points, so a big mesh stays quick.
void findSoft();
void cancelDrag();
void updateDrag(const ImGuiIO& io);
// Mirror editing: each point that moved, its twin across the shape's own X (the point that was
// where it is, mirrored) moved the mirrored way. Points on the middle stay on it.
void mirrorEdits(Object& o, const Mesh& before);
// What moving snaps to near the mouse (points, edges' or faces' middles), in the world: not
// what's being moved. Marked with a ring.
std::optional<glm::vec3> snapTarget(ImVec2 mouse, float within = 22.0f);
// The number typed while dragging, if any (just "-" or "." is none yet).
std::optional<float> typed() const;
void dragNow(const ImGuiIO& io);
// ───────────────────────────── drawing a shape ─────────────────────────────
// The plane shapes are drawn on: the one the view looks straight at, or the ground.
void workPlane(glm::vec3& point, glm::vec3& normal) const;
// The plane drawn on: the face under the first point if it was on an object, else the view's.
void drawPlane(glm::vec3& p, glm::vec3& n);
std::optional<glm::vec3> drawPoint(const ImGuiIO& io);
std::string sketchTyped_; // (drawing a shape: the next line's length, typed)
// Drawing a shape: numbers typed go to the next line's length, Enter puts the point there.
bool sketchKeys(const ImGuiIO& io);
void finishShape();
// ───────────────────────────── the viewport's mouse ─────────────────────────────
void viewport(ImGuiIO& io);
void addDrawPoint(const ImGuiIO& io);
// Painting: on the model under the mouse.
void paintViewport(ImGuiIO& io);
// The brush: whatever passes under it is selected (or, with Ctrl, let go).
void paint(const ImGuiIO& io);
// ───────────────────────────── keys ─────────────────────────────
void shortcuts(ImGuiIO& io);
// ───────────────────────────── 3D ─────────────────────────────
#if defined(__ANDROID__)
static constexpr int kRayLight = 0; // (light bounced by ray tracing: not on phones)
#else
static constexpr int kRayLight = 1;
#endif
// Solid: a plain grey room and soft studio light, no shadows or effects — for seeing shapes.
// Rendered: sky, sun, shadows and effects.
void applyShading();
// Painted, and shown as painted (with rounding or smoothing added since, it isn't).
bool painted(const Object& o) const { return o.picture && o.uvsFit() && !o.hasFinish() && !cutKeys_.count(o.id); }
keel::ModelId modelOf(const Object& o);
const Picture& picture(const Reference& ref);
void loadLogo();
void logoImage(float size);
// A picture of ours in the UI, read the way ImGui's colours are (not turned linear: too dark).
void uiImage(ImDrawList* dl, keel::TextureId t, ImVec2 a, ImVec2 b);
float gridStep() const { return std::pow(10.0f, std::floor(std::log10(std::max(viewHeight() / 4.0f, 1e-4f)))); }
void draw3D(keel::Renderer& r);
// (the Print tab's: the printer's plate and overhangs)
// On top of the scene: outlines and wires, points, the gizmo, the selection shapes.
// An empty scene: how to start, in the middle of the view (gone once there's anything).
void emptyHints(ImDrawList* dl);
void overlays();
void gizmo(ImDrawList* dl, const ImGuiIO& io);
// ───────────────────────────── panels ─────────────────────────────
void setupUi();
// The least a panel can be and still read right (its words, its rows), by the font's size.
static ImVec2 panelMin(std::string_view name);
// 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.
ImVec2 keepMinSizes(ImGuiDockNode* n);
void defaultLayout(ImGuiID dock);
// ───────────────────────────── commands ─────────────────────────────
// Everything that can be done, by name: for the command search, keys of your own, the pies.
void buildCommands();
void openSearch();
void runCommand(const std::string& id); void commandItem(const char* id);
void commandSearch();
// The pies: the tools (Space), or the views (Shift+Space), round the mouse while it's held.
void pieFrame(ImGuiIO& io);
// Keys of your own: kept in keys.txt (a line each: the command's id, a tab, the key).
void loadMyKeys();
void saveMyKeys();
void menus();
void menuBar();
void addMenuItems();
// How the last item's key looks: filled when it's the one in use, sunk while held.
static keel::ui::KeyState keyState(bool on);
// A square button with a picture on it (the accent when it's the one in use).
bool iconButton(const char* id, Icon icon, bool on, const char* tip, float size = 38.0f);
// A wide one, with words beside the picture.
bool wideButton(const char* id, Icon icon, const char* label, bool on, float width, const char* tip = nullptr, float h = 30.0f);
// Buttons in rows, as many as fit.
template <class F>
void grid(int count, float size, F each) {
const float gap = 5.0f;
const int perRow = std::max(1, int((ImGui::GetContentRegionAvail().x + gap) / (size + gap)));
for (int i = 0; i < count; ++i) {
if (i % perRow) ImGui::SameLine(0, gap);
each(i);
}
}
void toolbox();
// The plug-in tool that's on: which plug-in and which of its tools (none: -1).
std::pair<int, int> pluginToolAt() const;
bool pluginToolFound() const { return pluginToolAt().first >= 0; }
// A plug-in tool's click: the spot on what's under the mouse, or on the ground.
void clickPluginTool(ImVec2 mouse);
void paintToolbox(float w);
void sculptOptions(float w);
void paintOptions(float w);
void softChoice(float w);
void toolOptions();
void layersPanel();
// A value that's undoable: the undo point is taken when you start dragging or typing.
template <class F>
bool undoable(F widget) {
const bool changed = widget();
if (ImGui::IsItemActivated()) pushUndo();
return changed;
}
void paintProperties(float w);
void renderProperties(float w);
// The Paint tab's picture: the selected object's, flat, to paint on and place pictures on.
void picturePanel();
void propertiesPanel();
// 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.
void materialPicker(Object& o);
void editProperties(Object& o, float w);
void statusBar();
// 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).
void viewButtons();
// ───────────────────────────── scripts ─────────────────────────────
void scriptLine(std::string text, bool error = false);
fry::SceneScript* currentScript() { return script_ < scene_.scripts.size() ? &scene_.scripts[script_] : nullptr; }
// "little_town.lua" -> "little town" (a script's name in the list).
static std::string scriptName(const std::string& path);
// Adds a script to the file's list and shows it (the same one again: just shows it).
void addScript(std::string name, std::string code);
// Runs the Script panel's script: one undo step; if it stops with an error, everything it did
// is taken back.
void runScriptNow();
// After a script or plug-in command: kept as one undo step, or all taken back on an error.
void finishRun(const fry::ScriptResult& r, const std::string& name, bool frame);
void openScript(const std::string& path, const std::string& shownName);
void saveScript(std::string file);
// The scripts that come with it (content/Fry3DX/scripts), as menu items that add one.
void exampleScripts();
void exampleItems(bool selectable);
// ── fry_bench: frames timed while the camera turns or a setting's dragged (finding what's slow) ──
struct Bench {
std::string what;
int left = 0;
std::vector<double> ms;
} bench_;
std::vector<std::pair<ImGuiKey, int>> holding_; // (fry_hold: keys held down for that many more frames)
float aoReach() const;
void lookBy(ImVec2 d);
void refocus();
float nearestThing();
float viewScale() const { return std::max(std::min(dist_, nearest_), 0.001f); } // (how big the view is where it matters: what's ahead, or nearer)
void benchStep();
void benchEnd(std::chrono::steady_clock::time_point began);
// ── Own materials (materials.txt in the settings folder) ──
static std::string ownMaterialsPath() { return keel::prefPath() + "materials.txt"; }
void loadOwnMaterials();
void saveOwnMaterials();
// ── Plug-ins: content/Fry3DX/plugins (they come with it) and the settings folder's plugins ──
static std::string pluginsFolder() { return keel::prefPath() + "plugins/"; }
std::set<std::string> pluginsOff() const;
void setPluginOn(const std::string& file, bool on);
void loadPlugins();
void copyPlugin(const PluginEntry& e);
void openPluginsFolder();
bool pluginUsable(size_t i) const { return i < plugins_.size() && plugins_[i].p && plugins_[i].error.empty(); }
void pluginMenuItems(const char* menu);
void pluginMenuItem(size_t i, size_t c);
void runPluginCommand(size_t i, size_t c, const std::vector<double>& values);
// A plug-in command's settings, asked for before it runs.
void commandForm();
void pluginsWindow();
static int growString(ImGuiInputTextCallbackData* d);
// A one-line field for a std::string (it grows as it's typed into).
static bool inputString(const char* label, std::string& text, const char* hint = nullptr) {
return ImGui::InputTextWithHint(label, hint ? hint : "", text.data(), text.capacity() + 1, ImGuiInputTextFlags_CallbackResize, growString, &text);
}
void scriptPanel();
void helpWindow();
// Keys of your own: any command on any key (they come before the usual ones).
void myKeysTable();
// ── (being made) ──
bool showPrintSize_ = false, liveMirror_ = false, keepProportions_ = false;
// Each picked object (or all, in the Print tab with none picked) made ready to print.
void repairSelected();
// Crease (Shift+E): the picked edges (or those between picked points / round picked faces)
// kept sharp when the shape's smoothed; again: not.
void creaseSelected();
// Slide (Alt+G): the picked points glide along their edges, each along the edge that goes
// most the way the mouse goes, never past its other end. Click: done. Esc / right click: as it was.
struct Slide {
bool active = false;
uint32_t object = 0;
Mesh from;
std::vector<int> pts;
std::vector<std::vector<int>> rails; // (each point's neighbours that aren't picked: where it can go)
ImVec2 start{0, 0};
} slide_;
void startSlide();
void cancelSlide();
void slideFrame(const ImGuiIO& io);
// Looking straight at a reference picture's plane (the front picture from the front or the back...).
bool lookingAt(Axis a) const;
std::string workspaceDir() const { return keel::prefPath() + "workspaces/"; }
void resetLayout();
void workspacesWindow();
static std::string fileSafe(std::string n);
// The steps that can be undone, oldest first: a click goes back (or on) to just after it.
void historyWindow();
void aboutWindow();
};
} // namespace fryapp
Reference in a new issue View git blame Copy permalink