457 lines
17 KiB
C++
457 lines
17 KiB
C++
#include "terrainvertexpaintmode.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <memory>
|
|
#include <string>
|
|
|
|
#include <QComboBox>
|
|
#include <QDropEvent>
|
|
#include <QEvent>
|
|
#include <QIcon>
|
|
|
|
#include <apps/opencs/model/doc/document.hpp>
|
|
#include <apps/opencs/model/prefs/state.hpp>
|
|
#include <apps/opencs/model/world/cellselection.hpp>
|
|
#include <apps/opencs/model/world/columnimp.hpp>
|
|
#include <apps/opencs/model/world/columns.hpp>
|
|
#include <apps/opencs/model/world/data.hpp>
|
|
#include <apps/opencs/model/world/idtable.hpp>
|
|
#include <apps/opencs/model/world/land.hpp>
|
|
#include <apps/opencs/model/world/universalid.hpp>
|
|
#include <apps/opencs/view/widget/brushshapes.hpp>
|
|
#include <apps/opencs/view/widget/scenetool.hpp>
|
|
|
|
#include <components/debug/debuglog.hpp>
|
|
#include <components/esm3/loadland.hpp>
|
|
|
|
#include "../widget/scenetoolbar.hpp"
|
|
#include "../widget/scenetoolvertexpaintbrush.hpp"
|
|
|
|
#include "../../model/world/commands.hpp"
|
|
#include "../../model/world/idtree.hpp"
|
|
|
|
#include "brushdraw.hpp"
|
|
#include "commands.hpp"
|
|
#include "editmode.hpp"
|
|
#include "mask.hpp"
|
|
#include "pagedworldspacewidget.hpp"
|
|
#include "worldspacewidget.hpp"
|
|
|
|
class QPoint;
|
|
class QWidget;
|
|
|
|
namespace CSMWorld
|
|
{
|
|
struct Cell;
|
|
}
|
|
|
|
namespace osg
|
|
{
|
|
class Group;
|
|
}
|
|
|
|
CSVRender::TerrainVertexPaintMode::TerrainVertexPaintMode(
|
|
WorldspaceWidget* worldspaceWidget, osg::Group* parentNode, QWidget* parent)
|
|
: EditMode(worldspaceWidget, QIcon{ ":scenetoolbar/editing-terrain-vertex-paint" }, Mask_Terrain,
|
|
"Terrain vertex paint editing", parent)
|
|
, mParentNode(parentNode)
|
|
, mVertexPaintEditToolColor(Qt::white)
|
|
{
|
|
}
|
|
|
|
void CSVRender::TerrainVertexPaintMode::activate(CSVWidget::SceneToolbar* toolbar)
|
|
{
|
|
if (!mVertexPaintBrushScenetool)
|
|
{
|
|
mVertexPaintBrushScenetool = new CSVWidget::SceneToolVertexPaintBrush(
|
|
toolbar, "scenetoolvertexpaintbrush", getWorldspaceWidget().getDocument());
|
|
connect(mVertexPaintBrushScenetool->mVertexPaintBrushWindow, &CSVWidget::VertexPaintBrushWindow::passBrushSize,
|
|
this, &TerrainVertexPaintMode::setBrushSize);
|
|
connect(mVertexPaintBrushScenetool->mVertexPaintBrushWindow, &CSVWidget::VertexPaintBrushWindow::passBrushShape,
|
|
this, &TerrainVertexPaintMode::setBrushShape);
|
|
connect(mVertexPaintBrushScenetool->mVertexPaintBrushWindow->mSizeSliders->mBrushSizeSlider,
|
|
&QSlider::valueChanged, this, &TerrainVertexPaintMode::setBrushSize);
|
|
connect(mVertexPaintBrushScenetool->mVertexPaintBrushWindow->mToolSelector,
|
|
qOverload<int>(&QComboBox::currentIndexChanged), this, &TerrainVertexPaintMode::setVertexPaintEditTool);
|
|
connect(mVertexPaintBrushScenetool->mVertexPaintBrushWindow->mColorButtonWidget,
|
|
&CSVWidget::ColorButtonWidget::colorChanged, this, &TerrainVertexPaintMode::setVertexPaintColor);
|
|
}
|
|
|
|
if (!mBrushDraw)
|
|
mBrushDraw = std::make_unique<BrushDraw>(mParentNode);
|
|
|
|
EditMode::activate(toolbar);
|
|
toolbar->addTool(mVertexPaintBrushScenetool);
|
|
}
|
|
|
|
void CSVRender::TerrainVertexPaintMode::deactivate(CSVWidget::SceneToolbar* toolbar)
|
|
{
|
|
if (mVertexPaintBrushScenetool)
|
|
{
|
|
toolbar->removeTool(mVertexPaintBrushScenetool);
|
|
}
|
|
|
|
if (mBrushDraw)
|
|
mBrushDraw.reset();
|
|
|
|
EditMode::deactivate(toolbar);
|
|
}
|
|
|
|
void CSVRender::TerrainVertexPaintMode::primaryOpenPressed(const WorldspaceHitResult& hit) // Apply changes here
|
|
{
|
|
}
|
|
|
|
void CSVRender::TerrainVertexPaintMode::primaryEditPressed(const WorldspaceHitResult& hit)
|
|
{
|
|
if (hit.hit && hit.tag == nullptr)
|
|
{
|
|
mRestoreMode = true;
|
|
CSMDoc::Document& document = getWorldspaceWidget().getDocument();
|
|
QUndoStack& undoStack = document.getUndoStack();
|
|
undoStack.beginMacro("Restore land vertex colour");
|
|
editVertexColourGrid(CSMWorld::CellCoordinates::toVertexCoords(hit.worldPos), true);
|
|
undoStack.endMacro();
|
|
}
|
|
mRestoreMode = false;
|
|
}
|
|
|
|
void CSVRender::TerrainVertexPaintMode::primarySelectPressed(const WorldspaceHitResult& hit)
|
|
{
|
|
if (hit.hit && hit.tag == nullptr)
|
|
{
|
|
mRestoreMode = false;
|
|
CSMDoc::Document& document = getWorldspaceWidget().getDocument();
|
|
QUndoStack& undoStack = document.getUndoStack();
|
|
undoStack.beginMacro("Paint land vertex colour");
|
|
editVertexColourGrid(CSMWorld::CellCoordinates::toVertexCoords(hit.worldPos), true);
|
|
undoStack.endMacro();
|
|
}
|
|
}
|
|
|
|
bool CSVRender::TerrainVertexPaintMode::primaryEditStartDrag(const QPoint& pos)
|
|
{
|
|
WorldspaceHitResult hit = getWorldspaceWidget().mousePick(pos, getWorldspaceWidget().getInteractionMask());
|
|
if (hit.hit && hit.tag == nullptr)
|
|
{
|
|
mDragMode = InteractionType_PrimaryEdit;
|
|
mIsEditing = true;
|
|
mRestoreMode = true;
|
|
CSMDoc::Document& document = getWorldspaceWidget().getDocument();
|
|
QUndoStack& undoStack = document.getUndoStack();
|
|
undoStack.beginMacro("Restore land vertex colours");
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CSVRender::TerrainVertexPaintMode::secondaryEditStartDrag(const QPoint& pos)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool CSVRender::TerrainVertexPaintMode::primarySelectStartDrag(const QPoint& pos)
|
|
{
|
|
WorldspaceHitResult hit = getWorldspaceWidget().mousePick(pos, getWorldspaceWidget().getInteractionMask());
|
|
if (hit.hit && hit.tag == nullptr)
|
|
{
|
|
mDragMode = InteractionType_PrimarySelect;
|
|
mIsEditing = true;
|
|
mRestoreMode = false;
|
|
CSMDoc::Document& document = getWorldspaceWidget().getDocument();
|
|
QUndoStack& undoStack = document.getUndoStack();
|
|
undoStack.beginMacro("Paint land vertex colours");
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void CSVRender::TerrainVertexPaintMode::drag(const QPoint& pos, int diffX, int diffY, double speedFactor)
|
|
{
|
|
if (mDragMode == InteractionType_PrimarySelect || mDragMode == InteractionType_PrimaryEdit)
|
|
{
|
|
WorldspaceHitResult hit = getWorldspaceWidget().mousePick(pos, getWorldspaceWidget().getInteractionMask());
|
|
if (mIsEditing && hit.hit && hit.tag == nullptr)
|
|
editVertexColourGrid(CSMWorld::CellCoordinates::toVertexCoords(hit.worldPos), true);
|
|
}
|
|
}
|
|
|
|
void CSVRender::TerrainVertexPaintMode::dragCompleted(const QPoint& pos)
|
|
{
|
|
if (mDragMode == InteractionType_PrimarySelect || mDragMode == InteractionType_PrimaryEdit)
|
|
{
|
|
if (mIsEditing)
|
|
{
|
|
CSMDoc::Document& document = getWorldspaceWidget().getDocument();
|
|
QUndoStack& undoStack = document.getUndoStack();
|
|
undoStack.endMacro();
|
|
}
|
|
endVertexPaintEditing();
|
|
mRestoreMode = false;
|
|
}
|
|
}
|
|
|
|
void CSVRender::TerrainVertexPaintMode::dragAborted()
|
|
{
|
|
if (mIsEditing)
|
|
{
|
|
CSMDoc::Document& document = getWorldspaceWidget().getDocument();
|
|
QUndoStack& undoStack = document.getUndoStack();
|
|
undoStack.endMacro();
|
|
}
|
|
endVertexPaintEditing();
|
|
mDragMode = InteractionType_None;
|
|
mRestoreMode = false;
|
|
}
|
|
|
|
void CSVRender::TerrainVertexPaintMode::dragWheel(int diff, double speedFactor) {}
|
|
|
|
void CSVRender::TerrainVertexPaintMode::endVertexPaintEditing()
|
|
{
|
|
mIsEditing = false;
|
|
}
|
|
|
|
void CSVRender::TerrainVertexPaintMode::editVertexColourGrid(
|
|
const std::pair<int, int>& vertexCoords, bool dragOperation)
|
|
{
|
|
CSMDoc::Document& document = getWorldspaceWidget().getDocument();
|
|
CSMWorld::IdTable& landTable
|
|
= dynamic_cast<CSMWorld::IdTable&>(*document.getData().getTableModel(CSMWorld::UniversalId::Type_Land));
|
|
|
|
std::string cellId = CSMWorld::CellCoordinates::vertexGlobalToCellId(vertexCoords);
|
|
|
|
if (!allowLandColourEditing(cellId))
|
|
return;
|
|
|
|
std::pair<CSMWorld::CellCoordinates, bool> cellCoordinatesPair = CSMWorld::CellCoordinates::fromId(cellId);
|
|
|
|
int cellX = cellCoordinatesPair.first.getX();
|
|
int cellY = cellCoordinatesPair.first.getY();
|
|
|
|
int xHitInCell = CSMWorld::CellCoordinates::vertexGlobalToInCellCoords(vertexCoords.first);
|
|
int yHitInCell = CSMWorld::CellCoordinates::vertexGlobalToInCellCoords(vertexCoords.second);
|
|
if (xHitInCell < 0)
|
|
{
|
|
xHitInCell = xHitInCell + ESM::Land::LAND_SIZE;
|
|
cellX = cellX - 1;
|
|
}
|
|
if (yHitInCell > ESM::Land::LAND_SIZE - 1)
|
|
{
|
|
yHitInCell = yHitInCell - ESM::Land::LAND_SIZE;
|
|
cellY = cellY + 1;
|
|
}
|
|
|
|
cellId = CSMWorld::CellCoordinates::generateId(cellX, cellY);
|
|
if (!allowLandColourEditing(cellId))
|
|
return;
|
|
|
|
std::string iteratedCellId;
|
|
|
|
int colourColumn = landTable.findColumnIndex(CSMWorld::Columns::ColumnId_LandColoursIndex);
|
|
|
|
int r = std::max(static_cast<float>(mBrushSize) / 2.0f, 1.0f);
|
|
|
|
if (mBrushShape == CSVWidget::BrushShape_Point)
|
|
{
|
|
CSMWorld::LandColoursColumn::DataType newTerrain = landTable.data(landTable.getModelIndex(cellId, colourColumn))
|
|
.value<CSMWorld::LandColoursColumn::DataType>();
|
|
|
|
if (allowLandColourEditing(cellId))
|
|
{
|
|
alterColour(newTerrain, xHitInCell, yHitInCell);
|
|
pushEditToCommand(newTerrain, document, landTable, cellId);
|
|
}
|
|
}
|
|
|
|
const bool isSquareBrush = mBrushShape == CSVWidget::BrushShape_Square;
|
|
const bool isCircleBrush = mBrushShape == CSVWidget::BrushShape_Circle;
|
|
if (isSquareBrush || isCircleBrush)
|
|
{
|
|
int upperLeftCellX = cellX - std::floor(r / ESM::Land::LAND_SIZE);
|
|
int upperLeftCellY = cellY - std::floor(r / ESM::Land::LAND_SIZE);
|
|
if (xHitInCell - (r % ESM::Land::LAND_SIZE) < 0)
|
|
upperLeftCellX--;
|
|
if (yHitInCell - (r % ESM::Land::LAND_SIZE) < 0)
|
|
upperLeftCellY--;
|
|
|
|
int lowerrightCellX = cellX + std::floor(r / ESM::Land::LAND_SIZE);
|
|
int lowerrightCellY = cellY + std::floor(r / ESM::Land::LAND_SIZE);
|
|
if (xHitInCell + (r % ESM::Land::LAND_SIZE) > ESM::Land::LAND_SIZE - 1)
|
|
lowerrightCellX++;
|
|
if (yHitInCell + (r % ESM::Land::LAND_SIZE) > ESM::Land::LAND_SIZE - 1)
|
|
lowerrightCellY++;
|
|
|
|
for (int iCell = upperLeftCellX; iCell <= lowerrightCellX; iCell++)
|
|
{
|
|
for (int jCell = upperLeftCellY; jCell <= lowerrightCellY; jCell++)
|
|
{
|
|
iteratedCellId = CSMWorld::CellCoordinates::generateId(iCell, jCell);
|
|
if (allowLandColourEditing(iteratedCellId))
|
|
{
|
|
CSMWorld::LandColoursColumn::DataType newTerrain
|
|
= landTable.data(landTable.getModelIndex(iteratedCellId, colourColumn))
|
|
.value<CSMWorld::LandColoursColumn::DataType>();
|
|
for (int i = 0; i < ESM::Land::LAND_SIZE; i++)
|
|
{
|
|
for (int j = 0; j < ESM::Land::LAND_SIZE; j++)
|
|
{
|
|
osg::Vec2f relativeCoords(0.0, 0.0);
|
|
if (iCell < cellX)
|
|
relativeCoords.x() = xHitInCell + ESM::Land::LAND_SIZE * abs(iCell - cellX) - i;
|
|
else if (iCell > cellX)
|
|
relativeCoords.x() = -xHitInCell + ESM::Land::LAND_SIZE * abs(iCell - cellX) + i;
|
|
else
|
|
relativeCoords.x() = abs(i - xHitInCell);
|
|
if (jCell < cellY)
|
|
relativeCoords.y() = yHitInCell + ESM::Land::LAND_SIZE * abs(jCell - cellY) - j;
|
|
else if (jCell > cellY)
|
|
relativeCoords.y() = -yHitInCell + ESM::Land::LAND_SIZE * abs(jCell - cellY) + j;
|
|
else
|
|
relativeCoords.y() = abs(j - yHitInCell);
|
|
if (isSquareBrush && (relativeCoords.x() >= r || relativeCoords.y() >= r))
|
|
continue;
|
|
if (isCircleBrush && relativeCoords.length() >= r)
|
|
continue;
|
|
alterColour(newTerrain, i, j);
|
|
}
|
|
}
|
|
pushEditToCommand(newTerrain, document, landTable, iteratedCellId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CSVRender::TerrainVertexPaintMode::alterColour(
|
|
CSMWorld::LandColoursColumn::DataType& landColorsNew, int inCellX, int inCellY)
|
|
{
|
|
const int red = mRestoreMode ? 255 : mVertexPaintEditToolColor.red();
|
|
const int green = mRestoreMode ? 255 : mVertexPaintEditToolColor.green();
|
|
const int blue = mRestoreMode ? 255 : mVertexPaintEditToolColor.blue();
|
|
|
|
// TODO: handle different smoothing/blend types with different tools, right now this expects Replace
|
|
landColorsNew[(inCellY * ESM::Land::LAND_SIZE + inCellX) * 3 + 0] = red;
|
|
landColorsNew[(inCellY * ESM::Land::LAND_SIZE + inCellX) * 3 + 1] = green;
|
|
landColorsNew[(inCellY * ESM::Land::LAND_SIZE + inCellX) * 3 + 2] = blue;
|
|
}
|
|
|
|
void CSVRender::TerrainVertexPaintMode::pushEditToCommand(const CSMWorld::LandColoursColumn::DataType& newLandColours,
|
|
CSMDoc::Document& document, CSMWorld::IdTable& landTable, const std::string& cellId)
|
|
{
|
|
QVariant changedLand;
|
|
changedLand.setValue(newLandColours);
|
|
|
|
QModelIndex index(
|
|
landTable.getModelIndex(cellId, landTable.findColumnIndex(CSMWorld::Columns::ColumnId_LandColoursIndex)));
|
|
|
|
QUndoStack& undoStack = document.getUndoStack();
|
|
undoStack.push(new CSMWorld::ModifyCommand(landTable, index, changedLand));
|
|
}
|
|
|
|
bool CSVRender::TerrainVertexPaintMode::allowLandColourEditing(const std::string& cellId, bool useTool)
|
|
{
|
|
CSMDoc::Document& document = getWorldspaceWidget().getDocument();
|
|
CSMWorld::IdTable& landTable
|
|
= dynamic_cast<CSMWorld::IdTable&>(*document.getData().getTableModel(CSMWorld::UniversalId::Type_Land));
|
|
CSMWorld::IdTree& cellTable
|
|
= dynamic_cast<CSMWorld::IdTree&>(*document.getData().getTableModel(CSMWorld::UniversalId::Type_Cells));
|
|
|
|
const ESM::RefId cellRefId = ESM::RefId::stringRefId(cellId);
|
|
const bool noCell = document.getData().getCells().searchId(cellRefId) == -1;
|
|
const bool noLand = document.getData().getLand().searchId(cellRefId) == -1;
|
|
|
|
if (noCell)
|
|
{
|
|
std::string mode = CSMPrefs::get()["3D Scene Editing"]["outside-landedit"].toString();
|
|
|
|
// target cell does not exist
|
|
if (mode == "Discard")
|
|
return false;
|
|
|
|
if (useTool && mode == "Create cell and land, then edit")
|
|
{
|
|
auto createCommand = std::make_unique<CSMWorld::CreateCommand>(cellTable, cellId);
|
|
int parentIndex = cellTable.findColumnIndex(CSMWorld::Columns::ColumnId_Cell);
|
|
int index = cellTable.findNestedColumnIndex(parentIndex, CSMWorld::Columns::ColumnId_Interior);
|
|
createCommand->addNestedValue(parentIndex, index, false);
|
|
document.getUndoStack().push(createCommand.release());
|
|
|
|
if (CSVRender::PagedWorldspaceWidget* paged
|
|
= dynamic_cast<CSVRender::PagedWorldspaceWidget*>(&getWorldspaceWidget()))
|
|
{
|
|
CSMWorld::CellSelection selection = paged->getCellSelection();
|
|
selection.add(CSMWorld::CellCoordinates::fromId(cellId).first);
|
|
paged->setCellSelection(selection);
|
|
}
|
|
}
|
|
}
|
|
else if (CSVRender::PagedWorldspaceWidget* paged
|
|
= dynamic_cast<CSVRender::PagedWorldspaceWidget*>(&getWorldspaceWidget()))
|
|
{
|
|
CSMWorld::CellSelection selection = paged->getCellSelection();
|
|
if (!selection.has(CSMWorld::CellCoordinates::fromId(cellId).first))
|
|
{
|
|
// target cell exists, but is not shown
|
|
std::string mode = CSMPrefs::get()["3D Scene Editing"]["outside-visible-landedit"].toString();
|
|
|
|
if (mode == "Discard")
|
|
return false;
|
|
|
|
if (useTool && mode == "Show cell and edit")
|
|
{
|
|
selection.add(CSMWorld::CellCoordinates::fromId(cellId).first);
|
|
paged->setCellSelection(selection);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (noLand)
|
|
{
|
|
std::string mode = CSMPrefs::get()["3D Scene Editing"]["outside-landedit"].toString();
|
|
|
|
// target cell does not exist
|
|
if (mode == "Discard")
|
|
return false;
|
|
|
|
if (useTool && mode == "Create cell and land, then edit")
|
|
{
|
|
document.getUndoStack().push(new CSMWorld::CreateCommand(landTable, cellId));
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void CSVRender::TerrainVertexPaintMode::dragMoveEvent(QDragMoveEvent* event) {}
|
|
|
|
void CSVRender::TerrainVertexPaintMode::mouseMoveEvent(QMouseEvent* event)
|
|
{
|
|
WorldspaceHitResult hit = getWorldspaceWidget().mousePick(event->pos(), getInteractionMask());
|
|
if (hit.hit && mBrushDraw)
|
|
mBrushDraw->update(hit.worldPos, mBrushSize, mBrushShape);
|
|
if (!hit.hit && mBrushDraw)
|
|
mBrushDraw->hide();
|
|
}
|
|
|
|
void CSVRender::TerrainVertexPaintMode::setBrushSize(int brushSize)
|
|
{
|
|
mBrushSize = brushSize;
|
|
}
|
|
|
|
void CSVRender::TerrainVertexPaintMode::setBrushShape(CSVWidget::BrushShape brushShape)
|
|
{
|
|
mBrushShape = brushShape;
|
|
}
|
|
|
|
void CSVRender::TerrainVertexPaintMode::setVertexPaintEditTool(int shapeEditTool)
|
|
{
|
|
mVertexPaintEditTool = shapeEditTool;
|
|
}
|
|
|
|
void CSVRender::TerrainVertexPaintMode::setVertexPaintColor(const QColor& color)
|
|
{
|
|
mVertexPaintEditToolColor = color;
|
|
}
|