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

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;
};
}