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

Replace Old Widgets

Browse source
This commit is contained in:
IlyaShurupov 2024-10-18 10:56:42 +03:00
parent cce8f0e1bc
commit fcd5eb2d2a
81 changed files with 388 additions and 278 deletions
Download patch file Download diff file Expand all files Collapse all files

18
Sketch3D/applications/Entry.cpp
View file

@ -1,29 +1,19 @@
#include "GraphicApplication.hpp"
#include "WidgetApplication.hpp"
#include "Sketch3D.hpp"
#include "Sketch3DWidget.hpp"
using namespace tp;
class Sketch3DApplication : public Application {
class Sketch3DApplication : public WidgetApplication {
public:
Sketch3DApplication() :
mGui(*mGraphics->getCanvas(), { 1920, 1080 }) {}
void processFrame(EventHandler* eventHandler, halnf delta) override {
auto rec = RectF({ 0, 0 }, mWindow->getSize());
mGui.setVisible(true);
mGui.setArea(rec);
mGui.updateConfigWrapper(mWidgetManager);
mGui.procWrapper(*eventHandler, rec);
mGui(*mGraphics->getCanvas(), { 1920, 1080 }) {
setRoot(&mGui);
}
void drawFrame(Canvas* canvas) override { mGui.drawWrapper(*canvas); }
private:
WidgetManager mWidgetManager;
Sketch3DGUI mGui;
};

132
Sketch3D/public/Sketch3DWidget.hpp
View file

@ -1,7 +1,9 @@
#pragma once
#include "Sketch3D.hpp"
#include "Widgets.hpp"
#include "Widget.hpp"
#include "DockWidget.hpp"
#include "FloatingWidget.hpp"
namespace tp {
@ -17,30 +19,31 @@ namespace tp {
~Sketch3DWidget() { mCanvas->deleteImageHandle(mImage); }
void eventProcess(const Events& events) override {
if (!this->mArea.isInside(events.getPointer())) {
void process(const EventHandler& events) override {
auto area = getArea().relative();
Vec2F pointer = events.getPointer();
auto crs = events.getPointer();
if (!area.isInside(events.getPointer())) {
return;
}
auto crs = (events.getPointer() - this->mArea.pos);
crs.x /= this->mArea.z;
crs.y /= this->mArea.w;
crs.x /= area.z;
crs.y /= area.w;
crs = (crs - 0.5) * 2;
// TODO : make better api for events
Vec2F absolutePos = events.getPointer() - this->mArea.pos;
if (events.isPressed(InputID::MOUSE1)) {
mAction = true;
} else if (events.isReleased(InputID::MOUSE1)) {
mAction = false;
}
Vec2F relativePos = ((absolutePos / this->mArea.size) - 0.5f) * 2.f;
Vec2F relativePosPrev = ((mActionPosAbsolutePrev / this->mArea.size) - 0.5f) * 2.f;
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(this->mArea.w / this->mArea.z);
mProject.mCamera.setRatio(area.w / area.z);
switch (mMode) {
case Mode::MOVE:
@ -50,7 +53,7 @@ namespace tp {
}
case Mode::ZOOM:
{
halnf factor = absolutePos.y / mActionPosAbsolutePrev.y;
halnf factor = pointer.y / mActionPosAbsolutePrev.y;
if (mAction) mProject.mCamera.zoom(factor);
break;
}
@ -61,22 +64,25 @@ namespace tp {
}
case Mode::DRAW:
{
mProject.sample(events.getPointerPressure(), this->mArea.w / this->mArea.z, crs);
mProject.sample(events.getPointerPressure(), area.w / area.z, crs);
break;
}
default: break;
}
mActionPosAbsolutePrev = absolutePos;
mActionPosAbsolutePrev = pointer;
}
void eventDraw(Canvas& canvas) override {
mRenderer.renderToTexture(&mProject, this->mArea.size);
canvas.drawImage(this->mArea, &mImage, 0, 1, 12);
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;
@ -90,62 +96,72 @@ namespace tp {
Canvas* mCanvas = nullptr;
};
class Sketch3DGUI : public WorkspaceWidget {
class Sketch3DGUI : public DockWidget {
public:
Sketch3DGUI(Canvas& canvas, Vec2F renderResolution) :
mViewport(canvas, renderResolution)
{
explicit Sketch3DGUI(Canvas& canvas, Vec2F renderResolution) :
DockWidget(),
mViewport(canvas, renderResolution) {
mControls.addWidgetToMenu(&mDrawButton);
mControls.addWidgetToMenu(&mMoveButton);
mControls.addWidgetToMenu(&mRotateButton);
mControls.addWidgetToMenu(&mZoomButton);
mControls.addToMenu(&mDrawButton);
mControls.addToMenu(&mMoveButton);
mControls.addToMenu(&mRotateButton);
mControls.addToMenu(&mZoomButton);
mColorPicker.addWidgetToMenu(&mRed);
mColorPicker.addWidgetToMenu(&mGreen);
mColorPicker.addWidgetToMenu(&mBlue);
mColorPicker.addToMenu(&mRed);
mColorPicker.addToMenu(&mGreen);
mColorPicker.addToMenu(&mBlue);
mDockSpace.setCenterWidget(&mViewport);
setCenterWidget(&mViewport);
mFloatingLayer.mChildWidgets.pushBack(&mControls);
mFloatingLayer.mChildWidgets.pushBack(&mColorPicker);
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 });
mDrawButton.mCallback = [this]() { mViewport.mMode = Sketch3DWidget::Mode::DRAW; };
mMoveButton.mCallback = [this]() { mViewport.mMode = Sketch3DWidget::Mode::MOVE; };
mRotateButton.mCallback = [this]() { mViewport.mMode = Sketch3DWidget::Mode::ROTATE; };
mZoomButton.mCallback = [this]() { mViewport.mMode = Sketch3DWidget::Mode::ZOOM; };
}
void eventProcess(const Events& events) override {
WorkspaceWidget::eventProcess(events);
void process(const EventHandler& events) override {
DockWidget::process(events);
mViewport.setColor(RGBA(mRed.mSlider.mFactor, mGreen.mSlider.mFactor, mBlue.mSlider.mFactor, 1.f));
mViewport.setColor(RGBA(mRed.val(), mGreen.val(), mBlue.val(), 1.f));
}
void eventDraw(Canvas& canvas) override { canvas.rect(this->mArea, mBackgroundColor, mRounding); }
void eventUpdateConfiguration(WidgetManager& wm) override {
wm.setActiveId("Sketch3DGui");
mBackgroundColor = wm.getColor("Background", "Background");
mRounding = wm.getNumber("Rounding", "Rounding");
}
void draw(Canvas& canvas) override { canvas.rect(getArea().relative(), mBackgroundColor, mRounding); }
private:
Sketch3DWidget mViewport;
ScrollableWindow mOptions;
FloatingWidget mControls;
ButtonWidget mDrawButton = ButtonWidget("Draw", { 0, 0, 100, 30 });
ButtonWidget mMoveButton = ButtonWidget("Pan", { 0, 0, 100, 30 });
ButtonWidget mRotateButton = ButtonWidget("Orbit", { 0, 0, 100, 30 });
ButtonWidget mZoomButton = ButtonWidget("Zoom", { 0, 0, 100, 30 });
FloatingMenu mPanel;
FloatingWidget mColorPicker;
NamedSliderWidget mRed = NamedSliderWidget("Red");
NamedSliderWidget mGreen = NamedSliderWidget("Green");
NamedSliderWidget mBlue = NamedSliderWidget("Blue");
FloatingMenu mControls;
ButtonWidget mDrawButton;
ButtonWidget mMoveButton;
ButtonWidget mRotateButton;
ButtonWidget mZoomButton;
FloatingMenu mColorPicker;
SliderWidget mRed;
SliderWidget mGreen;
SliderWidget mBlue;
RGBA mBackgroundColor;
halnf mRounding = 0;