ilusha/Modules
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix focus lockin & sketch3d new gui

Browse source
This commit is contained in:
IlyaShurupov 2024-10-20 12:01:42 +03:00
parent aecc75828b
commit 2460c9ce8d
44 changed files with 1015 additions and 322 deletions
Download patch file Download diff file Expand all files Collapse all files

11
Sketch3D/applications/Entry.cpp
View file

@ -2,19 +2,22 @@
#include "WidgetApplication.hpp"
#include "Sketch3D.hpp"
#include "Sketch3DWidget.hpp"
#include "SketchGUI.hpp"
using namespace tp;
class Sketch3DApplication : public WidgetApplication {
public:
Sketch3DApplication() :
mGui(*mGraphics->getCanvas(), { 1920, 1080 }) {
Sketch3DApplication() {
setRoot(&mGui);
mGui.createRenderWidget(mGraphics->getCanvas(), { 1920, 1080 });
mGui.setProject(&mSketch);
}
private:
Sketch3DGUI mGui;
SketchGUI mGui;
Project mSketch;
};
void runApp() {

22
Sketch3D/private/Sketch3D.cpp
View file

@ -283,6 +283,14 @@ PencilBrush::~PencilBrush() {
if (mStroke) delete mStroke;
}
void PencilBrush::finish(Project* proj) {
if (mStroke) {
ensureReady(mStroke, &proj->mCamera);
proj->mLayers[proj->mActiveLayer]->strokes.pushBack(mStroke);
mStroke = nullptr;
}
}
Layer::~Layer() {
for (auto str : strokes) {
delete str.data();
@ -316,6 +324,20 @@ void Project::sample(halnf pressure, halnf cameraRatio, Vec2F relativeCameraPos)
}
}
void Project::setPencil() {
if (auto idx = mBrushes.presents(mActiveBrush)) {
mBrushes.getSlotVal(idx)->finish(this);
}
mActiveBrush = "pencil";
}
void Project::setEraser() {
if (auto idx = mBrushes.presents(mActiveBrush)) {
mBrushes.getSlotVal(idx)->finish(this);
}
mActiveBrush = "eraser";
}
Project::~Project() {
for (auto brush : mBrushes) {
delete brush->val;

184
Sketch3D/private/SketchGUI.cpp Normal file
View file

@ -0,0 +1,184 @@
#include "SketchGUI.hpp"
#include "SimpleLayouts.hpp"
using namespace tp;
SketchRenderWidget::SketchRenderWidget(Canvas& canvas, Vec2F renderResolution) :
mRenderer(renderResolution) {
mImage = canvas.createImageFromTextId(mRenderer.getBuff()->texId(), mRenderer.getBuff()->getSize());
mCanvas = &canvas;
setSizePolicy(SizePolicy::Expanding, SizePolicy::Expanding);
setDebug("render", {});
}
SketchRenderWidget::~SketchRenderWidget() { mCanvas->deleteImageHandle(mImage); }
void SketchRenderWidget::draw(Canvas& canvas) {
auto area = getArea().relative();
if (mProject) {
mRenderer.renderToTexture(mProject, area.size);
canvas.drawImage(area, &mImage, 0, 1, 12);
}
}
void SketchRenderWidget::setProject(Project* project) { mProject = project; }
void SketchViewportWidget::setProject(Project* project) {
mProject = project;
mProject->mBackgroundColor = { 0.13f, 0.13f, 0.13f, 0.8f };
}
void SketchViewportWidget::setColor(const RGBA& color) {
((PencilBrush*) mProject->mBrushes.get("pencil"))->mCol = color;
}
void SketchViewportWidget::setRenderWidget(SketchRenderWidget* widget) { addChild(widget); }
void SketchViewportWidget::process(const EventHandler& events) {
if (!mProject) return;
auto area = getArea().relative();
Vec2F pointer = events.getPointer();
auto crs = events.getPointer();
if (!area.isInside(events.getPointer())) return;
crs.x /= area.z;
crs.y /= area.w;
crs = (crs - 0.5) * 2;
if (events.isPressed(InputID::MOUSE1)) {
mAction = true;
lockFocus();
} else if (events.isReleased(InputID::MOUSE1)) {
mAction = false;
freeFocus();
}
mProject->mCamera.setRatio(area.w / area.z);
if (mAction) {
Vec2F relativePos = ((pointer / area.size) - 0.5f) * 2.f;
Vec2F relativePosPrev = ((mActionPosAbsolutePrev / area.size) - 0.5f) * 2.f;
Vec2F relativeDelta = relativePos - relativePosPrev;
if (events.isDown(InputID::LEFT_SHIFT)) {
mProject->mCamera.move(relativePos, relativePosPrev);
} else if (events.isDown(InputID::LEFT_ALT)) {
mProject->mCamera.rotate(-relativeDelta.x * halnf(PI), -relativeDelta.y * halnf(PI));
} else if (events.isDown(InputID::LEFT_CONTROL)) {
halnf factor = pointer.y / mActionPosAbsolutePrev.y;
mProject->mCamera.zoom(factor);
} else {
mProject->sample(events.getPointerPressure(), area.w / area.z, crs);
}
} else {
mProject->sample(0, area.w / area.z, crs);
}
mActionPosAbsolutePrev = pointer;
}
SketchViewportWidget::SketchViewportWidget() {
setLayout(new ToolBarLayout(this));
setDebug("viewport", {});
}
void SketchViewportWidget::setToolbarWidget(Widget* widget) {
addChild(widget);
widget->bringToFront();
}
ToolbarWidget::ToolbarWidget() {
setDirection(false);
setDebug("toolbar", {});
addToToolbar(&mFileHover);
addToToolbar(&mPencilHover);
addToToolbar(&mViewHover);
mFileHover.setText("File");
mViewHover.setText("View");
mPencilHover.setText("Brush");
}
void ToolbarWidget::addToToolbar(Widget* button) {
button->getLayout()->setMinSize({60, 30});
getContainer()->addChild(button);
}
SketchGUI::SketchGUI() :
DockWidget() {
setCenterWidget(&mViewport);
dockWidget(&mPanel, DockLayout::RIGHT);
toggleWidgetVisibility(DockLayout::RIGHT);
mPanel.addToMenu(&mControls);
mPanel.setText("Controls");
mPanel.setArea({ 110, 110, 300, 500 });
mControls.setText("Tools");
mControls.addToMenu(&mSelectPencil);
mControls.addToMenu(&mSelectEraser);
mControls.setArea({ 0, 0, 300, 400 });
// brush
{
auto popup = mToolbar.mPencilHover.getPopup();
popup->addChild(&mColorPicker);
popup->addChild(&mBrushSizeSlider);
mColorPicker.setArea({10, 10, 300, 300});
}
// view
{
auto popup = mToolbar.mViewHover.getPopup();
popup->addChild(&mToggleSidePanel);
mToggleSidePanel.setText("Toggle Panel");
mToggleSidePanel.setAction([this](){
toggleWidgetVisibility(getSide(&mPanel));
});
}
mSelectPencil.setAction([this](){ mProject->setPencil(); });
mSelectPencil.setText("Pencil");
mSelectEraser.setAction([this](){ mProject->setEraser(); });
mSelectEraser.setText("Eraser TODO");
}
void SketchGUI::createRenderWidget(Canvas* canvas, const Vec2F& renderResolution) {
mRenderWidget = new SketchRenderWidget(*canvas, renderResolution);
mViewport.setRenderWidget(mRenderWidget);
mViewport.setToolbarWidget(&mToolbar);
}
void SketchGUI::setProject(Project* project) {
mProject = project;
mViewport.setProject(project);
if (mRenderWidget) mRenderWidget->setProject(project);
}
SketchGUI::~SketchGUI() { delete mRenderWidget; }
void SketchGUI::process(const EventHandler& events) {
DockWidget::process(events);
if (!mProject) return;
auto pencil = dynamic_cast<PencilBrush*>(mProject->mBrushes.get("pencil"));
pencil->mCol = mColorPicker.mColorWheel.color;
pencil->mSize = mBrushSizeSlider.val() * 0.2f + 0.001f;
}
void SketchGUI::draw(Canvas& canvas) { canvas.rect(getArea().relative(), mBackgroundColor, mRounding); }

9
Sketch3D/public/Sketch3D.hpp
View file

@ -97,6 +97,9 @@ namespace tp {
Project();
~Project();
void setPencil();
void setEraser();
// pos from -1 to 1 (left ot right bottom to top)
void sample(halnf pressure, halnf cameraRatio, Vec2F relativeCameraPos);
@ -116,6 +119,7 @@ namespace tp {
std::string mType = "equal";
Brush() = default;
virtual void sample(Project* proj, Vec2F crs, halnf pressure) {}
virtual void finish(Project* proj) {}
virtual void draw(Renderer* render, const Camera* camera) {}
virtual ~Brush() = default;
};
@ -125,8 +129,9 @@ namespace tp {
PencilBrush();
~PencilBrush() override;
virtual void sample(Project* proj, Vec2F crs, halnf pressure) override;
virtual void draw(Renderer* render, const Camera* camera) override;
void finish(Project* proj) override;
void sample(Project* proj, Vec2F crs, halnf pressure) override;
void draw(Renderer* render, const Camera* camera) override;
private:
void ensureReady(Stroke* stroke, const Camera* cam, bool debug = false) const;

169
Sketch3D/public/Sketch3DWidget.hpp
View file

@ -1,169 +0,0 @@
#pragma once
#include "Sketch3D.hpp"
#include "Widget.hpp"
#include "DockWidget.hpp"
#include "FloatingWidget.hpp"
namespace tp {
class Sketch3DWidget : public Widget {
public:
Sketch3DWidget(Canvas& canvas, Vec2F renderResolution) :
mRenderer(renderResolution) {
mImage = canvas.createImageFromTextId(mRenderer.getBuff()->texId(), mRenderer.getBuff()->getSize());
mCanvas = &canvas;
mProject.mBackgroundColor = { 0.13f, 0.13f, 0.13f, 1.f };
}
~Sketch3DWidget() { mCanvas->deleteImageHandle(mImage); }
void process(const EventHandler& events) override {
auto area = getArea().relative();
Vec2F pointer = events.getPointer();
auto crs = events.getPointer();
if (!area.isInside(events.getPointer())) {
return;
}
crs.x /= area.z;
crs.y /= area.w;
crs = (crs - 0.5) * 2;
if (events.isPressed(InputID::MOUSE1)) {
mAction = true;
} else if (events.isReleased(InputID::MOUSE1)) {
mAction = false;
}
Vec2F relativePos = ((pointer / area.size) - 0.5f) * 2.f;
Vec2F relativePosPrev = ((mActionPosAbsolutePrev / area.size) - 0.5f) * 2.f;
Vec2F relativeDelta = relativePos - relativePosPrev;
mProject.mCamera.setRatio(area.w / area.z);
switch (mMode) {
case Mode::MOVE:
{
if (mAction) mProject.mCamera.move(relativePos, relativePosPrev);
break;
}
case Mode::ZOOM:
{
halnf factor = pointer.y / mActionPosAbsolutePrev.y;
if (mAction) mProject.mCamera.zoom(factor);
break;
}
case Mode::ROTATE:
{
if (mAction) mProject.mCamera.rotate(-relativeDelta.x * halnf(PI), -relativeDelta.y * halnf(PI));
break;
}
case Mode::DRAW:
{
mProject.sample(events.getPointerPressure(), area.w / area.z, crs);
break;
}
default: break;
}
mActionPosAbsolutePrev = pointer;
}
void draw(Canvas& canvas) override {
auto area = getArea().relative();
mRenderer.renderToTexture(&mProject, area.size);
canvas.drawImage(area, &mImage, 0, 1, 12);
}
void setColor(const RGBA& color) { ((PencilBrush*) mProject.mBrushes.get("pencil"))->mCol = color; }
[[nodiscard]] bool processesEvents() const override { return true; }
public:
enum class Mode { MOVE, ROTATE, ZOOM, DRAW, NONE } mMode = Mode::NONE;
Vec2F mActionPosAbsolutePrev = { 0, 0 };
bool mAction = false;
private:
Renderer mRenderer;
Project mProject;
Canvas::ImageHandle mImage;
Canvas* mCanvas = nullptr;
};
class Sketch3DGUI : public DockWidget {
public:
explicit Sketch3DGUI(Canvas& canvas, Vec2F renderResolution) :
DockWidget(),
mViewport(canvas, renderResolution) {
mControls.addToMenu(&mDrawButton);
mControls.addToMenu(&mMoveButton);
mControls.addToMenu(&mRotateButton);
mControls.addToMenu(&mZoomButton);
mColorPicker.addToMenu(&mRed);
mColorPicker.addToMenu(&mGreen);
mColorPicker.addToMenu(&mBlue);
setCenterWidget(&mViewport);
mPanel.addToMenu(&mControls);
mPanel.addToMenu(&mColorPicker);
// addChild(&mPanel);
dockWidget(&mPanel, DockLayout::RIGHT);
mDrawButton.setAction([this]() { mViewport.mMode = Sketch3DWidget::Mode::DRAW; });
mMoveButton.setAction([this]() { mViewport.mMode = Sketch3DWidget::Mode::MOVE; });
mRotateButton.setAction([this]() { mViewport.mMode = Sketch3DWidget::Mode::ROTATE; });
mZoomButton.setAction([this]() { mViewport.mMode = Sketch3DWidget::Mode::ZOOM; });
mDrawButton.setText("Draw");
mMoveButton.setText("Pan");
mRotateButton.setText("Orbit");
mZoomButton.setText("Zoom");
mPanel.setText("Controls");
mControls.setText("Tools");
mColorPicker.setText("Color");
mPanel.setArea({110, 110, 300, 500 });
mControls.setArea({0, 0, 300, 400 });
mColorPicker.setArea({0, 0, 300, 300 });
}
void process(const EventHandler& events) override {
DockWidget::process(events);
mViewport.setColor(RGBA(mRed.val(), mGreen.val(), mBlue.val(), 1.f));
}
void draw(Canvas& canvas) override { canvas.rect(getArea().relative(), mBackgroundColor, mRounding); }
private:
Sketch3DWidget mViewport;
FloatingMenu mPanel;
FloatingMenu mControls;
ButtonWidget mDrawButton;
ButtonWidget mMoveButton;
ButtonWidget mRotateButton;
ButtonWidget mZoomButton;
FloatingMenu mColorPicker;
SliderWidget mRed;
SliderWidget mGreen;
SliderWidget mBlue;
RGBA mBackgroundColor;
halnf mRounding = 0;
};
}

95
Sketch3D/public/SketchGUI.hpp Normal file
View file

@ -0,0 +1,95 @@
#pragma once
#include "Sketch3D.hpp"
#include "Widget.hpp"
#include "DockWidget.hpp"
#include "FloatingWidget.hpp"
#include "ColorPickerWidget.hpp"
namespace tp {
class SketchRenderWidget : public Widget {
public:
SketchRenderWidget(Canvas& canvas, Vec2F renderResolution);
~SketchRenderWidget() override;
void draw(Canvas& canvas) override;
void setProject(Project* project);
private:
Renderer mRenderer;
Project* mProject = nullptr;
Canvas::ImageHandle mImage;
Canvas* mCanvas = nullptr;
};
class SketchViewportWidget : public Widget {
public:
SketchViewportWidget();
void setProject(Project* project);
void setColor(const RGBA& color);
void setRenderWidget(SketchRenderWidget* widget);
void setToolbarWidget(Widget* widget);
void process(const EventHandler& events) override;
[[nodiscard]] bool processesEvents() const override { return true; }
private:
Project* mProject = nullptr;
public:
Vec2F mActionPosAbsolutePrev = { 0, 0 };
bool mAction = false;
};
class ToolbarWidget : public ScrollableWidget {
public:
ToolbarWidget();
private:
void addToToolbar(Widget* button);
public:
HoverPopupTriggerWidget mFileHover;
HoverPopupTriggerWidget mPencilHover;
HoverPopupTriggerWidget mViewHover;
};
class SketchGUI : public DockWidget {
public:
SketchGUI();
void createRenderWidget(Canvas* canvas, const Vec2F& renderResolution);
void setProject(Project* project);
~SketchGUI() override;
void process(const EventHandler& events) override;
void draw(Canvas& canvas) override;
private:
Project* mProject = nullptr;
SketchViewportWidget mViewport;
ToolbarWidget mToolbar;
SketchRenderWidget* mRenderWidget = nullptr;
FloatingMenu mPanel;
RGBPickerWidget mColorPicker;
ButtonWidget mToggleSidePanel;
ButtonWidget mSelectPencil;
ButtonWidget mSelectEraser;
SliderWidget mBrushSizeSlider;
FloatingMenu mControls;
RGBA mBackgroundColor;
halnf mRounding = 0;
};
}