Modules/3DEditor/private/EditorWidget.cpp

#include "EditorWidget.hpp"

#include "BoxLayout.hpp"
#include "Event.hpp"
#include "StackLayout.hpp"
#include "Ui.hpp"

using namespace tp;
using namespace tp::ui;

namespace {
	constexpr halnf kOrbitSensitivity = 3;
	constexpr halnf kSpinRadiansPerMs = 0.1f / 16;
}

EditorViewport::EditorViewport(Canvas& canvas, Editor& editor) :
	mCanvas(canvas),
	mEditor(editor),
	mImage(canvas.createImageFromTextId(editor.getViewportTexID(), { 0, 0 })) {
	setDebugName("editor viewport");
	setSizing(AxisSizing::fill(), AxisSizing::fill());
}

EditorViewport::~EditorViewport() { mCanvas.deleteImageHandle(mImage); }

void EditorViewport::setSpinning(bool spinning) {
	if (spinning) startTicking();
	else stopTicking();
}

void EditorViewport::onEvent(Event& event) {
	switch (event.type()) {
		case Event::Type::PointerDown:
			if (event.button() != PointerButton::Primary) return;
			mDragging = true;
			mPreviousPointer = event.position();
			ui()->capturePointer(*this);
			if (mNavigation == Navigation::Select) mEditor.selectObject(normalized(event.position()) * -1);
			break;

		case Event::Type::PointerMove:
			if (!mDragging) return;
			navigate(event.position(), event.delta());
			mPreviousPointer = event.position();
			break;

		case Event::Type::PointerUp:
			if (!mDragging) return;
			mDragging = false;
			ui()->releasePointer(*this);
			break;

		case Event::Type::Wheel: mEditor.navigationZoom(1 - event.wheelAmount() * 0.1f); break;

		default: return;
	}

	event.accept();
	requestPaint();
}

void EditorViewport::onTick(halnf deltaMs) {
	Object* active = mEditor.getActiveObject();
	if (!active) return;

	auto rotator = decltype(active->mTopology.Basis)::rotatorDir({ 1, 1, 1 }, kSpinRadiansPerMs * deltaMs);
	active->mTopology.Basis = rotator * active->mTopology.Basis;
	mEditor.getScene()->updateCache();
	requestPaint();
}

void EditorViewport::paint(Painter& painter) {
	mEditor.setViewportSize(size());
	mEditor.renderViewport();
	mCanvas.updateTextureID(mImage, mEditor.getViewportTexID());
	painter.image(localRect(), { mImage.id });
}

Vec2F EditorViewport::normalized(Vec2F local) const { return ((local / size()) - 0.5f) * 2.0f; }

void EditorViewport::navigate(Vec2F local, Vec2F delta) {
	switch (mNavigation) {
		case Navigation::Orbit: mEditor.navigationOrbit(delta / size() * kOrbitSensitivity); break;
		case Navigation::Pan: mEditor.navigationPan(normalized(mPreviousPointer), normalized(local)); break;
		case Navigation::Zoom: mEditor.navigationZoom(1 + delta.y / size().y); break;
		case Navigation::Select: mEditor.selectObject(normalized(local) * -1); break;
	}
}

EditorWidget::EditorWidget(Canvas& canvas, Editor& editor) :
	Panel(Surface::Window),
	mEditor(editor),
	mViewport(canvas, editor) {
	setDebugName("editor");
	setSizing(AxisSizing::fill(), AxisSizing::fill());
	emplaceLayout<StackLayout>();

	buildRenderPanel();
	buildNavigationPanel();

	mDock.setCenter(&mViewport);
	mDock.addPanel(mNavigationPanel);
	mDock.addPanel(mRenderPanel);
	mDock.openPanel(mRenderPanel);
	addChild(mDock);
}

void EditorWidget::buildRenderPanel() {
	mRenderType.add(mRaster);
	mRenderType.add(mPathTracer);
	mRenderType.selectIndex(0);
	mRenderType.setOnChanged([this](size_t index) {
		if (index == 1) mEditor.renderPathFrame();
		mEditor.setRenderType(index == 1 ? Editor::RenderType::PATH_TRACER : Editor::RenderType::RASTER);
		mViewport.requestPaint();
	});

	mDenoise.setOnActivate([this]() {
		mEditor.denoisePathRenderBuffers();
		mViewport.requestPaint();
	});

	mRenderContent.emplaceLayout<ColumnLayout>(6).setCrossAlign(CrossAlign::Start);
	for (Widget* item : std::initializer_list<Widget*>{ &mRaster, &mPathTracer, &mDenoise })
		mRenderContent.addChild(*item);

	mRenderPanel.setContent(&mRenderContent);
	mRenderPanel.setDockedLength(260);
}

void EditorWidget::buildNavigationPanel() {
	const EditorViewport::Navigation modes[] = { EditorViewport::Navigation::Orbit,
																							 EditorViewport::Navigation::Pan,
																							 EditorViewport::Navigation::Zoom,
																							 EditorViewport::Navigation::Select };

	for (RadioButton* option : { &mOrbit, &mPan, &mZoom, &mSelect })
		mNavigation.add(*option);
	mNavigation.selectIndex(0);
	mNavigation.setOnChanged([this, modes](size_t index) { mViewport.setNavigation(modes[index]); });

	mReset.setOnActivate([this]() {
		mEditor.navigationReset();
		mViewport.requestPaint();
	});

	mSpin.setOnChanged([this](bool spinning) { mViewport.setSpinning(spinning); });
	mSpin.setChecked(true);

	mNavigationContent.emplaceLayout<ColumnLayout>(6).setCrossAlign(CrossAlign::Start);
	for (Widget* item : std::initializer_list<Widget*>{ &mOrbit, &mPan, &mZoom, &mSelect, &mReset, &mSpin }) {
		mNavigationContent.addChild(*item);
	}

	mNavigationPanel.setContent(&mNavigationContent);
	mNavigationPanel.setDockedLength(200);
}