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

Widgets Additions and sketch3d new gui

Browse source
This commit is contained in:
IlyaShurupov 2024-10-20 12:01:42 +03:00 • committed by Ilya Shurupov
parent afad2c80e5
commit e10a494223
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;
};
}