mirror/openmw
1
0
Fork 0
mirror of https://github.com/OpenMW/openmw.git synced 2025-10-15 20:16:34 +00:00
Code Issues Releases Wiki Activity

Add and fix -Wshadow

Browse source
This commit is contained in:
elsid 2025-08-06 23:44:18 +02:00
parent 9610be7c8a
commit 3067294f0d
No known key found for this signature in database
GPG key ID: B845CB9FEE18AB40
77 changed files with 455 additions and 445 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
CMakeLists.txt
View file

@ -618,7 +618,7 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" OR CMAKE_CXX_COMPILER_FRONTEND_VARIANT
add_compile_options("/WX") add_compile_options("/WX")
endif() endif()
else () else ()
add_compile_options("-Wall" "-Wextra" "-Wundef" "-Wextra-semi" "-Wno-unused-parameter" "-pedantic" "-Wno-long-long" "-Wnon-virtual-dtor" "-Wunused") add_compile_options("-Wall" "-Wextra" "-Wundef" "-Wextra-semi" "-Wno-unused-parameter" "-pedantic" "-Wno-long-long" "-Wnon-virtual-dtor" "-Wunused" "-Wshadow")
if (CMAKE_CXX_COMPILER_ID STREQUAL Clang AND NOT APPLE) if (CMAKE_CXX_COMPILER_ID STREQUAL Clang AND NOT APPLE)
if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 3.6 OR CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 3.6) if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 3.6 OR CMAKE_CXX_COMPILER_VERSION VERSION_EQUAL 3.6)

7
apps/components_tests/misc/testresourcehelpers.cpp
View file

@ -24,8 +24,11 @@ namespace
TEST(CorrectSoundPath, corrected_path_does_not_check_existence_in_vfs) TEST(CorrectSoundPath, corrected_path_does_not_check_existence_in_vfs)
{ {
std::unique_ptr<VFS::Manager> mVFS = TestingOpenMW::createTestVFS({}); std::unique_ptr<VFS::Manager> mVFS = TestingOpenMW::createTestVFS({});
constexpr VFS::Path::NormalizedView path("sound/foo.wav");
EXPECT_EQ(correctSoundPath(path, *mVFS), "sound/foo.mp3"); {
constexpr VFS::Path::NormalizedView path("sound/foo.wav");
EXPECT_EQ(correctSoundPath(path, *mVFS), "sound/foo.mp3");
}
auto correctESM4SoundPath = [](auto path, auto* vfs) { auto correctESM4SoundPath = [](auto path, auto* vfs) {
return Misc::ResourceHelpers::correctResourcePath({ { "sound" } }, path, vfs, ".mp3"); return Misc::ResourceHelpers::correctResourcePath({ { "sound" } }, path, vfs, ".mp3");

2
apps/components_tests/nifloader/testbulletnifloader.cpp
View file

@ -47,7 +47,7 @@ namespace
bool isNear(const btVector3& lhs, const btVector3& rhs) bool isNear(const btVector3& lhs, const btVector3& rhs)
{ {
return std::equal(static_cast<const btScalar*>(lhs), static_cast<const btScalar*>(lhs) + 3, return std::equal(static_cast<const btScalar*>(lhs), static_cast<const btScalar*>(lhs) + 3,
static_cast<const btScalar*>(rhs), [](btScalar lhs, btScalar rhs) { return isNear(lhs, rhs); }); static_cast<const btScalar*>(rhs), [](btScalar l, btScalar r) { return isNear(l, r); });
} }
bool isNear(const btMatrix3x3& lhs, const btMatrix3x3& rhs) bool isNear(const btMatrix3x3& lhs, const btMatrix3x3& rhs)

10
apps/esmtool/tes4.cpp
View file

@ -572,13 +572,13 @@ namespace EsmTool
} }
} }
auto visitorRec = [&params](ESM4::Reader& reader) { return readRecord(params, reader); }; auto visitorRec = [&params](ESM4::Reader& r) { return readRecord(params, r); };
auto visitorGroup = [&params](ESM4::Reader& reader) { auto visitorGroup = [&params](ESM4::Reader& r) {
if (params.mQuite) if (params.mQuite)
return; return;
auto groupType = static_cast<ESM4::GroupType>(reader.hdr().group.type); auto groupType = static_cast<ESM4::GroupType>(r.hdr().group.type);
std::cout << "\nGroup: " << toString(groupType) << " " std::cout << "\nGroup: " << toString(groupType) << " " << ESM::NAME(r.hdr().group.typeId).toStringView()
<< ESM::NAME(reader.hdr().group.typeId).toStringView() << '\n'; << '\n';
}; };
ESM4::ReaderUtils::readAll(reader, visitorRec, visitorGroup); ESM4::ReaderUtils::readAll(reader, visitorRec, visitorGroup);
} }

6
apps/opencs/model/world/universalid.cpp
View file

@ -245,10 +245,10 @@ CSMWorld::UniversalId::UniversalId(const std::string& universalId)
std::istringstream stream(universalId.substr(index + 2)); std::istringstream stream(universalId.substr(index + 2));
int index = 0; int indexValue = 0;
if (stream >> index) if (stream >> indexValue)
{ {
mValue = index; mValue = indexValue;
return; return;
} }

6
apps/opencs/view/filter/editwidget.cpp
View file

@ -25,16 +25,16 @@
#include "../../model/world/data.hpp" #include "../../model/world/data.hpp"
#include "../../model/world/idtablebase.hpp" #include "../../model/world/idtablebase.hpp"
CSVFilter::EditWidget::EditWidget(CSMWorld::Data& data, QWidget* parent) CSVFilter::EditWidget::EditWidget(CSMWorld::Data& worldData, QWidget* parent)
: QLineEdit(parent) : QLineEdit(parent)
, mParser(data) , mParser(worldData)
, mIsEmpty(true) , mIsEmpty(true)
{ {
mPalette = palette(); mPalette = palette();
connect(this, &QLineEdit::textChanged, this, &EditWidget::textChanged); connect(this, &QLineEdit::textChanged, this, &EditWidget::textChanged);
const CSMWorld::IdTableBase* model const CSMWorld::IdTableBase* model
= static_cast<const CSMWorld::IdTableBase*>(data.getTableModel(CSMWorld::UniversalId::Type_Filters)); = static_cast<const CSMWorld::IdTableBase*>(worldData.getTableModel(CSMWorld::UniversalId::Type_Filters));
connect(model, &CSMWorld::IdTableBase::dataChanged, this, &EditWidget::filterDataChanged, Qt::QueuedConnection); connect(model, &CSMWorld::IdTableBase::dataChanged, this, &EditWidget::filterDataChanged, Qt::QueuedConnection);
connect(model, &CSMWorld::IdTableBase::rowsRemoved, this, &EditWidget::filterRowsRemoved, Qt::QueuedConnection); connect(model, &CSMWorld::IdTableBase::rowsRemoved, this, &EditWidget::filterRowsRemoved, Qt::QueuedConnection);

2
apps/opencs/view/filter/editwidget.hpp
View file

@ -71,7 +71,7 @@ namespace CSVFilter
QAction* mHelpAction; QAction* mHelpAction;
public: public:
EditWidget(CSMWorld::Data& data, QWidget* parent = nullptr); explicit EditWidget(CSMWorld::Data& worldData, QWidget* parent = nullptr);
void createFilterRequest(const std::vector<FilterData>& sourceFilter, Qt::DropAction action); void createFilterRequest(const std::vector<FilterData>& sourceFilter, Qt::DropAction action);

4
apps/opencs/view/filter/filterbox.cpp
View file

@ -16,14 +16,14 @@
#include <apps/opencs/model/world/universalid.hpp> #include <apps/opencs/model/world/universalid.hpp>
#include <apps/opencs/view/world/dragrecordtable.hpp> #include <apps/opencs/view/world/dragrecordtable.hpp>
CSVFilter::FilterBox::FilterBox(CSMWorld::Data& data, QWidget* parent) CSVFilter::FilterBox::FilterBox(CSMWorld::Data& worldData, QWidget* parent)
: QWidget(parent) : QWidget(parent)
{ {
QHBoxLayout* layout = new QHBoxLayout(this); QHBoxLayout* layout = new QHBoxLayout(this);
layout->setContentsMargins(0, 0, 0, 0); layout->setContentsMargins(0, 0, 0, 0);
mRecordFilterBox = new RecordFilterBox(data, this); mRecordFilterBox = new RecordFilterBox(worldData, this);
layout->addWidget(mRecordFilterBox); layout->addWidget(mRecordFilterBox);

2
apps/opencs/view/filter/filterbox.hpp
View file

@ -38,7 +38,7 @@ namespace CSVFilter
RecordFilterBox* mRecordFilterBox; RecordFilterBox* mRecordFilterBox;
public: public:
FilterBox(CSMWorld::Data& data, QWidget* parent = nullptr); explicit FilterBox(CSMWorld::Data& worldData, QWidget* parent = nullptr);
void setRecordFilter(const std::string& filter); void setRecordFilter(const std::string& filter);

4
apps/opencs/view/filter/recordfilterbox.cpp
View file

@ -9,7 +9,7 @@
#include "editwidget.hpp" #include "editwidget.hpp"
#include "filterdata.hpp" #include "filterdata.hpp"
CSVFilter::RecordFilterBox::RecordFilterBox(CSMWorld::Data& data, QWidget* parent) CSVFilter::RecordFilterBox::RecordFilterBox(CSMWorld::Data& worldData, QWidget* parent)
: QWidget(parent) : QWidget(parent)
{ {
QHBoxLayout* layout = new QHBoxLayout(this); QHBoxLayout* layout = new QHBoxLayout(this);
@ -20,7 +20,7 @@ CSVFilter::RecordFilterBox::RecordFilterBox(CSMWorld::Data& data, QWidget* paren
label->setIndent(2); label->setIndent(2);
layout->addWidget(label); layout->addWidget(label);
mEdit = new EditWidget(data, this); mEdit = new EditWidget(worldData, this);
layout->addWidget(mEdit); layout->addWidget(mEdit);

2
apps/opencs/view/filter/recordfilterbox.hpp
View file

@ -33,7 +33,7 @@ namespace CSVFilter
EditWidget* mEdit; EditWidget* mEdit;
public: public:
RecordFilterBox(CSMWorld::Data& data, QWidget* parent = nullptr); explicit RecordFilterBox(CSMWorld::Data& worldData, QWidget* parent = nullptr);
void setFilter(const std::string& filter); void setFilter(const std::string& filter);

16
apps/opencs/view/render/pathgridmode.cpp
View file

@ -39,7 +39,7 @@ namespace CSVRender
PathgridMode::PathgridMode(WorldspaceWidget* worldspaceWidget, QWidget* parent) PathgridMode::PathgridMode(WorldspaceWidget* worldspaceWidget, QWidget* parent)
: EditMode(worldspaceWidget, Misc::ScalableIcon::load(":scenetoolbar/editing-pathgrid"), : EditMode(worldspaceWidget, Misc::ScalableIcon::load(":scenetoolbar/editing-pathgrid"),
Mask_Pathgrid | Mask_Terrain | Mask_Reference, getTooltip(), parent) Mask_Pathgrid | Mask_Terrain | Mask_Reference, getTooltip(), parent)
, mDragMode(DragMode_None) , mDragMode(DragMode::None)
, mFromNode(0) , mFromNode(0)
, mSelectionMode(nullptr) , mSelectionMode(nullptr)
{ {
@ -174,7 +174,7 @@ namespace CSVRender
if (!selection.empty()) if (!selection.empty())
{ {
mDragMode = DragMode_Move; mDragMode = DragMode::Move;
return true; return true;
} }
@ -188,7 +188,7 @@ namespace CSVRender
{ {
if (PathgridTag* tag = dynamic_cast<PathgridTag*>(hit.tag.get())) if (PathgridTag* tag = dynamic_cast<PathgridTag*>(hit.tag.get()))
{ {
mDragMode = DragMode_Edge; mDragMode = DragMode::Edge;
mEdgeId = tag->getPathgrid()->getId(); mEdgeId = tag->getPathgrid()->getId();
mFromNode = SceneUtil::getPathgridNode(hit.index0); mFromNode = SceneUtil::getPathgridNode(hit.index0);
@ -202,7 +202,7 @@ namespace CSVRender
void PathgridMode::drag(const QPoint& pos, int diffX, int diffY, double speedFactor) void PathgridMode::drag(const QPoint& pos, int diffX, int diffY, double speedFactor)
{ {
if (mDragMode == DragMode_Move) if (mDragMode == DragMode::Move)
{ {
std::vector<osg::ref_ptr<TagBase>> selection = getWorldspaceWidget().getSelection(Mask_Pathgrid); std::vector<osg::ref_ptr<TagBase>> selection = getWorldspaceWidget().getSelection(Mask_Pathgrid);
@ -219,7 +219,7 @@ namespace CSVRender
} }
} }
} }
else if (mDragMode == DragMode_Edge) else if (mDragMode == DragMode::Edge)
{ {
WorldspaceHitResult hit = getWorldspaceWidget().mousePick(pos, getWorldspaceWidget().getInteractionMask()); WorldspaceHitResult hit = getWorldspaceWidget().mousePick(pos, getWorldspaceWidget().getInteractionMask());
@ -243,7 +243,7 @@ namespace CSVRender
void PathgridMode::dragCompleted(const QPoint& pos) void PathgridMode::dragCompleted(const QPoint& pos)
{ {
if (mDragMode == DragMode_Move) if (mDragMode == DragMode::Move)
{ {
std::vector<osg::ref_ptr<TagBase>> selection = getWorldspaceWidget().getSelection(Mask_Pathgrid); std::vector<osg::ref_ptr<TagBase>> selection = getWorldspaceWidget().getSelection(Mask_Pathgrid);
for (std::vector<osg::ref_ptr<TagBase>>::iterator it = selection.begin(); it != selection.end(); ++it) for (std::vector<osg::ref_ptr<TagBase>>::iterator it = selection.begin(); it != selection.end(); ++it)
@ -258,7 +258,7 @@ namespace CSVRender
} }
} }
} }
else if (mDragMode == DragMode_Edge) else if (mDragMode == DragMode::Edge)
{ {
WorldspaceHitResult hit = getWorldspaceWidget().mousePick(pos, getWorldspaceWidget().getInteractionMask()); WorldspaceHitResult hit = getWorldspaceWidget().mousePick(pos, getWorldspaceWidget().getInteractionMask());
@ -283,7 +283,7 @@ namespace CSVRender
mFromNode = 0; mFromNode = 0;
} }
mDragMode = DragMode_None; mDragMode = DragMode::None;
getWorldspaceWidget().reset(Mask_Pathgrid); getWorldspaceWidget().reset(Mask_Pathgrid);
} }

8
apps/opencs/view/render/pathgridmode.hpp
View file

@ -50,11 +50,11 @@ namespace CSVRender
void dragAborted() override; void dragAborted() override;
private: private:
enum DragMode enum class DragMode
{ {
DragMode_None, None,
DragMode_Move, Move,
DragMode_Edge Edge
}; };
DragMode mDragMode; DragMode mDragMode;

8
apps/opencs/view/render/previewwidget.cpp
View file

@ -12,10 +12,10 @@
class QWidget; class QWidget;
CSVRender::PreviewWidget::PreviewWidget( CSVRender::PreviewWidget::PreviewWidget(
CSMWorld::Data& data, const std::string& id, bool referenceable, QWidget* parent) CSMWorld::Data& worldData, const std::string& id, bool referenceable, QWidget* parent)
: SceneWidget(data.getResourceSystem(), parent) : SceneWidget(worldData.getResourceSystem(), parent)
, mData(data) , mData(worldData)
, mObject(data, mRootNode, id, referenceable) , mObject(worldData, mRootNode, id, referenceable)
{ {
selectNavigationMode("orbit"); selectNavigationMode("orbit");

3
apps/opencs/view/render/previewwidget.hpp
View file

@ -26,7 +26,8 @@ namespace CSVRender
CSVRender::Object mObject; CSVRender::Object mObject;
public: public:
PreviewWidget(CSMWorld::Data& data, const std::string& id, bool referenceable, QWidget* parent = nullptr); explicit PreviewWidget(
CSMWorld::Data& worldData, const std::string& id, bool referenceable, QWidget* parent = nullptr);
signals: signals:

2
apps/opencs/view/render/worldspacewidget.cpp
View file

@ -454,7 +454,7 @@ CSVRender::WorldspaceHitResult CSVRender::WorldspaceWidget::mousePick(
std::vector<osgUtil::LineSegmentIntersector::Intersection> validIntersections std::vector<osgUtil::LineSegmentIntersector::Intersection> validIntersections
= { intersections.begin(), intersections.end() }; = { intersections.begin(), intersections.end() };
const auto& removeBackfaces = [direction = direction](const osgUtil::LineSegmentIntersector::Intersection& i) { const auto& removeBackfaces = [direction](const osgUtil::LineSegmentIntersector::Intersection& i) {
return direction * i.getWorldIntersectNormal() > 0; return direction * i.getWorldIntersectNormal() > 0;
}; };

5
apps/opencs/view/world/bodypartcreator.cpp
View file

@ -19,8 +19,9 @@ std::string CSVWorld::BodyPartCreator::getId() const
return id; return id;
} }
CSVWorld::BodyPartCreator::BodyPartCreator(CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id) CSVWorld::BodyPartCreator::BodyPartCreator(
: GenericCreator(data, undoStack, id) CSMWorld::Data& worldData, QUndoStack& undoStack, const CSMWorld::UniversalId& id)
: GenericCreator(worldData, undoStack, id)
{ {
mFirstPerson = new QCheckBox("First Person", this); mFirstPerson = new QCheckBox("First Person", this);
insertBeforeButtons(mFirstPerson, false); insertBeforeButtons(mFirstPerson, false);

2
apps/opencs/view/world/bodypartcreator.hpp
View file

@ -25,7 +25,7 @@ namespace CSVWorld
std::string getId() const override; std::string getId() const override;
public: public:
BodyPartCreator(CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id); explicit BodyPartCreator(CSMWorld::Data& worldData, QUndoStack& undoStack, const CSMWorld::UniversalId& id);
/// \return Error description for current user input. /// \return Error description for current user input.
std::string getErrors() const override; std::string getErrors() const override;

4
apps/opencs/view/world/cellcreator.cpp
View file

@ -37,8 +37,8 @@ void CSVWorld::CellCreator::configureCreateCommand(CSMWorld::CreateCommand& comm
command.addNestedValue(parentIndex, index, mType->currentIndex() == 0); command.addNestedValue(parentIndex, index, mType->currentIndex() == 0);
} }
CSVWorld::CellCreator::CellCreator(CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id) CSVWorld::CellCreator::CellCreator(CSMWorld::Data& worldData, QUndoStack& undoStack, const CSMWorld::UniversalId& id)
: GenericCreator(data, undoStack, id) : GenericCreator(worldData, undoStack, id)
{ {
mY = new QSpinBox(this); mY = new QSpinBox(this);
mY->setVisible(false); mY->setVisible(false);

2
apps/opencs/view/world/cellcreator.hpp
View file

@ -38,7 +38,7 @@ namespace CSVWorld
void configureCreateCommand(CSMWorld::CreateCommand& command) const override; void configureCreateCommand(CSMWorld::CreateCommand& command) const override;
public: public:
CellCreator(CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id); explicit CellCreator(CSMWorld::Data& worldData, QUndoStack& undoStack, const CSMWorld::UniversalId& id);
void reset() override; void reset() override;

4
apps/opencs/view/world/dialoguecreator.cpp
View file

@ -21,8 +21,8 @@ void CSVWorld::DialogueCreator::configureCreateCommand(CSMWorld::CreateCommand&
} }
CSVWorld::DialogueCreator::DialogueCreator( CSVWorld::DialogueCreator::DialogueCreator(
CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id, int type) CSMWorld::Data& worldData, QUndoStack& undoStack, const CSMWorld::UniversalId& id, int type)
: GenericCreator(data, undoStack, id, true) : GenericCreator(worldData, undoStack, id, true)
, mType(type) , mType(type)
{ {
} }

3
apps/opencs/view/world/dialoguecreator.hpp
View file

@ -29,7 +29,8 @@ namespace CSVWorld
void configureCreateCommand(CSMWorld::CreateCommand& command) const override; void configureCreateCommand(CSMWorld::CreateCommand& command) const override;
public: public:
DialogueCreator(CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id, int type); explicit DialogueCreator(
CSMWorld::Data& worldData, QUndoStack& undoStack, const CSMWorld::UniversalId& id, int type);
}; };
class TopicCreatorFactory : public CreatorFactoryBase class TopicCreatorFactory : public CreatorFactoryBase

4
apps/opencs/view/world/genericcreator.cpp
View file

@ -149,8 +149,8 @@ void CSVWorld::GenericCreator::addScope(const QString& name, CSMWorld::Scope sco
} }
CSVWorld::GenericCreator::GenericCreator( CSVWorld::GenericCreator::GenericCreator(
CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id, bool relaxedIdRules) CSMWorld::Data& worldData, QUndoStack& undoStack, const CSMWorld::UniversalId& id, bool relaxedIdRules)
: mData(data) : mData(worldData)
, mUndoStack(undoStack) , mUndoStack(undoStack)
, mListId(id) , mListId(id)
, mLocked(false) , mLocked(false)

4
apps/opencs/view/world/genericcreator.hpp
View file

@ -95,8 +95,8 @@ namespace CSVWorld
void addScope(const QString& name, CSMWorld::Scope scope, const QString& tooltip); void addScope(const QString& name, CSMWorld::Scope scope, const QString& tooltip);
public: public:
GenericCreator( explicit GenericCreator(CSMWorld::Data& worldData, QUndoStack& undoStack, const CSMWorld::UniversalId& id,
CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id, bool relaxedIdRules = false); bool relaxedIdRules = false);
void setEditLock(bool locked) override; void setEditLock(bool locked) override;

4
apps/opencs/view/world/globalcreator.cpp
View file

@ -23,8 +23,8 @@ namespace CSVWorld
command.addValue(index, type); command.addValue(index, type);
} }
GlobalCreator::GlobalCreator(CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id) GlobalCreator::GlobalCreator(CSMWorld::Data& worldData, QUndoStack& undoStack, const CSMWorld::UniversalId& id)
: GenericCreator(data, undoStack, id, true) : GenericCreator(worldData, undoStack, id, true)
{ {
} }
} }

2
apps/opencs/view/world/globalcreator.hpp
View file

@ -21,7 +21,7 @@ namespace CSVWorld
Q_OBJECT Q_OBJECT
public: public:
GlobalCreator(CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id); explicit GlobalCreator(CSMWorld::Data& worldData, QUndoStack& undoStack, const CSMWorld::UniversalId& id);
protected: protected:
void configureCreateCommand(CSMWorld::CreateCommand& command) const override; void configureCreateCommand(CSMWorld::CreateCommand& command) const override;

4
apps/opencs/view/world/infocreator.cpp
View file

@ -81,9 +81,9 @@ void CSVWorld::InfoCreator::configureCreateCommand(CSMWorld::CreateCommand& comm
} }
} }
CSVWorld::InfoCreator::InfoCreator(CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id, CSVWorld::InfoCreator::InfoCreator(CSMWorld::Data& worldData, QUndoStack& undoStack, const CSMWorld::UniversalId& id,
CSMWorld::IdCompletionManager& completionManager) CSMWorld::IdCompletionManager& completionManager)
: GenericCreator(data, undoStack, id) : GenericCreator(worldData, undoStack, id)
{ {
// Determine if we're dealing with topics or journals. // Determine if we're dealing with topics or journals.
CSMWorld::ColumnBase::Display displayType = CSMWorld::ColumnBase::Display_Topic; CSMWorld::ColumnBase::Display displayType = CSMWorld::ColumnBase::Display_Topic;

2
apps/opencs/view/world/infocreator.hpp
View file

@ -40,7 +40,7 @@ namespace CSVWorld
void configureCreateCommand(CSMWorld::CreateCommand& command) const override; void configureCreateCommand(CSMWorld::CreateCommand& command) const override;
public: public:
InfoCreator(CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id, explicit InfoCreator(CSMWorld::Data& worldData, QUndoStack& undoStack, const CSMWorld::UniversalId& id,
CSMWorld::IdCompletionManager& completionManager); CSMWorld::IdCompletionManager& completionManager);
void cloneMode(const std::string& originId, const CSMWorld::UniversalId::Type type) override; void cloneMode(const std::string& originId, const CSMWorld::UniversalId::Type type) override;

4
apps/opencs/view/world/landcreator.cpp
View file

@ -15,8 +15,8 @@
namespace CSVWorld namespace CSVWorld
{ {
LandCreator::LandCreator(CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id) LandCreator::LandCreator(CSMWorld::Data& worldData, QUndoStack& undoStack, const CSMWorld::UniversalId& id)
: GenericCreator(data, undoStack, id) : GenericCreator(worldData, undoStack, id)
, mXLabel(nullptr) , mXLabel(nullptr)
, mYLabel(nullptr) , mYLabel(nullptr)
, mX(nullptr) , mX(nullptr)

2
apps/opencs/view/world/landcreator.hpp
View file

@ -30,7 +30,7 @@ namespace CSVWorld
QSpinBox* mY; QSpinBox* mY;
public: public:
LandCreator(CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id); explicit LandCreator(CSMWorld::Data& worldData, QUndoStack& undoStack, const CSMWorld::UniversalId& id);
void cloneMode(const std::string& originId, const CSMWorld::UniversalId::Type type) override; void cloneMode(const std::string& originId, const CSMWorld::UniversalId::Type type) override;

6
apps/opencs/view/world/pathgridcreator.cpp
View file

@ -30,9 +30,9 @@ CSMWorld::IdTable& CSVWorld::PathgridCreator::getPathgridsTable() const
return dynamic_cast<CSMWorld::IdTable&>(*getData().getTableModel(getCollectionId())); return dynamic_cast<CSMWorld::IdTable&>(*getData().getTableModel(getCollectionId()));
} }
CSVWorld::PathgridCreator::PathgridCreator(CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id, CSVWorld::PathgridCreator::PathgridCreator(CSMWorld::Data& worldData, QUndoStack& undoStack,
CSMWorld::IdCompletionManager& completionManager) const CSMWorld::UniversalId& id, CSMWorld::IdCompletionManager& completionManager)
: GenericCreator(data, undoStack, id) : GenericCreator(worldData, undoStack, id)
{ {
setManualEditing(false); setManualEditing(false);

2
apps/opencs/view/world/pathgridcreator.hpp
View file

@ -42,7 +42,7 @@ namespace CSVWorld
CSMWorld::IdTable& getPathgridsTable() const; CSMWorld::IdTable& getPathgridsTable() const;
public: public:
PathgridCreator(CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id, explicit PathgridCreator(CSMWorld::Data& worldData, QUndoStack& undoStack, const CSMWorld::UniversalId& id,
CSMWorld::IdCompletionManager& completionManager); CSMWorld::IdCompletionManager& completionManager);
/// \brief Set cell ID input widget to ID of record to be cloned. /// \brief Set cell ID input widget to ID of record to be cloned.

4
apps/opencs/view/world/referenceablecreator.cpp
View file

@ -25,8 +25,8 @@ void CSVWorld::ReferenceableCreator::configureCreateCommand(CSMWorld::CreateComm
} }
CSVWorld::ReferenceableCreator::ReferenceableCreator( CSVWorld::ReferenceableCreator::ReferenceableCreator(
CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id) CSMWorld::Data& worldData, QUndoStack& undoStack, const CSMWorld::UniversalId& id)
: GenericCreator(data, undoStack, id) : GenericCreator(worldData, undoStack, id)
{ {
QLabel* label = new QLabel("Type", this); QLabel* label = new QLabel("Type", this);
insertBeforeButtons(label, false); insertBeforeButtons(label, false);

3
apps/opencs/view/world/referenceablecreator.hpp
View file

@ -29,7 +29,8 @@ namespace CSVWorld
void configureCreateCommand(CSMWorld::CreateCommand& command) const override; void configureCreateCommand(CSMWorld::CreateCommand& command) const override;
public: public:
ReferenceableCreator(CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id); explicit ReferenceableCreator(
CSMWorld::Data& worldData, QUndoStack& undoStack, const CSMWorld::UniversalId& id);
void reset() override; void reset() override;

4
apps/opencs/view/world/referencecreator.cpp
View file

@ -33,9 +33,9 @@ void CSVWorld::ReferenceCreator::configureCreateCommand(CSMWorld::CreateCommand&
command.addValue(cellIdColumn, mCell->text()); command.addValue(cellIdColumn, mCell->text());
} }
CSVWorld::ReferenceCreator::ReferenceCreator(CSMWorld::Data& data, QUndoStack& undoStack, CSVWorld::ReferenceCreator::ReferenceCreator(CSMWorld::Data& worldData, QUndoStack& undoStack,
const CSMWorld::UniversalId& id, CSMWorld::IdCompletionManager& completionManager) const CSMWorld::UniversalId& id, CSMWorld::IdCompletionManager& completionManager)
: GenericCreator(data, undoStack, id) : GenericCreator(worldData, undoStack, id)
{ {
QLabel* label = new QLabel("Cell", this); QLabel* label = new QLabel("Cell", this);
insertBeforeButtons(label, false); insertBeforeButtons(label, false);

2
apps/opencs/view/world/referencecreator.hpp
View file

@ -44,7 +44,7 @@ namespace CSVWorld
void configureCreateCommand(CSMWorld::CreateCommand& command) const override; void configureCreateCommand(CSMWorld::CreateCommand& command) const override;
public: public:
ReferenceCreator(CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id, explicit ReferenceCreator(CSMWorld::Data& worldData, QUndoStack& undoStack, const CSMWorld::UniversalId& id,
CSMWorld::IdCompletionManager& completionManager); CSMWorld::IdCompletionManager& completionManager);
void cloneMode(const std::string& originId, const CSMWorld::UniversalId::Type type) override; void cloneMode(const std::string& originId, const CSMWorld::UniversalId::Type type) override;

4
apps/opencs/view/world/startscriptcreator.cpp
View file

@ -29,9 +29,9 @@ CSMWorld::IdTable& CSVWorld::StartScriptCreator::getStartScriptsTable() const
return dynamic_cast<CSMWorld::IdTable&>(*getData().getTableModel(getCollectionId())); return dynamic_cast<CSMWorld::IdTable&>(*getData().getTableModel(getCollectionId()));
} }
CSVWorld::StartScriptCreator::StartScriptCreator(CSMWorld::Data& data, QUndoStack& undoStack, CSVWorld::StartScriptCreator::StartScriptCreator(CSMWorld::Data& worldData, QUndoStack& undoStack,
const CSMWorld::UniversalId& id, CSMWorld::IdCompletionManager& completionManager) const CSMWorld::UniversalId& id, CSMWorld::IdCompletionManager& completionManager)
: GenericCreator(data, undoStack, id) : GenericCreator(worldData, undoStack, id)
{ {
setManualEditing(false); setManualEditing(false);

2
apps/opencs/view/world/startscriptcreator.hpp
View file

@ -45,7 +45,7 @@ namespace CSVWorld
CSMWorld::IdTable& getStartScriptsTable() const; CSMWorld::IdTable& getStartScriptsTable() const;
public: public:
StartScriptCreator(CSMWorld::Data& data, QUndoStack& undoStack, const CSMWorld::UniversalId& id, explicit StartScriptCreator(CSMWorld::Data& worldData, QUndoStack& undoStack, const CSMWorld::UniversalId& id,
CSMWorld::IdCompletionManager& completionManager); CSMWorld::IdCompletionManager& completionManager);
/// \brief Set script ID input widget to ID of record to be cloned. /// \brief Set script ID input widget to ID of record to be cloned.

4
apps/openmw/mwdialogue/quest.cpp
View file

@ -71,8 +71,8 @@ namespace MWDialogue
const ESM::Dialogue* dialogue const ESM::Dialogue* dialogue
= MWBase::Environment::get().getESMStore()->get<ESM::Dialogue>().find(entry.mTopic); = MWBase::Environment::get().getESMStore()->get<ESM::Dialogue>().find(entry.mTopic);
auto info = std::find_if(dialogue->mInfo.begin(), dialogue->mInfo.end(), auto info = std::find_if(
[&](const auto& info) { return info.mId == entry.mInfoId; }); dialogue->mInfo.begin(), dialogue->mInfo.end(), [&](const auto& i) { return i.mId == entry.mInfoId; });
if (info == dialogue->mInfo.end() || info->mData.mJournalIndex == -1) if (info == dialogue->mInfo.end() || info->mData.mJournalIndex == -1)
throw std::runtime_error("unknown journal entry for topic " + mTopic.toDebugString()); throw std::runtime_error("unknown journal entry for topic " + mTopic.toDebugString());

34
apps/openmw/mwgui/bookpage.cpp
View file

@ -1122,10 +1122,10 @@ namespace MWGui
struct CreateActiveFormat struct CreateActiveFormat
{ {
PageDisplay* this_; PageDisplay* mPageDisplay;
CreateActiveFormat(PageDisplay* this_) explicit CreateActiveFormat(PageDisplay* pageDisplay)
: this_(this_) : mPageDisplay(pageDisplay)
{ {
} }
@ -1133,15 +1133,15 @@ namespace MWGui
{ {
MyGUI::IFont* const font = run.mStyle->mFont; MyGUI::IFont* const font = run.mStyle->mFont;
ActiveTextFormats::iterator j = this_->mActiveTextFormats.find(font); ActiveTextFormats::iterator j = mPageDisplay->mActiveTextFormats.find(font);
if (j == this_->mActiveTextFormats.end()) if (j == mPageDisplay->mActiveTextFormats.end())
{ {
auto textFormat = std::make_unique<TextFormat>(font, this_); auto textFormat = std::make_unique<TextFormat>(font, mPageDisplay);
textFormat->mTexture = font->getTextureFont(); textFormat->mTexture = font->getTextureFont();
j = this_->mActiveTextFormats.insert(std::make_pair(font, std::move(textFormat))).first; j = mPageDisplay->mActiveTextFormats.insert(std::make_pair(font, std::move(textFormat))).first;
} }
j->second->mCountVertex += run.mPrintableChars * 6; j->second->mCountVertex += run.mPrintableChars * 6;
@ -1189,24 +1189,24 @@ namespace MWGui
struct RenderRun struct RenderRun
{ {
PageDisplay* this_; PageDisplay* mPageDisplay;
GlyphStream& glyphStream; GlyphStream& mGlyphStream;
RenderRun(PageDisplay* this_, GlyphStream& glyphStream) explicit RenderRun(PageDisplay* pageDisplay, GlyphStream& glyphStream)
: this_(this_) : mPageDisplay(pageDisplay)
, glyphStream(glyphStream) , mGlyphStream(glyphStream)
{ {
} }
void operator()(Section const& section, Line const& line, Run const& run) const void operator()(Section const& section, Line const& line, Run const& run) const
{ {
bool isActive = run.mStyle->mInteractiveId && (run.mStyle == this_->mFocusItem); bool isActive = run.mStyle->mInteractiveId && (run.mStyle == mPageDisplay->mFocusItem);
MyGUI::Colour colour = isActive MyGUI::Colour colour = isActive
? (this_->mItemActive ? run.mStyle->mActiveColour : run.mStyle->mHotColour) ? (mPageDisplay->mItemActive ? run.mStyle->mActiveColour : run.mStyle->mHotColour)
: run.mStyle->mNormalColour; : run.mStyle->mNormalColour;
glyphStream.reset(static_cast<float>(section.mRect.left + line.mRect.left + run.mLeft), mGlyphStream.reset(static_cast<float>(section.mRect.left + line.mRect.left + run.mLeft),
static_cast<float>(line.mRect.top), colour); static_cast<float>(line.mRect.top), colour);
Utf8Stream stream(run.mRange); Utf8Stream stream(run.mRange);
@ -1219,9 +1219,9 @@ namespace MWGui
continue; continue;
if (!ucsSpace(codePoint)) if (!ucsSpace(codePoint))
glyphStream.emitGlyph(codePoint); mGlyphStream.emitGlyph(codePoint);
else else
glyphStream.emitSpace(codePoint); mGlyphStream.emitSpace(codePoint);
} }
} }
}; };

18
apps/openmw/mwgui/journalviewmodel.cpp
View file

@ -75,11 +75,11 @@ namespace MWGui
{ {
typedef t_iterator iterator_t; typedef t_iterator iterator_t;
iterator_t itr; iterator_t mItr;
JournalViewModelImpl const* mModel; JournalViewModelImpl const* mModel;
BaseEntry(JournalViewModelImpl const* model, iterator_t itr) BaseEntry(JournalViewModelImpl const* model, iterator_t itr)
: itr(itr) : mItr(itr)
, mModel(model) , mModel(model)
, loaded(false) , loaded(false)
{ {
@ -235,7 +235,7 @@ namespace MWGui
template <typename iterator_t> template <typename iterator_t>
struct JournalEntryImpl : BaseEntry<iterator_t, JournalEntry> struct JournalEntryImpl : BaseEntry<iterator_t, JournalEntry>
{ {
using BaseEntry<iterator_t, JournalEntry>::itr; using BaseEntry<iterator_t, JournalEntry>::mItr;
mutable std::string timestamp_buffer; mutable std::string timestamp_buffer;
@ -244,7 +244,7 @@ namespace MWGui
{ {
} }
std::string getText() const override { return itr->getText(); } std::string getText() const override { return mItr->getText(); }
Utf8Span timestamp() const override Utf8Span timestamp() const override
{ {
@ -254,9 +254,9 @@ namespace MWGui
std::ostringstream os; std::ostringstream os;
os << itr->mDayOfMonth << ' ' os << mItr->mDayOfMonth << ' '
<< MWBase::Environment::get().getWorld()->getTimeManager()->getMonthName(itr->mMonth) << " (" << MWBase::Environment::get().getWorld()->getTimeManager()->getMonthName(mItr->mMonth) << " ("
<< dayStr << " " << (itr->mDay) << ')'; << dayStr << " " << (mItr->mDay) << ')';
timestamp_buffer = os.str(); timestamp_buffer = os.str();
} }
@ -334,9 +334,9 @@ namespace MWGui
{ {
} }
std::string getText() const override { return itr->getText(); } std::string getText() const override { return mItr->getText(); }
Utf8Span source() const override { return toUtf8Span(itr->mActorName); } Utf8Span source() const override { return toUtf8Span(mItr->mActorName); }
}; };
void visitTopicEntries(TopicId topicId, std::function<void(TopicEntry const&)> visitor) const override void visitTopicEntries(TopicId topicId, std::function<void(TopicEntry const&)> visitor) const override

4
apps/openmw/mwgui/postprocessorhud.cpp
View file

@ -465,11 +465,11 @@ namespace MWGui
} }
} }
auto tryFocus = [this](ListWrapper* widget, const std::string& hint) { auto tryFocus = [this](ListWrapper* widget, const std::string& focusHint) {
MyGUI::Widget* oldFocus = MyGUI::InputManager::getInstance().getKeyFocusWidget(); MyGUI::Widget* oldFocus = MyGUI::InputManager::getInstance().getKeyFocusWidget();
if (oldFocus == mFilter) if (oldFocus == mFilter)
return; return;
size_t index = widget->findItemIndexWith(hint); size_t index = widget->findItemIndexWith(focusHint);
if (index != MyGUI::ITEM_NONE) if (index != MyGUI::ITEM_NONE)
{ {

4
apps/openmw/mwgui/quickkeysmenu.cpp
View file

@ -626,8 +626,8 @@ namespace MWGui
MWWorld::Ptr player = MWMechanics::getPlayer(); MWWorld::Ptr player = MWMechanics::getPlayer();
MWWorld::InventoryStore& store = player.getClass().getInventoryStore(player); MWWorld::InventoryStore& store = player.getClass().getInventoryStore(player);
auto assign = [this](auto type, MWWorld::Ptr item) { auto assign = [this](ESM::QuickKeys::Type keyType, MWWorld::Ptr item) {
if (type == ESM::QuickKeys::Type::Item) if (keyType == ESM::QuickKeys::Type::Item)
assignItem(item); assignItem(item);
else // if (quickKey.mType == ESM::QuickKeys::Type::MagicItem) else // if (quickKey.mType == ESM::QuickKeys::Type::MagicItem)
onAssignMagicItem(item); onAssignMagicItem(item);

8
apps/openmw/mwlua/inputbindings.cpp
View file

@ -84,7 +84,7 @@ namespace MWLua
inputActions[sol::meta_function::index] inputActions[sol::meta_function::index]
= [](LuaUtil::InputAction::Registry& registry, std::string_view key) { return registry[key]; }; = [](LuaUtil::InputAction::Registry& registry, std::string_view key) { return registry[key]; };
{ {
auto pairs = [](LuaUtil::InputAction::Registry& registry) { auto pairs = [](LuaUtil::InputAction::Registry& self) {
auto next = [](LuaUtil::InputAction::Registry& registry, std::string_view key) auto next = [](LuaUtil::InputAction::Registry& registry, std::string_view key)
-> sol::optional<std::tuple<std::string, LuaUtil::InputAction::Info>> { -> sol::optional<std::tuple<std::string, LuaUtil::InputAction::Info>> {
std::optional<std::string> nextKey(registry.nextKey(key)); std::optional<std::string> nextKey(registry.nextKey(key));
@ -93,7 +93,7 @@ namespace MWLua
else else
return std::make_tuple(*nextKey, registry[*nextKey].value()); return std::make_tuple(*nextKey, registry[*nextKey].value());
}; };
return std::make_tuple(next, registry, registry.firstKey()); return std::make_tuple(next, self, self.firstKey());
}; };
inputActions[sol::meta_function::pairs] = pairs; inputActions[sol::meta_function::pairs] = pairs;
} }
@ -122,7 +122,7 @@ namespace MWLua
inputTriggers[sol::meta_function::index] inputTriggers[sol::meta_function::index]
= [](LuaUtil::InputTrigger::Registry& registry, std::string_view key) { return registry[key]; }; = [](LuaUtil::InputTrigger::Registry& registry, std::string_view key) { return registry[key]; };
{ {
auto pairs = [](LuaUtil::InputTrigger::Registry& registry) { auto pairs = [](LuaUtil::InputTrigger::Registry& self) {
auto next = [](LuaUtil::InputTrigger::Registry& registry, std::string_view key) auto next = [](LuaUtil::InputTrigger::Registry& registry, std::string_view key)
-> sol::optional<std::tuple<std::string, LuaUtil::InputTrigger::Info>> { -> sol::optional<std::tuple<std::string, LuaUtil::InputTrigger::Info>> {
std::optional<std::string> nextKey(registry.nextKey(key)); std::optional<std::string> nextKey(registry.nextKey(key));
@ -131,7 +131,7 @@ namespace MWLua
else else
return std::make_tuple(*nextKey, registry[*nextKey].value()); return std::make_tuple(*nextKey, registry[*nextKey].value());
}; };
return std::make_tuple(next, registry, registry.firstKey()); return std::make_tuple(next, self, self.firstKey());
}; };
inputTriggers[sol::meta_function::pairs] = pairs; inputTriggers[sol::meta_function::pairs] = pairs;
} }

183
apps/openmw/mwlua/magicbindings.cpp
View file

@ -214,18 +214,18 @@ namespace MWLua
sol::table initCoreMagicBindings(const Context& context) sol::table initCoreMagicBindings(const Context& context)
{ {
sol::state_view lua = context.sol(); sol::state_view state = context.sol();
sol::table magicApi(lua, sol::create); sol::table magicApi(state, sol::create);
// Constants // Constants
magicApi["RANGE"] = LuaUtil::makeStrictReadOnly(LuaUtil::tableFromPairs<std::string_view, ESM::RangeType>(lua, magicApi["RANGE"] = LuaUtil::makeStrictReadOnly(LuaUtil::tableFromPairs<std::string_view, ESM::RangeType>(state,
{ {
{ "Self", ESM::RT_Self }, { "Self", ESM::RT_Self },
{ "Touch", ESM::RT_Touch }, { "Touch", ESM::RT_Touch },
{ "Target", ESM::RT_Target }, { "Target", ESM::RT_Target },
})); }));
magicApi["SPELL_TYPE"] magicApi["SPELL_TYPE"]
= LuaUtil::makeStrictReadOnly(LuaUtil::tableFromPairs<std::string_view, ESM::Spell::SpellType>(lua, = LuaUtil::makeStrictReadOnly(LuaUtil::tableFromPairs<std::string_view, ESM::Spell::SpellType>(state,
{ {
{ "Spell", ESM::Spell::ST_Spell }, { "Spell", ESM::Spell::ST_Spell },
{ "Ability", ESM::Spell::ST_Ability }, { "Ability", ESM::Spell::ST_Ability },
@ -235,7 +235,7 @@ namespace MWLua
{ "Power", ESM::Spell::ST_Power }, { "Power", ESM::Spell::ST_Power },
})); }));
magicApi["ENCHANTMENT_TYPE"] magicApi["ENCHANTMENT_TYPE"]
= LuaUtil::makeStrictReadOnly(LuaUtil::tableFromPairs<std::string_view, ESM::Enchantment::Type>(lua, = LuaUtil::makeStrictReadOnly(LuaUtil::tableFromPairs<std::string_view, ESM::Enchantment::Type>(state,
{ {
{ "CastOnce", ESM::Enchantment::Type::CastOnce }, { "CastOnce", ESM::Enchantment::Type::CastOnce },
{ "CastOnStrike", ESM::Enchantment::Type::WhenStrikes }, { "CastOnStrike", ESM::Enchantment::Type::WhenStrikes },
@ -243,7 +243,7 @@ namespace MWLua
{ "ConstantEffect", ESM::Enchantment::Type::ConstantEffect }, { "ConstantEffect", ESM::Enchantment::Type::ConstantEffect },
})); }));
sol::table effect(lua, sol::create); sol::table effect(state, sol::create);
magicApi["EFFECT_TYPE"] = LuaUtil::makeStrictReadOnly(effect); magicApi["EFFECT_TYPE"] = LuaUtil::makeStrictReadOnly(effect);
for (const auto& name : ESM::MagicEffect::sIndexNames) for (const auto& name : ESM::MagicEffect::sIndexNames)
{ {
@ -251,22 +251,22 @@ namespace MWLua
} }
// Spell store // Spell store
sol::table spells(lua, sol::create); sol::table spells(state, sol::create);
addRecordFunctionBinding<ESM::Spell>(spells, context); addRecordFunctionBinding<ESM::Spell>(spells, context);
magicApi["spells"] = LuaUtil::makeReadOnly(spells); magicApi["spells"] = LuaUtil::makeReadOnly(spells);
// Enchantment store // Enchantment store
sol::table enchantments(lua, sol::create); sol::table enchantments(state, sol::create);
addRecordFunctionBinding<ESM::Enchantment>(enchantments, context); addRecordFunctionBinding<ESM::Enchantment>(enchantments, context);
magicApi["enchantments"] = LuaUtil::makeReadOnly(enchantments); magicApi["enchantments"] = LuaUtil::makeReadOnly(enchantments);
// MagicEffect store // MagicEffect store
sol::table magicEffects(lua, sol::create); sol::table magicEffects(state, sol::create);
magicApi["effects"] = LuaUtil::makeReadOnly(magicEffects); magicApi["effects"] = LuaUtil::makeReadOnly(magicEffects);
using MagicEffectStore = MWWorld::Store<ESM::MagicEffect>; using MagicEffectStore = MWWorld::Store<ESM::MagicEffect>;
const MagicEffectStore* magicEffectStore const MagicEffectStore* magicEffectStore
= &MWBase::Environment::get().getWorld()->getStore().get<ESM::MagicEffect>(); = &MWBase::Environment::get().getWorld()->getStore().get<ESM::MagicEffect>();
auto magicEffectStoreT = lua.new_usertype<MagicEffectStore>("ESM3_MagicEffectStore"); auto magicEffectStoreT = state.new_usertype<MagicEffectStore>("ESM3_MagicEffectStore");
magicEffectStoreT[sol::meta_function::to_string] = [](const MagicEffectStore& store) { magicEffectStoreT[sol::meta_function::to_string] = [](const MagicEffectStore& store) {
return "ESM3_MagicEffectStore{" + std::to_string(store.getSize()) + " effects}"; return "ESM3_MagicEffectStore{" + std::to_string(store.getSize()) + " effects}";
}; };
@ -276,7 +276,7 @@ namespace MWLua
int index = ESM::MagicEffect::indexNameToIndex(id); int index = ESM::MagicEffect::indexNameToIndex(id);
return store.search(index); return store.search(index);
}); });
auto magicEffectsIter = [magicEffectStore](sol::this_state lua, const sol::object& /*store*/, auto magicEffectsIter = [magicEffectStore](sol::this_state thisState, const sol::object& /*store*/,
sol::optional<int> id) -> std::tuple<sol::object, sol::object> { sol::optional<int> id) -> std::tuple<sol::object, sol::object> {
MagicEffectStore::iterator iter; MagicEffectStore::iterator iter;
if (id.has_value()) if (id.has_value())
@ -288,19 +288,20 @@ namespace MWLua
else else
iter = magicEffectStore->begin(); iter = magicEffectStore->begin();
if (iter != magicEffectStore->end()) if (iter != magicEffectStore->end())
return std::make_tuple(sol::make_object(lua, iter->first), sol::make_object(lua, &iter->second)); return std::make_tuple(
sol::make_object(thisState, iter->first), sol::make_object(thisState, &iter->second));
else else
return std::make_tuple(sol::nil, sol::nil); return std::make_tuple(sol::nil, sol::nil);
}; };
magicEffectStoreT[sol::meta_function::pairs] magicEffectStoreT[sol::meta_function::pairs]
= [iter = sol::make_object(lua, magicEffectsIter)] { return iter; }; = [iter = sol::make_object(state, magicEffectsIter)] { return iter; };
magicEffectStoreT[sol::meta_function::ipairs] magicEffectStoreT[sol::meta_function::ipairs]
= [iter = sol::make_object(lua, magicEffectsIter)] { return iter; }; = [iter = sol::make_object(state, magicEffectsIter)] { return iter; };
magicEffects["records"] = magicEffectStore; magicEffects["records"] = magicEffectStore;
// Spell record // Spell record
auto spellT = lua.new_usertype<ESM::Spell>("ESM3_Spell"); auto spellT = state.new_usertype<ESM::Spell>("ESM3_Spell");
spellT[sol::meta_function::to_string] spellT[sol::meta_function::to_string]
= [](const ESM::Spell& rec) -> std::string { return "ESM3_Spell[" + rec.mId.toDebugString() + "]"; }; = [](const ESM::Spell& rec) -> std::string { return "ESM3_Spell[" + rec.mId.toDebugString() + "]"; };
spellT["id"] = sol::readonly_property([](const ESM::Spell& rec) { return rec.mId.serializeText(); }); spellT["id"] = sol::readonly_property([](const ESM::Spell& rec) { return rec.mId.serializeText(); });
@ -313,12 +314,12 @@ namespace MWLua
[](const ESM::Spell& rec) -> bool { return !!(rec.mData.mFlags & ESM::Spell::F_PCStart); }); [](const ESM::Spell& rec) -> bool { return !!(rec.mData.mFlags & ESM::Spell::F_PCStart); });
spellT["autocalcFlag"] = sol::readonly_property( spellT["autocalcFlag"] = sol::readonly_property(
[](const ESM::Spell& rec) -> bool { return !!(rec.mData.mFlags & ESM::Spell::F_Autocalc); }); [](const ESM::Spell& rec) -> bool { return !!(rec.mData.mFlags & ESM::Spell::F_Autocalc); });
spellT["effects"] = sol::readonly_property([lua = lua.lua_state()](const ESM::Spell& rec) -> sol::table { spellT["effects"] = sol::readonly_property([lua = state.lua_state()](const ESM::Spell& rec) -> sol::table {
return effectParamsListToTable(lua, rec.mEffects.mList); return effectParamsListToTable(lua, rec.mEffects.mList);
}); });
// Enchantment record // Enchantment record
auto enchantT = lua.new_usertype<ESM::Enchantment>("ESM3_Enchantment"); auto enchantT = state.new_usertype<ESM::Enchantment>("ESM3_Enchantment");
enchantT[sol::meta_function::to_string] = [](const ESM::Enchantment& rec) -> std::string { enchantT[sol::meta_function::to_string] = [](const ESM::Enchantment& rec) -> std::string {
return "ESM3_Enchantment[" + rec.mId.toDebugString() + "]"; return "ESM3_Enchantment[" + rec.mId.toDebugString() + "]";
}; };
@ -330,12 +331,12 @@ namespace MWLua
enchantT["charge"] enchantT["charge"]
= sol::readonly_property([](const ESM::Enchantment& rec) -> int { return rec.mData.mCharge; }); = sol::readonly_property([](const ESM::Enchantment& rec) -> int { return rec.mData.mCharge; });
enchantT["effects"] enchantT["effects"]
= sol::readonly_property([lua = lua.lua_state()](const ESM::Enchantment& rec) -> sol::table { = sol::readonly_property([lua = state.lua_state()](const ESM::Enchantment& rec) -> sol::table {
return effectParamsListToTable(lua, rec.mEffects.mList); return effectParamsListToTable(lua, rec.mEffects.mList);
}); });
// Effect params // Effect params
auto effectParamsT = lua.new_usertype<ESM::IndexedENAMstruct>("ESM3_EffectParams"); auto effectParamsT = state.new_usertype<ESM::IndexedENAMstruct>("ESM3_EffectParams");
effectParamsT[sol::meta_function::to_string] = [magicEffectStore](const ESM::IndexedENAMstruct& params) { effectParamsT[sol::meta_function::to_string] = [magicEffectStore](const ESM::IndexedENAMstruct& params) {
const ESM::MagicEffect* const rec = magicEffectStore->find(params.mData.mEffectID); const ESM::MagicEffect* const rec = magicEffectStore->find(params.mData.mEffectID);
return "ESM3_EffectParams[" + ESM::MagicEffect::indexToGmstString(rec->mIndex) + "]"; return "ESM3_EffectParams[" + ESM::MagicEffect::indexToGmstString(rec->mIndex) + "]";
@ -376,7 +377,7 @@ namespace MWLua
= sol::readonly_property([](const ESM::IndexedENAMstruct& params) -> int { return params.mIndex; }); = sol::readonly_property([](const ESM::IndexedENAMstruct& params) -> int { return params.mIndex; });
// MagicEffect record // MagicEffect record
auto magicEffectT = lua.new_usertype<ESM::MagicEffect>("ESM3_MagicEffect"); auto magicEffectT = state.new_usertype<ESM::MagicEffect>("ESM3_MagicEffect");
magicEffectT[sol::meta_function::to_string] = [](const ESM::MagicEffect& rec) { magicEffectT[sol::meta_function::to_string] = [](const ESM::MagicEffect& rec) {
return "ESM3_MagicEffect[" + ESM::MagicEffect::indexToGmstString(rec.mIndex) + "]"; return "ESM3_MagicEffect[" + ESM::MagicEffect::indexToGmstString(rec.mIndex) + "]";
@ -444,78 +445,78 @@ namespace MWLua
// magicEffectT["projectileSpeed"] // magicEffectT["projectileSpeed"]
// = sol::readonly_property([](const ESM::MagicEffect& rec) -> float { return rec.mData.mSpeed; }); // = sol::readonly_property([](const ESM::MagicEffect& rec) -> float { return rec.mData.mSpeed; });
auto activeSpellEffectT = lua.new_usertype<ESM::ActiveEffect>("ActiveSpellEffect"); auto activeSpellEffectT = state.new_usertype<ESM::ActiveEffect>("ActiveSpellEffect");
activeSpellEffectT[sol::meta_function::to_string] = [](const ESM::ActiveEffect& effect) { activeSpellEffectT[sol::meta_function::to_string] = [](const ESM::ActiveEffect& self) {
return "ActiveSpellEffect[" + ESM::MagicEffect::indexToGmstString(effect.mEffectId) + "]"; return "ActiveSpellEffect[" + ESM::MagicEffect::indexToGmstString(self.mEffectId) + "]";
}; };
activeSpellEffectT["id"] = sol::readonly_property([](const ESM::ActiveEffect& effect) -> std::string { activeSpellEffectT["id"] = sol::readonly_property([](const ESM::ActiveEffect& self) -> std::string {
auto name = ESM::MagicEffect::indexToName(effect.mEffectId); auto name = ESM::MagicEffect::indexToName(self.mEffectId);
return Misc::StringUtils::lowerCase(name); return Misc::StringUtils::lowerCase(name);
}); });
activeSpellEffectT["index"] activeSpellEffectT["index"]
= sol::readonly_property([](const ESM::ActiveEffect& effect) -> int { return effect.mEffectIndex; }); = sol::readonly_property([](const ESM::ActiveEffect& self) -> int { return self.mEffectIndex; });
activeSpellEffectT["name"] = sol::readonly_property([](const ESM::ActiveEffect& effect) -> std::string { activeSpellEffectT["name"] = sol::readonly_property([](const ESM::ActiveEffect& self) -> std::string {
return MWMechanics::EffectKey(effect.mEffectId, effect.getSkillOrAttribute()).toString(); return MWMechanics::EffectKey(self.mEffectId, self.getSkillOrAttribute()).toString();
}); });
activeSpellEffectT["affectedSkill"] activeSpellEffectT["affectedSkill"]
= sol::readonly_property([magicEffectStore](const ESM::ActiveEffect& effect) -> sol::optional<std::string> { = sol::readonly_property([magicEffectStore](const ESM::ActiveEffect& self) -> sol::optional<std::string> {
auto* rec = magicEffectStore->find(effect.mEffectId); auto* rec = magicEffectStore->find(self.mEffectId);
if (rec->mData.mFlags & ESM::MagicEffect::TargetSkill) if (rec->mData.mFlags & ESM::MagicEffect::TargetSkill)
return effect.getSkillOrAttribute().serializeText(); return self.getSkillOrAttribute().serializeText();
else else
return sol::nullopt; return sol::nullopt;
}); });
activeSpellEffectT["affectedAttribute"] activeSpellEffectT["affectedAttribute"]
= sol::readonly_property([magicEffectStore](const ESM::ActiveEffect& effect) -> sol::optional<std::string> { = sol::readonly_property([magicEffectStore](const ESM::ActiveEffect& self) -> sol::optional<std::string> {
auto* rec = magicEffectStore->find(effect.mEffectId); auto* rec = magicEffectStore->find(self.mEffectId);
if (rec->mData.mFlags & ESM::MagicEffect::TargetAttribute) if (rec->mData.mFlags & ESM::MagicEffect::TargetAttribute)
return effect.getSkillOrAttribute().serializeText(); return self.getSkillOrAttribute().serializeText();
else else
return sol::nullopt; return sol::nullopt;
}); });
activeSpellEffectT["magnitudeThisFrame"] activeSpellEffectT["magnitudeThisFrame"]
= sol::readonly_property([magicEffectStore](const ESM::ActiveEffect& effect) -> sol::optional<float> { = sol::readonly_property([magicEffectStore](const ESM::ActiveEffect& self) -> sol::optional<float> {
auto* rec = magicEffectStore->find(effect.mEffectId); auto* rec = magicEffectStore->find(self.mEffectId);
if (rec->mData.mFlags & ESM::MagicEffect::Flags::NoMagnitude) if (rec->mData.mFlags & ESM::MagicEffect::Flags::NoMagnitude)
return sol::nullopt; return sol::nullopt;
return effect.mMagnitude; return self.mMagnitude;
}); });
activeSpellEffectT["minMagnitude"] activeSpellEffectT["minMagnitude"]
= sol::readonly_property([magicEffectStore](const ESM::ActiveEffect& effect) -> sol::optional<float> { = sol::readonly_property([magicEffectStore](const ESM::ActiveEffect& self) -> sol::optional<float> {
auto* rec = magicEffectStore->find(effect.mEffectId); auto* rec = magicEffectStore->find(self.mEffectId);
if (rec->mData.mFlags & ESM::MagicEffect::Flags::NoMagnitude) if (rec->mData.mFlags & ESM::MagicEffect::Flags::NoMagnitude)
return sol::nullopt; return sol::nullopt;
return effect.mMinMagnitude; return self.mMinMagnitude;
}); });
activeSpellEffectT["maxMagnitude"] activeSpellEffectT["maxMagnitude"]
= sol::readonly_property([magicEffectStore](const ESM::ActiveEffect& effect) -> sol::optional<float> { = sol::readonly_property([magicEffectStore](const ESM::ActiveEffect& self) -> sol::optional<float> {
auto* rec = magicEffectStore->find(effect.mEffectId); auto* rec = magicEffectStore->find(self.mEffectId);
if (rec->mData.mFlags & ESM::MagicEffect::Flags::NoMagnitude) if (rec->mData.mFlags & ESM::MagicEffect::Flags::NoMagnitude)
return sol::nullopt; return sol::nullopt;
return effect.mMaxMagnitude; return self.mMaxMagnitude;
}); });
activeSpellEffectT["durationLeft"] activeSpellEffectT["durationLeft"]
= sol::readonly_property([magicEffectStore](const ESM::ActiveEffect& effect) -> sol::optional<float> { = sol::readonly_property([magicEffectStore](const ESM::ActiveEffect& self) -> sol::optional<float> {
// Permanent/constant effects, abilities, etc. will have a negative duration // Permanent/constant effects, abilities, etc. will have a negative duration
if (effect.mDuration < 0) if (self.mDuration < 0)
return sol::nullopt; return sol::nullopt;
auto* rec = magicEffectStore->find(effect.mEffectId); auto* rec = magicEffectStore->find(self.mEffectId);
if (rec->mData.mFlags & ESM::MagicEffect::Flags::NoDuration) if (rec->mData.mFlags & ESM::MagicEffect::Flags::NoDuration)
return sol::nullopt; return sol::nullopt;
return effect.mTimeLeft; return self.mTimeLeft;
}); });
activeSpellEffectT["duration"] activeSpellEffectT["duration"]
= sol::readonly_property([magicEffectStore](const ESM::ActiveEffect& effect) -> sol::optional<float> { = sol::readonly_property([magicEffectStore](const ESM::ActiveEffect& self) -> sol::optional<float> {
// Permanent/constant effects, abilities, etc. will have a negative duration // Permanent/constant effects, abilities, etc. will have a negative duration
if (effect.mDuration < 0) if (self.mDuration < 0)
return sol::nullopt; return sol::nullopt;
auto* rec = magicEffectStore->find(effect.mEffectId); auto* rec = magicEffectStore->find(self.mEffectId);
if (rec->mData.mFlags & ESM::MagicEffect::Flags::NoDuration) if (rec->mData.mFlags & ESM::MagicEffect::Flags::NoDuration)
return sol::nullopt; return sol::nullopt;
return effect.mDuration; return self.mDuration;
}); });
auto activeSpellT = lua.new_usertype<ActiveSpell>("ActiveSpellParams"); auto activeSpellT = state.new_usertype<ActiveSpell>("ActiveSpellParams");
activeSpellT[sol::meta_function::to_string] = [](const ActiveSpell& activeSpell) { activeSpellT[sol::meta_function::to_string] = [](const ActiveSpell& activeSpell) {
return "ActiveSpellParams[" + activeSpell.mParams.getSourceSpellId().serializeText() + "]"; return "ActiveSpellParams[" + activeSpell.mParams.getSourceSpellId().serializeText() + "]";
}; };
@ -525,7 +526,7 @@ namespace MWLua
return activeSpell.mParams.getSourceSpellId().serializeText(); return activeSpell.mParams.getSourceSpellId().serializeText();
}); });
activeSpellT["item"] activeSpellT["item"]
= sol::readonly_property([lua = lua.lua_state()](const ActiveSpell& activeSpell) -> sol::object { = sol::readonly_property([lua = state.lua_state()](const ActiveSpell& activeSpell) -> sol::object {
auto item = activeSpell.mParams.getItem(); auto item = activeSpell.mParams.getItem();
if (!item.isSet()) if (!item.isSet())
return sol::nil; return sol::nil;
@ -538,7 +539,7 @@ namespace MWLua
return sol::make_object(lua, LObject(itemPtr)); return sol::make_object(lua, LObject(itemPtr));
}); });
activeSpellT["caster"] activeSpellT["caster"]
= sol::readonly_property([lua = lua.lua_state()](const ActiveSpell& activeSpell) -> sol::object { = sol::readonly_property([lua = state.lua_state()](const ActiveSpell& activeSpell) -> sol::object {
auto caster = MWBase::Environment::get().getWorld()->searchPtrViaActorId( auto caster = MWBase::Environment::get().getWorld()->searchPtrViaActorId(
activeSpell.mParams.getCasterActorId()); activeSpell.mParams.getCasterActorId());
if (caster.isEmpty()) if (caster.isEmpty())
@ -552,14 +553,14 @@ namespace MWLua
} }
}); });
activeSpellT["effects"] activeSpellT["effects"]
= sol::readonly_property([lua = lua.lua_state()](const ActiveSpell& activeSpell) -> sol::table { = sol::readonly_property([lua = state.lua_state()](const ActiveSpell& activeSpell) -> sol::table {
sol::table res(lua, sol::create); sol::table res(lua, sol::create);
size_t tableIndex = 0; size_t tableIndex = 0;
for (const ESM::ActiveEffect& effect : activeSpell.mParams.getEffects()) for (const ESM::ActiveEffect& e : activeSpell.mParams.getEffects())
{ {
if (!(effect.mFlags & ESM::ActiveEffect::Flag_Applied)) if (!(e.mFlags & ESM::ActiveEffect::Flag_Applied))
continue; continue;
res[++tableIndex] = effect; // ESM::ActiveEffect (effect params) res[++tableIndex] = e; // ESM::ActiveEffect (effect params)
} }
return res; return res;
}); });
@ -579,39 +580,39 @@ namespace MWLua
return activeSpell.mParams.getActiveSpellId().serializeText(); return activeSpell.mParams.getActiveSpellId().serializeText();
}); });
auto activeEffectT = lua.new_usertype<ActiveEffect>("ActiveEffect"); auto activeEffectT = state.new_usertype<ActiveEffect>("ActiveEffect");
activeEffectT[sol::meta_function::to_string] = [](const ActiveEffect& effect) { activeEffectT[sol::meta_function::to_string] = [](const ActiveEffect& self) {
return "ActiveEffect[" + ESM::MagicEffect::indexToGmstString(effect.key.mId) + "]"; return "ActiveEffect[" + ESM::MagicEffect::indexToGmstString(self.key.mId) + "]";
}; };
activeEffectT["id"] = sol::readonly_property([](const ActiveEffect& effect) -> std::string { activeEffectT["id"] = sol::readonly_property([](const ActiveEffect& self) -> std::string {
auto name = ESM::MagicEffect::indexToName(effect.key.mId); auto name = ESM::MagicEffect::indexToName(self.key.mId);
return Misc::StringUtils::lowerCase(name); return Misc::StringUtils::lowerCase(name);
}); });
activeEffectT["name"] activeEffectT["name"]
= sol::readonly_property([](const ActiveEffect& effect) -> std::string { return effect.key.toString(); }); = sol::readonly_property([](const ActiveEffect& self) -> std::string { return self.key.toString(); });
activeEffectT["affectedSkill"] activeEffectT["affectedSkill"]
= sol::readonly_property([magicEffectStore](const ActiveEffect& effect) -> sol::optional<std::string> { = sol::readonly_property([magicEffectStore](const ActiveEffect& self) -> sol::optional<std::string> {
auto* rec = magicEffectStore->find(effect.key.mId); auto* rec = magicEffectStore->find(self.key.mId);
if (rec->mData.mFlags & ESM::MagicEffect::TargetSkill) if (rec->mData.mFlags & ESM::MagicEffect::TargetSkill)
return effect.key.mArg.serializeText(); return self.key.mArg.serializeText();
return sol::nullopt; return sol::nullopt;
}); });
activeEffectT["affectedAttribute"] activeEffectT["affectedAttribute"]
= sol::readonly_property([magicEffectStore](const ActiveEffect& effect) -> sol::optional<std::string> { = sol::readonly_property([magicEffectStore](const ActiveEffect& self) -> sol::optional<std::string> {
auto* rec = magicEffectStore->find(effect.key.mId); auto* rec = magicEffectStore->find(self.key.mId);
if (rec->mData.mFlags & ESM::MagicEffect::TargetAttribute) if (rec->mData.mFlags & ESM::MagicEffect::TargetAttribute)
return effect.key.mArg.serializeText(); return self.key.mArg.serializeText();
return sol::nullopt; return sol::nullopt;
}); });
activeEffectT["magnitude"] activeEffectT["magnitude"]
= sol::readonly_property([](const ActiveEffect& effect) { return effect.param.getMagnitude(); }); = sol::readonly_property([](const ActiveEffect& self) { return self.param.getMagnitude(); });
activeEffectT["magnitudeBase"] activeEffectT["magnitudeBase"]
= sol::readonly_property([](const ActiveEffect& effect) { return effect.param.getBase(); }); = sol::readonly_property([](const ActiveEffect& self) { return self.param.getBase(); });
activeEffectT["magnitudeModifier"] activeEffectT["magnitudeModifier"]
= sol::readonly_property([](const ActiveEffect& effect) { return effect.param.getModifier(); }); = sol::readonly_property([](const ActiveEffect& self) { return self.param.getModifier(); });
return LuaUtil::makeReadOnly(magicApi); return LuaUtil::makeReadOnly(magicApi);
} }
@ -633,10 +634,10 @@ namespace MWLua
const MWWorld::ESMStore& esmStore = *MWBase::Environment::get().getESMStore(); const MWWorld::ESMStore& esmStore = *MWBase::Environment::get().getESMStore();
auto getEffectsFromIndexes = [&](const ESM::EffectList& effects) { auto getEffectsFromIndexes = [&](const ESM::EffectList& effectList) {
std::vector<ESM::IndexedENAMstruct> enams; std::vector<ESM::IndexedENAMstruct> enams;
for (auto index : effectIndexes) for (auto index : effectIndexes)
enams.push_back(effects.mList.at(index)); enams.push_back(effectList.mList.at(index));
return enams; return enams;
}; };
@ -690,24 +691,24 @@ namespace MWLua
void addActorMagicBindings(sol::table& actor, const Context& context) void addActorMagicBindings(sol::table& actor, const Context& context)
{ {
auto lua = context.sol(); sol::state_view state = context.sol();
const MWWorld::Store<ESM::Spell>* spellStore const MWWorld::Store<ESM::Spell>* spellStore
= &MWBase::Environment::get().getWorld()->getStore().get<ESM::Spell>(); = &MWBase::Environment::get().getWorld()->getStore().get<ESM::Spell>();
// types.Actor.spells(o) // types.Actor.spells(o)
actor["spells"] = [](const sol::object& actor) { return ActorSpells{ actor }; }; actor["spells"] = [](const sol::object& object) { return ActorSpells{ object }; };
auto spellsT = lua.new_usertype<ActorSpells>("ActorSpells"); auto spellsT = state.new_usertype<ActorSpells>("ActorSpells");
spellsT[sol::meta_function::to_string] spellsT[sol::meta_function::to_string]
= [](const ActorSpells& spells) { return "ActorSpells[" + spells.mActor.object().toString() + "]"; }; = [](const ActorSpells& spells) { return "ActorSpells[" + spells.mActor.object().toString() + "]"; };
actor["activeSpells"] = [](const sol::object& actor) { return ActorActiveSpells{ actor }; }; actor["activeSpells"] = [](const sol::object& object) { return ActorActiveSpells{ object }; };
auto activeSpellsT = lua.new_usertype<ActorActiveSpells>("ActorActiveSpells"); auto activeSpellsT = state.new_usertype<ActorActiveSpells>("ActorActiveSpells");
activeSpellsT[sol::meta_function::to_string] = [](const ActorActiveSpells& spells) { activeSpellsT[sol::meta_function::to_string] = [](const ActorActiveSpells& spells) {
return "ActorActiveSpells[" + spells.mActor.object().toString() + "]"; return "ActorActiveSpells[" + spells.mActor.object().toString() + "]";
}; };
actor["activeEffects"] = [](const sol::object& actor) { return ActorActiveEffects{ actor }; }; actor["activeEffects"] = [](const sol::object& object) { return ActorActiveEffects{ object }; };
auto activeEffectsT = lua.new_usertype<ActorActiveEffects>("ActorActiveEffects"); auto activeEffectsT = state.new_usertype<ActorActiveEffects>("ActorActiveEffects");
activeEffectsT[sol::meta_function::to_string] = [](const ActorActiveEffects& effects) { activeEffectsT[sol::meta_function::to_string] = [](const ActorActiveEffects& effects) {
return "ActorActiveEffects[" + effects.mActor.object().toString() + "]"; return "ActorActiveEffects[" + effects.mActor.object().toString() + "]";
}; };
@ -741,15 +742,15 @@ namespace MWLua
throw std::runtime_error("Ability or disease can not be casted: " + spellId.toDebugString()); throw std::runtime_error("Ability or disease can not be casted: " + spellId.toDebugString());
} }
context.mLuaManager->addAction([obj = Object(ptr), spellId]() { context.mLuaManager->addAction([obj = Object(ptr), spellId]() {
const MWWorld::Ptr& ptr = obj.ptr(); const MWWorld::Ptr& objPtr = obj.ptr();
auto& stats = ptr.getClass().getCreatureStats(ptr); auto& stats = objPtr.getClass().getCreatureStats(objPtr);
// We need to deselect any enchant items before we can select a spell otherwise the item will be // We need to deselect any enchant items before we can select a spell otherwise the item will be
// reselected // reselected
const auto resetEnchantItem = [&]() { const auto resetEnchantItem = [&]() {
if (ptr.getClass().hasInventoryStore(ptr)) if (objPtr.getClass().hasInventoryStore(objPtr))
{ {
MWWorld::InventoryStore& inventory = ptr.getClass().getInventoryStore(ptr); MWWorld::InventoryStore& inventory = objPtr.getClass().getInventoryStore(objPtr);
inventory.setSelectedEnchantItem(inventory.end()); inventory.setSelectedEnchantItem(inventory.end());
} }
}; };
@ -757,7 +758,7 @@ namespace MWLua
if (spellId.empty()) if (spellId.empty())
{ {
resetEnchantItem(); resetEnchantItem();
if (ptr == MWBase::Environment::get().getWorld()->getPlayerPtr()) if (objPtr == MWBase::Environment::get().getWorld()->getPlayerPtr())
MWBase::Environment::get().getWindowManager()->unsetSelectedSpell(); MWBase::Environment::get().getWindowManager()->unsetSelectedSpell();
else else
stats.getSpells().setSelectedSpell(ESM::RefId()); stats.getSpells().setSelectedSpell(ESM::RefId());
@ -767,9 +768,9 @@ namespace MWLua
throw std::runtime_error("Actor doesn't know spell " + spellId.toDebugString()); throw std::runtime_error("Actor doesn't know spell " + spellId.toDebugString());
resetEnchantItem(); resetEnchantItem();
if (ptr == MWBase::Environment::get().getWorld()->getPlayerPtr()) if (objPtr == MWBase::Environment::get().getWorld()->getPlayerPtr())
{ {
int chance = MWMechanics::getSpellSuccessChance(spellId, ptr); int chance = MWMechanics::getSpellSuccessChance(spellId, objPtr);
MWBase::Environment::get().getWindowManager()->setSelectedSpell(spellId, chance); MWBase::Environment::get().getWindowManager()->setSelectedSpell(spellId, chance);
} }
else else
@ -821,10 +822,10 @@ namespace MWLua
}); });
// pairs(types.Actor.spells(o)) // pairs(types.Actor.spells(o))
spellsT[sol::meta_function::pairs] = lua["ipairsForArray"].template get<sol::function>(); spellsT[sol::meta_function::pairs] = state["ipairsForArray"].template get<sol::function>();
// ipairs(types.Actor.spells(o)) // ipairs(types.Actor.spells(o))
spellsT[sol::meta_function::ipairs] = lua["ipairsForArray"].template get<sol::function>(); spellsT[sol::meta_function::ipairs] = state["ipairsForArray"].template get<sol::function>();
// types.Actor.spells(o):add(id) // types.Actor.spells(o):add(id)
spellsT["add"] = [context](const ActorSpells& spells, const sol::object& spellOrId) { spellsT["add"] = [context](const ActorSpells& spells, const sol::object& spellOrId) {

18
apps/openmw/mwlua/menuscripts.cpp
View file

@ -81,16 +81,16 @@ namespace MWLua
manager->saveGame(description, slot); manager->saveGame(description, slot);
}; };
auto getSaves = [](sol::state_view lua, const MWState::Character& character) { auto getSaves = [](sol::state_view currentState, const MWState::Character& character) {
sol::table saves(lua, sol::create); sol::table saves(currentState, sol::create);
for (const MWState::Slot& slot : character) for (const MWState::Slot& slot : character)
{ {
sol::table slotInfo(lua, sol::create); sol::table slotInfo(currentState, sol::create);
slotInfo["description"] = slot.mProfile.mDescription; slotInfo["description"] = slot.mProfile.mDescription;
slotInfo["playerName"] = slot.mProfile.mPlayerName; slotInfo["playerName"] = slot.mProfile.mPlayerName;
slotInfo["playerLevel"] = slot.mProfile.mPlayerLevel; slotInfo["playerLevel"] = slot.mProfile.mPlayerLevel;
slotInfo["timePlayed"] = slot.mProfile.mTimePlayed; slotInfo["timePlayed"] = slot.mProfile.mTimePlayed;
sol::table contentFiles(lua, sol::create); sol::table contentFiles(currentState, sol::create);
for (size_t i = 0; i < slot.mProfile.mContentFiles.size(); ++i) for (size_t i = 0; i < slot.mProfile.mContentFiles.size(); ++i)
contentFiles[LuaUtil::toLuaIndex(i)] = Misc::StringUtils::lowerCase(slot.mProfile.mContentFiles[i]); contentFiles[LuaUtil::toLuaIndex(i)] = Misc::StringUtils::lowerCase(slot.mProfile.mContentFiles[i]);
@ -106,18 +106,18 @@ namespace MWLua
return saves; return saves;
}; };
api["getSaves"] = [getSaves](sol::this_state lua, std::string_view dir) -> sol::table { api["getSaves"] = [getSaves](sol::this_state thisState, std::string_view dir) -> sol::table {
const MWState::Character* character = findCharacter(dir); const MWState::Character* character = findCharacter(dir);
if (!character) if (!character)
throw std::runtime_error("Saves not found: " + std::string(dir)); throw std::runtime_error("Saves not found: " + std::string(dir));
return getSaves(lua, *character); return getSaves(thisState, *character);
}; };
api["getAllSaves"] = [getSaves](sol::this_state lua) -> sol::table { api["getAllSaves"] = [getSaves](sol::this_state thisState) -> sol::table {
sol::table saves(lua, sol::create); sol::table saves(thisState, sol::create);
MWBase::StateManager* manager = MWBase::Environment::get().getStateManager(); MWBase::StateManager* manager = MWBase::Environment::get().getStateManager();
for (auto it = manager->characterBegin(); it != manager->characterEnd(); ++it) for (auto it = manager->characterBegin(); it != manager->characterEnd(); ++it)
saves[it->getPath().filename().string()] = getSaves(lua, *it); saves[it->getPath().filename().string()] = getSaves(thisState, *it);
return saves; return saves;
}; };

12
apps/openmw/mwlua/objectbindings.cpp
View file

@ -445,16 +445,16 @@ namespace MWLua
if (!ptr.getContainerStore() && currentCount > countToRemove) if (!ptr.getContainerStore() && currentCount > countToRemove)
return std::nullopt; return std::nullopt;
// Delayed action to trigger side effects // Delayed action to trigger side effects
return [signedCountToRemove](MWWorld::Ptr ptr) { return [signedCountToRemove](MWWorld::Ptr p) {
// Restore the original count // Restore the original count
ptr.getCellRef().setCount(ptr.getCellRef().getCount(false) + signedCountToRemove); p.getCellRef().setCount(p.getCellRef().getCount(false) + signedCountToRemove);
// And now remove properly // And now remove properly
if (ptr.getContainerStore()) if (p.getContainerStore())
ptr.getContainerStore()->remove(ptr, std::abs(signedCountToRemove), false); p.getContainerStore()->remove(p, std::abs(signedCountToRemove), false);
else else
{ {
MWBase::Environment::get().getWorld()->disable(ptr); MWBase::Environment::get().getWorld()->disable(p);
MWBase::Environment::get().getWorld()->deleteObject(ptr); MWBase::Environment::get().getWorld()->deleteObject(p);
} }
}; };
}; };

102
apps/openmw/mwlua/postprocessingbindings.cpp
View file

@ -110,67 +110,69 @@ namespace MWLua
sol::state_view lua = context.sol(); sol::state_view lua = context.sol();
sol::table api(lua, sol::create); sol::table api(lua, sol::create);
sol::usertype<Shader> shader = lua.new_usertype<Shader>("Shader"); {
shader[sol::meta_function::to_string] = [](const Shader& shader) { return shader.toString(); }; sol::usertype<Shader> shader = lua.new_usertype<Shader>("Shader");
shader[sol::meta_function::to_string] = [](const Shader& self) { return self.toString(); };
shader["enable"] = [context](Shader& shader, sol::optional<int> optPos) { shader["enable"] = [context](Shader& self, sol::optional<int> optPos) {
std::optional<int> pos = std::nullopt; std::optional<int> pos = std::nullopt;
if (optPos) if (optPos)
pos = optPos.value(); pos = optPos.value();
if (shader.mShader && shader.mShader->isValid()) if (self.mShader && self.mShader->isValid())
shader.mQueuedAction = Shader::Action_Enable; self.mQueuedAction = Shader::Action_Enable;
context.mLuaManager->addAction([=, &shader] { context.mLuaManager->addAction([=, &self] {
shader.mQueuedAction = Shader::Action_None; self.mQueuedAction = Shader::Action_None;
if (MWBase::Environment::get().getWorld()->getPostProcessor()->enableTechnique(shader.mShader, pos) if (MWBase::Environment::get().getWorld()->getPostProcessor()->enableTechnique(self.mShader, pos)
== MWRender::PostProcessor::Status_Error) == MWRender::PostProcessor::Status_Error)
throw std::runtime_error("Failed enabling shader '" + shader.mShader->getName() + "'"); throw std::runtime_error("Failed enabling shader '" + self.mShader->getName() + "'");
}); });
}; };
shader["disable"] = [context](Shader& shader) { shader["disable"] = [context](Shader& self) {
shader.mQueuedAction = Shader::Action_Disable; self.mQueuedAction = Shader::Action_Disable;
context.mLuaManager->addAction([&] { context.mLuaManager->addAction([&] {
shader.mQueuedAction = Shader::Action_None; self.mQueuedAction = Shader::Action_None;
if (MWBase::Environment::get().getWorld()->getPostProcessor()->disableTechnique(shader.mShader) if (MWBase::Environment::get().getWorld()->getPostProcessor()->disableTechnique(self.mShader)
== MWRender::PostProcessor::Status_Error) == MWRender::PostProcessor::Status_Error)
throw std::runtime_error("Failed disabling shader '" + shader.mShader->getName() + "'"); throw std::runtime_error("Failed disabling shader '" + self.mShader->getName() + "'");
}); });
}; };
shader["isEnabled"] = [](const Shader& shader) { shader["isEnabled"] = [](const Shader& self) {
if (shader.mQueuedAction == Shader::Action_Enable) if (self.mQueuedAction == Shader::Action_Enable)
return true; return true;
else if (shader.mQueuedAction == Shader::Action_Disable) else if (self.mQueuedAction == Shader::Action_Disable)
return false; return false;
return MWBase::Environment::get().getWorld()->getPostProcessor()->isTechniqueEnabled(shader.mShader); return MWBase::Environment::get().getWorld()->getPostProcessor()->isTechniqueEnabled(self.mShader);
}; };
shader["name"] = sol::readonly_property( shader["name"] = sol::readonly_property(
[](const Shader& shader) { return getLocalizedMyGUIString(shader.mShader->getName()); }); [](const Shader& self) { return getLocalizedMyGUIString(self.mShader->getName()); });
shader["author"] = sol::readonly_property( shader["author"] = sol::readonly_property(
[](const Shader& shader) { return getLocalizedMyGUIString(shader.mShader->getAuthor()); }); [](const Shader& self) { return getLocalizedMyGUIString(self.mShader->getAuthor()); });
shader["description"] = sol::readonly_property( shader["description"] = sol::readonly_property(
[](const Shader& shader) { return getLocalizedMyGUIString(shader.mShader->getDescription()); }); [](const Shader& self) { return getLocalizedMyGUIString(self.mShader->getDescription()); });
shader["version"] = sol::readonly_property( shader["version"] = sol::readonly_property(
[](const Shader& shader) { return getLocalizedMyGUIString(shader.mShader->getVersion()); }); [](const Shader& self) { return getLocalizedMyGUIString(self.mShader->getVersion()); });
shader["setBool"] = getSetter<bool>(context); shader["setBool"] = getSetter<bool>(context);
shader["setFloat"] = getSetter<float>(context); shader["setFloat"] = getSetter<float>(context);
shader["setInt"] = getSetter<int>(context); shader["setInt"] = getSetter<int>(context);
shader["setVector2"] = getSetter<osg::Vec2f>(context); shader["setVector2"] = getSetter<osg::Vec2f>(context);
shader["setVector3"] = getSetter<osg::Vec3f>(context); shader["setVector3"] = getSetter<osg::Vec3f>(context);
shader["setVector4"] = getSetter<osg::Vec4f>(context); shader["setVector4"] = getSetter<osg::Vec4f>(context);
shader["setFloatArray"] = getArraySetter<float>(context); shader["setFloatArray"] = getArraySetter<float>(context);
shader["setIntArray"] = getArraySetter<int>(context); shader["setIntArray"] = getArraySetter<int>(context);
shader["setVector2Array"] = getArraySetter<osg::Vec2f>(context); shader["setVector2Array"] = getArraySetter<osg::Vec2f>(context);
shader["setVector3Array"] = getArraySetter<osg::Vec3f>(context); shader["setVector3Array"] = getArraySetter<osg::Vec3f>(context);
shader["setVector4Array"] = getArraySetter<osg::Vec4f>(context); shader["setVector4Array"] = getArraySetter<osg::Vec4f>(context);
}
api["load"] = [](const std::string& name) { api["load"] = [](const std::string& name) {
Shader shader{ MWBase::Environment::get().getWorld()->getPostProcessor()->loadTechnique(name, false) }; Shader shader{ MWBase::Environment::get().getWorld()->getPostProcessor()->loadTechnique(name, false) };

17
apps/openmw/mwlua/recordstore.hpp
View file

@ -47,18 +47,18 @@ namespace MWLua
using StoreT = MWWorld::Store<T>; using StoreT = MWWorld::Store<T>;
sol::state_view lua = context.sol(); sol::state_view lua = context.sol();
sol::usertype<StoreT> storeT = lua.new_usertype<StoreT>(recordName + "WorldStore"); sol::usertype<StoreT> storeT = lua.new_usertype<StoreT>(recordName + "WorldStore");
storeT[sol::meta_function::to_string] = [recordName](const StoreT& store) { storeT[sol::meta_function::to_string] = [recordName](const StoreT& self) {
return "{" + std::to_string(store.getSize()) + " " + recordName + " records}"; return "{" + std::to_string(self.getSize()) + " " + recordName + " records}";
}; };
storeT[sol::meta_function::length] = [](const StoreT& store) { return store.getSize(); }; storeT[sol::meta_function::length] = [](const StoreT& self) { return self.getSize(); };
storeT[sol::meta_function::index] = sol::overload( storeT[sol::meta_function::index] = sol::overload(
[](const StoreT& store, size_t index) -> const T* { [](const StoreT& self, size_t index) -> const T* {
if (index == 0 || index > store.getSize()) if (index == 0 || index > self.getSize())
return nullptr; return nullptr;
return store.at(LuaUtil::fromLuaIndex(index)); return self.at(LuaUtil::fromLuaIndex(index));
}, },
[](const StoreT& store, std::string_view id) -> const T* { [](const StoreT& self, std::string_view id) -> const T* {
return store.search(ESM::RefId::deserializeText(id)); return self.search(ESM::RefId::deserializeText(id));
}); });
storeT[sol::meta_function::ipairs] = lua["ipairsForArray"].template get<sol::function>(); storeT[sol::meta_function::ipairs] = lua["ipairsForArray"].template get<sol::function>();
storeT[sol::meta_function::pairs] = lua["ipairsForArray"].template get<sol::function>(); storeT[sol::meta_function::pairs] = lua["ipairsForArray"].template get<sol::function>();
@ -67,4 +67,5 @@ namespace MWLua
table["records"] = &store; table["records"] = &store;
} }
} }
#endif // MWLUA_RECORDSTORE_H #endif // MWLUA_RECORDSTORE_H

9
apps/openmw/mwlua/stats.cpp
View file

@ -107,8 +107,7 @@ namespace MWLua
sol::object get(const Context& context, ESM::StringRefId attributeId) const sol::object get(const Context& context, ESM::StringRefId attributeId) const
{ {
const auto& ptr = mObject.ptr(); if (!mObject.ptr().getClass().isNpc())
if (!ptr.getClass().isNpc())
return sol::nil; return sol::nil;
return getValue(context, mObject, &setNpcValue, attributeId, "skillIncreasesForAttribute", return getValue(context, mObject, &setNpcValue, attributeId, "skillIncreasesForAttribute",
@ -142,8 +141,7 @@ namespace MWLua
sol::object get(const Context& context, int specialization) const sol::object get(const Context& context, int specialization) const
{ {
const auto& ptr = mObject.ptr(); if (!mObject.ptr().getClass().isNpc())
if (!ptr.getClass().isNpc())
return sol::nil; return sol::nil;
return getValue(context, mObject, &setNpcValue, specialization, "skillIncreasesForSpecialization", return getValue(context, mObject, &setNpcValue, specialization, "skillIncreasesForSpecialization",
@ -192,8 +190,7 @@ namespace MWLua
sol::object getProgress(const Context& context) const sol::object getProgress(const Context& context) const
{ {
const auto& ptr = mObject.ptr(); if (!mObject.ptr().getClass().isNpc())
if (!ptr.getClass().isNpc())
return sol::nil; return sol::nil;
return getValue(context, mObject, &setNpcValue, std::monostate{}, "progress", return getValue(context, mObject, &setNpcValue, std::monostate{}, "progress",

32
apps/openmw/mwlua/types/actor.cpp
View file

@ -248,7 +248,7 @@ namespace MWLua
stats.setDrawState(newDrawState); stats.setDrawState(newDrawState);
}; };
actor["getSelectedEnchantedItem"] = [](sol::this_state lua, const Object& o) -> sol::object { actor["getSelectedEnchantedItem"] = [](sol::this_state thisState, const Object& o) -> sol::object {
const MWWorld::Ptr& ptr = o.ptr(); const MWWorld::Ptr& ptr = o.ptr();
if (!ptr.getClass().hasInventoryStore(ptr)) if (!ptr.getClass().hasInventoryStore(ptr))
return sol::nil; return sol::nil;
@ -258,9 +258,9 @@ namespace MWLua
return sol::nil; return sol::nil;
MWBase::Environment::get().getWorldModel()->registerPtr(*it); MWBase::Environment::get().getWorldModel()->registerPtr(*it);
if (dynamic_cast<const GObject*>(&o)) if (dynamic_cast<const GObject*>(&o))
return sol::make_object(lua, GObject(*it)); return sol::make_object(thisState, GObject(*it));
else else
return sol::make_object(lua, LObject(*it)); return sol::make_object(thisState, LObject(*it));
}; };
actor["setSelectedEnchantedItem"] = [context](const SelfObject& obj, const sol::object& item) { actor["setSelectedEnchantedItem"] = [context](const SelfObject& obj, const sol::object& item) {
const MWWorld::Ptr& ptr = obj.ptr(); const MWWorld::Ptr& ptr = obj.ptr();
@ -310,9 +310,9 @@ namespace MWLua
actor["inventory"] = sol::overload([](const LObject& o) { return Inventory<LObject>{ o }; }, actor["inventory"] = sol::overload([](const LObject& o) { return Inventory<LObject>{ o }; },
[](const GObject& o) { return Inventory<GObject>{ o }; }); [](const GObject& o) { return Inventory<GObject>{ o }; });
auto getAllEquipment = [](sol::this_state lua, const Object& o) { auto getAllEquipment = [](sol::this_state thisState, const Object& o) {
const MWWorld::Ptr& ptr = o.ptr(); const MWWorld::Ptr& ptr = o.ptr();
sol::table equipment(lua, sol::create); sol::table equipment(thisState, sol::create);
if (!ptr.getClass().hasInventoryStore(ptr)) if (!ptr.getClass().hasInventoryStore(ptr))
return equipment; return equipment;
@ -324,13 +324,13 @@ namespace MWLua
continue; continue;
MWBase::Environment::get().getWorldModel()->registerPtr(*it); MWBase::Environment::get().getWorldModel()->registerPtr(*it);
if (dynamic_cast<const GObject*>(&o)) if (dynamic_cast<const GObject*>(&o))
equipment[slot] = sol::make_object(lua, GObject(*it)); equipment[slot] = sol::make_object(thisState, GObject(*it));
else else
equipment[slot] = sol::make_object(lua, LObject(*it)); equipment[slot] = sol::make_object(thisState, LObject(*it));
} }
return equipment; return equipment;
}; };
auto getEquipmentFromSlot = [](sol::this_state lua, const Object& o, int slot) -> sol::object { auto getEquipmentFromSlot = [](sol::this_state thisState, const Object& o, int slot) -> sol::object {
const MWWorld::Ptr& ptr = o.ptr(); const MWWorld::Ptr& ptr = o.ptr();
if (!ptr.getClass().hasInventoryStore(ptr)) if (!ptr.getClass().hasInventoryStore(ptr))
return sol::nil; return sol::nil;
@ -340,9 +340,9 @@ namespace MWLua
return sol::nil; return sol::nil;
MWBase::Environment::get().getWorldModel()->registerPtr(*it); MWBase::Environment::get().getWorldModel()->registerPtr(*it);
if (dynamic_cast<const GObject*>(&o)) if (dynamic_cast<const GObject*>(&o))
return sol::make_object(lua, GObject(*it)); return sol::make_object(thisState, GObject(*it));
else else
return sol::make_object(lua, LObject(*it)); return sol::make_object(thisState, LObject(*it));
}; };
actor["getEquipment"] = sol::overload(getAllEquipment, getEquipmentFromSlot); actor["getEquipment"] = sol::overload(getAllEquipment, getEquipmentFromSlot);
actor["equipment"] = actor["getEquipment"]; // for compatibility; should be removed later actor["equipment"] = actor["getEquipment"]; // for compatibility; should be removed later
@ -373,10 +373,10 @@ namespace MWLua
context.mLuaManager->addAction( context.mLuaManager->addAction(
[obj = Object(ptr), eqp = std::move(eqp)] { setEquipment(obj.ptr(), eqp); }, "SetEquipmentAction"); [obj = Object(ptr), eqp = std::move(eqp)] { setEquipment(obj.ptr(), eqp); }, "SetEquipmentAction");
}; };
actor["getPathfindingAgentBounds"] = [](sol::this_state lua, const LObject& o) { actor["getPathfindingAgentBounds"] = [](sol::this_state thisState, const LObject& o) {
const DetourNavigator::AgentBounds agentBounds const DetourNavigator::AgentBounds agentBounds
= MWBase::Environment::get().getWorld()->getPathfindingAgentBounds(o.ptr()); = MWBase::Environment::get().getWorld()->getPathfindingAgentBounds(o.ptr());
sol::table result(lua, sol::create); sol::table result(thisState, sol::create);
result["shapeType"] = agentBounds.mShapeType; result["shapeType"] = agentBounds.mShapeType;
result["halfExtents"] = agentBounds.mHalfExtents; result["halfExtents"] = agentBounds.mHalfExtents;
return result; return result;
@ -410,13 +410,13 @@ namespace MWLua
return target.getClass().getCreatureStats(target).isDeathAnimationFinished(); return target.getClass().getCreatureStats(target).isDeathAnimationFinished();
}; };
actor["getEncumbrance"] = [](const Object& actor) -> float { actor["getEncumbrance"] = [](const Object& object) -> float {
const MWWorld::Ptr ptr = actor.ptr(); const MWWorld::Ptr ptr = object.ptr();
return ptr.getClass().getEncumbrance(ptr); return ptr.getClass().getEncumbrance(ptr);
}; };
actor["getCapacity"] = [](const Object& actor) -> float { actor["getCapacity"] = [](const Object& object) -> float {
const MWWorld::Ptr ptr = actor.ptr(); const MWWorld::Ptr ptr = object.ptr();
return ptr.getClass().getCapacity(ptr); return ptr.getClass().getCapacity(ptr);
}; };

3
apps/openmw/mwlua/types/book.cpp
View file

@ -120,8 +120,7 @@ namespace MWLua
record["enchantCapacity"] record["enchantCapacity"]
= sol::readonly_property([](const ESM::Book& rec) -> float { return rec.mData.mEnchant * 0.1f; }); = sol::readonly_property([](const ESM::Book& rec) -> float { return rec.mData.mEnchant * 0.1f; });
record["skill"] = sol::readonly_property([](const ESM::Book& rec) -> sol::optional<std::string> { record["skill"] = sol::readonly_property([](const ESM::Book& rec) -> sol::optional<std::string> {
ESM::RefId skill = ESM::Skill::indexToRefId(rec.mData.mSkillId); return LuaUtil::serializeRefId(ESM::Skill::indexToRefId(rec.mData.mSkillId));
return LuaUtil::serializeRefId(skill);
}); });
} }
} }

30
apps/openmw/mwlua/types/door.cpp
View file

@ -51,20 +51,20 @@ namespace MWLua
{ "Closing", MWWorld::DoorState::Closing }, { "Closing", MWWorld::DoorState::Closing },
})); }));
door["getDoorState"] = [](const Object& o) -> MWWorld::DoorState { door["getDoorState"] = [](const Object& o) -> MWWorld::DoorState {
const MWWorld::Ptr& door = doorPtr(o); const MWWorld::Ptr& ptr = doorPtr(o);
return door.getClass().getDoorState(door); return ptr.getClass().getDoorState(ptr);
}; };
door["isOpen"] = [](const Object& o) { door["isOpen"] = [](const Object& o) {
const MWWorld::Ptr& door = doorPtr(o); const MWWorld::Ptr& ptr = doorPtr(o);
bool doorIsIdle = door.getClass().getDoorState(door) == MWWorld::DoorState::Idle; bool doorIsIdle = ptr.getClass().getDoorState(ptr) == MWWorld::DoorState::Idle;
bool doorIsOpen = door.getRefData().getPosition().rot[2] != door.getCellRef().getPosition().rot[2]; bool doorIsOpen = ptr.getRefData().getPosition().rot[2] != ptr.getCellRef().getPosition().rot[2];
return doorIsIdle && doorIsOpen; return doorIsIdle && doorIsOpen;
}; };
door["isClosed"] = [](const Object& o) { door["isClosed"] = [](const Object& o) {
const MWWorld::Ptr& door = doorPtr(o); const MWWorld::Ptr& ptr = doorPtr(o);
bool doorIsIdle = door.getClass().getDoorState(door) == MWWorld::DoorState::Idle; bool doorIsIdle = ptr.getClass().getDoorState(ptr) == MWWorld::DoorState::Idle;
bool doorIsOpen = door.getRefData().getPosition().rot[2] != door.getCellRef().getPosition().rot[2]; bool doorIsOpen = ptr.getRefData().getPosition().rot[2] != ptr.getCellRef().getPosition().rot[2];
return doorIsIdle && !doorIsOpen; return doorIsIdle && !doorIsOpen;
}; };
@ -74,15 +74,15 @@ namespace MWLua
if (!allowChanges) if (!allowChanges)
throw std::runtime_error("Can only be used in global scripts or in local scripts on self."); throw std::runtime_error("Can only be used in global scripts or in local scripts on self.");
const MWWorld::Ptr& door = doorPtr(o); const MWWorld::Ptr& ptr = doorPtr(o);
auto world = MWBase::Environment::get().getWorld(); auto world = MWBase::Environment::get().getWorld();
if (!openState.has_value()) if (!openState.has_value())
world->activateDoor(door); world->activateDoor(ptr);
else if (*openState) else if (*openState)
world->activateDoor(door, MWWorld::DoorState::Opening); world->activateDoor(ptr, MWWorld::DoorState::Opening);
else else
world->activateDoor(door, MWWorld::DoorState::Closing); world->activateDoor(ptr, MWWorld::DoorState::Closing);
}; };
door["isTeleport"] = [](const Object& o) { return doorPtr(o).getCellRef().getTeleport(); }; door["isTeleport"] = [](const Object& o) { return doorPtr(o).getCellRef().getTeleport(); };
door["destPosition"] door["destPosition"]
@ -90,15 +90,15 @@ namespace MWLua
door["destRotation"] = [](const Object& o) -> LuaUtil::TransformQ { door["destRotation"] = [](const Object& o) -> LuaUtil::TransformQ {
return { Misc::Convert::makeOsgQuat(doorPtr(o).getCellRef().getDoorDest().rot) }; return { Misc::Convert::makeOsgQuat(doorPtr(o).getCellRef().getDoorDest().rot) };
}; };
door["destCell"] = [](sol::this_state lua, const Object& o) -> sol::object { door["destCell"] = [](sol::this_state thisState, const Object& o) -> sol::object {
const MWWorld::CellRef& cellRef = doorPtr(o).getCellRef(); const MWWorld::CellRef& cellRef = doorPtr(o).getCellRef();
if (!cellRef.getTeleport()) if (!cellRef.getTeleport())
return sol::nil; return sol::nil;
MWWorld::CellStore& cell = MWBase::Environment::get().getWorldModel()->getCell(cellRef.getDestCell()); MWWorld::CellStore& cell = MWBase::Environment::get().getWorldModel()->getCell(cellRef.getDestCell());
if (dynamic_cast<const GObject*>(&o)) if (dynamic_cast<const GObject*>(&o))
return sol::make_object(lua, GCell{ &cell }); return sol::make_object(thisState, GCell{ &cell });
else else
return sol::make_object(lua, LCell{ &cell }); return sol::make_object(thisState, LCell{ &cell });
}; };
addRecordFunctionBinding<ESM::Door>(door, context); addRecordFunctionBinding<ESM::Door>(door, context);

4
apps/openmw/mwlua/types/npc.cpp
View file

@ -466,10 +466,10 @@ namespace MWLua
ESM::RefId factionId = parseFactionId(faction); ESM::RefId factionId = parseFactionId(faction);
return ptr.getClass().getNpcStats(ptr).getExpelled(factionId); return ptr.getClass().getNpcStats(ptr).getExpelled(factionId);
}; };
npc["getFactions"] = [](sol::this_state lua, const Object& actor) { npc["getFactions"] = [](sol::this_state thisState, const Object& actor) {
const MWWorld::Ptr ptr = actor.ptr(); const MWWorld::Ptr ptr = actor.ptr();
MWMechanics::NpcStats& npcStats = ptr.getClass().getNpcStats(ptr); MWMechanics::NpcStats& npcStats = ptr.getClass().getNpcStats(ptr);
sol::table res(lua, sol::create); sol::table res(thisState, sol::create);
if (ptr == MWBase::Environment::get().getWorld()->getPlayerPtr()) if (ptr == MWBase::Environment::get().getWorld()->getPlayerPtr())
{ {
for (const auto& [factionId, _] : npcStats.getFactionRanks()) for (const auto& [factionId, _] : npcStats.getFactionRanks())

78
apps/openmw/mwlua/types/player.cpp
View file

@ -289,28 +289,28 @@ namespace MWLua
sol::state_view lua = context.sol(); sol::state_view lua = context.sol();
addJournalEntryBindings(player, lua, journal); addJournalEntryBindings(player, lua, journal);
player["quests"] = [](const Object& player) { player["quests"] = [](const Object& object) {
verifyPlayer(player); verifyPlayer(object);
bool allowChanges = dynamic_cast<const GObject*>(&player) != nullptr bool allowChanges = dynamic_cast<const GObject*>(&object) != nullptr
|| dynamic_cast<const SelfObject*>(&player) != nullptr; || dynamic_cast<const SelfObject*>(&object) != nullptr;
return Quests{ .mMutable = allowChanges }; return Quests{ .mMutable = allowChanges };
}; };
sol::usertype<Quests> quests = lua.new_usertype<Quests>("Quests"); sol::usertype<Quests> quests = lua.new_usertype<Quests>("Quests");
quests[sol::meta_function::to_string] = [](const Quests& quests) { return "Quests"; }; quests[sol::meta_function::to_string] = [](const Quests& /*self*/) { return "Quests"; };
quests[sol::meta_function::index] = [](const Quests& quests, std::string_view questId) -> sol::optional<Quest> { quests[sol::meta_function::index] = [](const Quests& self, std::string_view questId) -> sol::optional<Quest> {
ESM::RefId quest = ESM::RefId::deserializeText(questId); ESM::RefId quest = ESM::RefId::deserializeText(questId);
const ESM::Dialogue* dial = MWBase::Environment::get().getESMStore()->get<ESM::Dialogue>().search(quest); const ESM::Dialogue* dial = MWBase::Environment::get().getESMStore()->get<ESM::Dialogue>().search(quest);
if (dial == nullptr || dial->mType != ESM::Dialogue::Journal) if (dial == nullptr || dial->mType != ESM::Dialogue::Journal)
return sol::nullopt; return sol::nullopt;
return Quest{ .mQuestId = quest, .mMutable = quests.mMutable }; return Quest{ .mQuestId = quest, .mMutable = self.mMutable };
}; };
quests[sol::meta_function::pairs] = [journal](const Quests& quests) { quests[sol::meta_function::pairs] = [journal](const Quests& self) {
std::vector<ESM::RefId> ids; std::vector<ESM::RefId> ids;
for (auto it = journal->questBegin(); it != journal->questEnd(); ++it) for (auto it = journal->questBegin(); it != journal->questEnd(); ++it)
ids.push_back(it->first); ids.push_back(it->first);
size_t i = 0; size_t i = 0;
return [ids = std::move(ids), i, return [ids = std::move(ids), i,
allowChanges = quests.mMutable]() mutable -> sol::optional<std::tuple<std::string, Quest>> { allowChanges = self.mMutable]() mutable -> sol::optional<std::tuple<std::string, Quest>> {
if (i >= ids.size()) if (i >= ids.size())
return sol::nullopt; return sol::nullopt;
const ESM::RefId& id = ids[i++]; const ESM::RefId& id = ids[i++];
@ -320,19 +320,19 @@ namespace MWLua
sol::usertype<Quest> quest = lua.new_usertype<Quest>("Quest"); sol::usertype<Quest> quest = lua.new_usertype<Quest>("Quest");
quest[sol::meta_function::to_string] quest[sol::meta_function::to_string]
= [](const Quest& quest) { return "Quest[" + quest.mQuestId.serializeText() + "]"; }; = [](const Quest& self) { return "Quest[" + self.mQuestId.serializeText() + "]"; };
auto getQuestStage = [journal](const Quest& q) -> int { auto getQuestStage = [journal](const Quest& self) -> int {
const MWDialogue::Quest* quest = journal->getQuestOrNull(q.mQuestId); const MWDialogue::Quest* questPtr = journal->getQuestOrNull(self.mQuestId);
if (quest == nullptr) if (questPtr == nullptr)
return 0; return 0;
return journal->getJournalIndex(q.mQuestId); return journal->getJournalIndex(self.mQuestId);
}; };
auto setQuestStage = [context](const Quest& q, int stage) { auto setQuestStage = [context](const Quest& self, int stage) {
if (!q.mMutable) if (!self.mMutable)
throw std::runtime_error("Value can only be changed in global or player scripts!"); throw std::runtime_error("Value can only be changed in global or player scripts!");
context.mLuaManager->addAction( context.mLuaManager->addAction(
[q, stage] { MWBase::Environment::get().getJournal()->setJournalIndex(q.mQuestId, stage); }, [self, stage] { MWBase::Environment::get().getJournal()->setJournalIndex(self.mQuestId, stage); },
"setQuestStageAction"); "setQuestStageAction");
}; };
quest["stage"] = sol::property(getQuestStage, setQuestStage); quest["stage"] = sol::property(getQuestStage, setQuestStage);
@ -342,10 +342,10 @@ namespace MWLua
[journal](const Quest& q) { return journal->getQuestOrNull(q.mQuestId) != nullptr; }); [journal](const Quest& q) { return journal->getQuestOrNull(q.mQuestId) != nullptr; });
quest["finished"] = sol::property( quest["finished"] = sol::property(
[journal](const Quest& q) -> bool { [journal](const Quest& q) -> bool {
const MWDialogue::Quest* quest = journal->getQuestOrNull(q.mQuestId); const MWDialogue::Quest* questPtr = journal->getQuestOrNull(q.mQuestId);
if (quest == nullptr) if (questPtr == nullptr)
return false; return false;
return quest->isFinished(); return questPtr->isFinished();
}, },
[journal, context](const Quest& q, bool finished) { [journal, context](const Quest& q, bool finished) {
if (!q.mMutable) if (!q.mMutable)
@ -382,28 +382,28 @@ namespace MWLua
})); }));
MWBase::InputManager* input = MWBase::Environment::get().getInputManager(); MWBase::InputManager* input = MWBase::Environment::get().getInputManager();
player["getControlSwitch"] = [input](const Object& player, std::string_view key) { player["getControlSwitch"] = [input](const Object& object, std::string_view key) {
verifyPlayer(player); verifyPlayer(object);
return input->getControlSwitch(key); return input->getControlSwitch(key);
}; };
player["setControlSwitch"] = [input](const Object& player, std::string_view key, bool v) { player["setControlSwitch"] = [input](const Object& object, std::string_view key, bool v) {
verifyPlayer(player); verifyPlayer(object);
if (dynamic_cast<const LObject*>(&player) && !dynamic_cast<const SelfObject*>(&player)) if (dynamic_cast<const LObject*>(&object) && !dynamic_cast<const SelfObject*>(&object))
throw std::runtime_error("Only player and global scripts can toggle control switches."); throw std::runtime_error("Only player and global scripts can toggle control switches.");
input->toggleControlSwitch(key, v); input->toggleControlSwitch(key, v);
}; };
player["isTeleportingEnabled"] = [](const Object& player) -> bool { player["isTeleportingEnabled"] = [](const Object& object) -> bool {
verifyPlayer(player); verifyPlayer(object);
return MWBase::Environment::get().getWorld()->isTeleportingEnabled(); return MWBase::Environment::get().getWorld()->isTeleportingEnabled();
}; };
player["setTeleportingEnabled"] = [](const Object& player, bool state) { player["setTeleportingEnabled"] = [](const Object& object, bool state) {
verifyPlayer(player); verifyPlayer(object);
if (dynamic_cast<const LObject*>(&player) && !dynamic_cast<const SelfObject*>(&player)) if (dynamic_cast<const LObject*>(&object) && !dynamic_cast<const SelfObject*>(&object))
throw std::runtime_error("Only player and global scripts can toggle teleportation."); throw std::runtime_error("Only player and global scripts can toggle teleportation.");
MWBase::Environment::get().getWorld()->enableTeleporting(state); MWBase::Environment::get().getWorld()->enableTeleporting(state);
}; };
player["addTopic"] = [](const Object& player, std::string_view topicId) { player["addTopic"] = [](const Object& object, std::string_view topicId) {
verifyPlayer(player); verifyPlayer(object);
ESM::RefId topic = ESM::RefId::deserializeText(topicId); ESM::RefId topic = ESM::RefId::deserializeText(topicId);
const ESM::Dialogue* dialogueRecord const ESM::Dialogue* dialogueRecord
@ -418,8 +418,8 @@ namespace MWLua
MWBase::Environment::get().getDialogueManager()->addTopic(topic); MWBase::Environment::get().getDialogueManager()->addTopic(topic);
}; };
player["sendMenuEvent"] = [context](const Object& player, std::string eventName, const sol::object& eventData) { player["sendMenuEvent"] = [context](const Object& object, std::string eventName, const sol::object& eventData) {
verifyPlayer(player); verifyPlayer(object);
context.mLuaEvents->addMenuEvent({ std::move(eventName), LuaUtil::serialize(eventData) }); context.mLuaEvents->addMenuEvent({ std::move(eventName), LuaUtil::serialize(eventData) });
}; };
@ -471,13 +471,13 @@ namespace MWLua
}; };
player["birthSigns"] = initBirthSignRecordBindings(context); player["birthSigns"] = initBirthSignRecordBindings(context);
player["getBirthSign"] = [](const Object& player) -> std::string { player["getBirthSign"] = [](const Object& object) -> std::string {
verifyPlayer(player); verifyPlayer(object);
return MWBase::Environment::get().getWorld()->getPlayer().getBirthSign().serializeText(); return MWBase::Environment::get().getWorld()->getPlayer().getBirthSign().serializeText();
}; };
player["setBirthSign"] = [](const Object& player, const sol::object& recordOrId) { player["setBirthSign"] = [](const Object& object, const sol::object& recordOrId) {
verifyPlayer(player); verifyPlayer(object);
if (!dynamic_cast<const GObject*>(&player)) if (!dynamic_cast<const GObject*>(&object))
throw std::runtime_error("Only global scripts can change birth signs"); throw std::runtime_error("Only global scripts can change birth signs");
MWBase::Environment::get().getWorld()->getPlayer().setBirthSign(toBirthSignId(recordOrId)); MWBase::Environment::get().getWorld()->getPlayer().setBirthSign(toBirthSignId(recordOrId));
}; };

12
apps/openmw/mwlua/types/types.cpp
View file

@ -173,18 +173,18 @@ namespace MWLua
sol::table types(lua, sol::create); sol::table types(lua, sol::create);
auto addType = [&](std::string_view name, std::vector<ESM::RecNameInts> recTypes, auto addType = [&](std::string_view name, std::vector<ESM::RecNameInts> recTypes,
std::optional<std::string_view> base = std::nullopt) -> sol::table { std::optional<std::string_view> base = std::nullopt) -> sol::table {
sol::table t(lua, sol::create); sol::table table(lua, sol::create);
sol::table ro = LuaUtil::makeReadOnly(t); sol::table ro = LuaUtil::makeReadOnly(table);
sol::table meta = ro[sol::metatable_key]; sol::table meta = ro[sol::metatable_key];
meta[sol::meta_function::to_string] = [name]() { return name; }; meta[sol::meta_function::to_string] = [name]() { return name; };
if (base) if (base)
{ {
t["baseType"] = types[*base]; table["baseType"] = types[*base];
sol::table baseMeta(lua, sol::create); sol::table baseMeta(lua, sol::create);
baseMeta[sol::meta_function::index] = LuaUtil::getMutableFromReadOnly(types[*base]); baseMeta[sol::meta_function::index] = LuaUtil::getMutableFromReadOnly(types[*base]);
t[sol::metatable_key] = baseMeta; table[sol::metatable_key] = baseMeta;
} }
t["objectIsInstance"] = [types = recTypes](const Object& o) { table["objectIsInstance"] = [types = recTypes](const Object& o) {
unsigned int type = getLiveCellRefType(o.ptr().mRef); unsigned int type = getLiveCellRefType(o.ptr().mRef);
for (ESM::RecNameInts t : types) for (ESM::RecNameInts t : types)
if (t == type) if (t == type)
@ -192,7 +192,7 @@ namespace MWLua
return false; return false;
}; };
types[name] = ro; types[name] = ro;
return t; return table;
}; };
addActorBindings( addActorBindings(

26
apps/openmw/mwlua/uibindings.cpp
View file

@ -245,14 +245,14 @@ namespace MWLua
api["screenSize"] = []() { return osg::Vec2f(Settings::video().mResolutionX, Settings::video().mResolutionY); }; api["screenSize"] = []() { return osg::Vec2f(Settings::video().mResolutionX, Settings::video().mResolutionY); };
api["_getAllUiModes"] = [](sol::this_state lua) { api["_getAllUiModes"] = [](sol::this_state thisState) {
sol::table res(lua, sol::create); sol::table res(thisState, sol::create);
for (const auto& [_, name] : modeToName) for (const auto& [_, name] : modeToName)
res[name] = name; res[name] = name;
return res; return res;
}; };
api["_getUiModeStack"] = [windowManager](sol::this_state lua) { api["_getUiModeStack"] = [windowManager](sol::this_state thisState) {
sol::table res(lua, sol::create); sol::table res(thisState, sol::create);
int i = 1; int i = 1;
for (MWGui::GuiMode m : windowManager->getGuiModeStack()) for (MWGui::GuiMode m : windowManager->getGuiModeStack())
res[i++] = modeToName.at(m); res[i++] = modeToName.at(m);
@ -283,14 +283,14 @@ namespace MWLua
}, },
"Set UI modes"); "Set UI modes");
}; };
api["_getAllWindowIds"] = [windowManager](sol::this_state lua) { api["_getAllWindowIds"] = [windowManager](sol::this_state thisState) {
sol::table res(lua, sol::create); sol::table res(thisState, sol::create);
for (std::string_view name : windowManager->getAllWindowIds()) for (std::string_view name : windowManager->getAllWindowIds())
res[name] = name; res[name] = name;
return res; return res;
}; };
api["_getAllowedWindows"] = [windowManager](sol::this_state lua, std::string_view mode) { api["_getAllowedWindows"] = [windowManager](sol::this_state thisState, std::string_view mode) {
sol::table res(lua, sol::create); sol::table res(thisState, sol::create);
for (std::string_view name : windowManager->getAllowedWindowIds(nameToMode.at(mode))) for (std::string_view name : windowManager->getAllowedWindowIds(nameToMode.at(mode)))
res[name] = name; res[name] = name;
return res; return res;
@ -313,23 +313,23 @@ namespace MWLua
{ {
if (context.initializeOnce("openmw_ui_usertypes")) if (context.initializeOnce("openmw_ui_usertypes"))
{ {
auto element = context.sol().new_usertype<LuaUi::Element>("UiElement"); auto uiElement = context.sol().new_usertype<LuaUi::Element>("UiElement");
element[sol::meta_function::to_string] = [](const LuaUi::Element& element) { uiElement[sol::meta_function::to_string] = [](const LuaUi::Element& element) {
std::stringstream res; std::stringstream res;
res << "UiElement"; res << "UiElement";
if (element.mLayer != "") if (element.mLayer != "")
res << "[" << element.mLayer << "]"; res << "[" << element.mLayer << "]";
return res.str(); return res.str();
}; };
element["layout"] = sol::property([](const LuaUi::Element& element) { return element.mLayout; }, uiElement["layout"] = sol::property([](const LuaUi::Element& element) { return element.mLayout; },
[](LuaUi::Element& element, const sol::main_table& layout) { element.mLayout = layout; }); [](LuaUi::Element& element, const sol::main_table& layout) { element.mLayout = layout; });
element["update"] = [luaManager = context.mLuaManager](const std::shared_ptr<LuaUi::Element>& element) { uiElement["update"] = [luaManager = context.mLuaManager](const std::shared_ptr<LuaUi::Element>& element) {
if (element->mState != LuaUi::Element::Created) if (element->mState != LuaUi::Element::Created)
return; return;
element->mState = LuaUi::Element::Update; element->mState = LuaUi::Element::Update;
luaManager->addAction([element] { wrapAction(element, [&] { element->update(); }); }, "Update UI"); luaManager->addAction([element] { wrapAction(element, [&] { element->update(); }); }, "Update UI");
}; };
element["destroy"] = [luaManager = context.mLuaManager](const std::shared_ptr<LuaUi::Element>& element) { uiElement["destroy"] = [luaManager = context.mLuaManager](const std::shared_ptr<LuaUi::Element>& element) {
if (element->mState == LuaUi::Element::Destroyed) if (element->mState == LuaUi::Element::Destroyed)
return; return;
element->mState = LuaUi::Element::Destroy; element->mState = LuaUi::Element::Destroy;

14
apps/openmw/mwlua/vfsbindings.cpp
View file

@ -167,13 +167,13 @@ namespace MWLua
auto vfs = MWBase::Environment::get().getResourceSystem()->getVFS(); auto vfs = MWBase::Environment::get().getResourceSystem()->getVFS();
sol::usertype<FileHandle> handle = context.sol().new_usertype<FileHandle>("FileHandle"); sol::usertype<FileHandle> fileHandle = context.sol().new_usertype<FileHandle>("FileHandle");
handle["fileName"] fileHandle["fileName"]
= sol::readonly_property([](const FileHandle& self) -> std::string_view { return self.mFileName; }); = sol::readonly_property([](const FileHandle& self) -> std::string_view { return self.mFileName; });
handle[sol::meta_function::to_string] = [](const FileHandle& self) { fileHandle[sol::meta_function::to_string] = [](const FileHandle& self) {
return "FileHandle{'" + self.mFileName + "'" + (!self.mFilePtr ? ", closed" : "") + "}"; return "FileHandle{'" + self.mFileName + "'" + (!self.mFilePtr ? ", closed" : "") + "}";
}; };
handle["seek"] = sol::overload( fileHandle["seek"] = sol::overload(
[](sol::this_state lua, FileHandle& self, std::string_view whence, sol::optional<long> offset) { [](sol::this_state lua, FileHandle& self, std::string_view whence, sol::optional<long> offset) {
validateFile(self); validateFile(self);
@ -189,7 +189,7 @@ namespace MWLua
return seek(lua, self, std::ios_base::cur, off); return seek(lua, self, std::ios_base::cur, off);
}); });
handle["lines"] = [](sol::this_main_state lua, sol::main_object self) { fileHandle["lines"] = [](sol::this_main_state lua, sol::main_object self) {
if (!self.is<FileHandle*>()) if (!self.is<FileHandle*>())
throw std::runtime_error("self should be a file handle"); throw std::runtime_error("self should be a file handle");
return sol::as_function([lua, self]() -> sol::object { return sol::as_function([lua, self]() -> sol::object {
@ -212,7 +212,7 @@ namespace MWLua
}); });
}; };
handle["close"] = [](sol::this_state lua, FileHandle& self) { fileHandle["close"] = [](sol::this_state lua, FileHandle& self) {
sol::variadic_results values; sol::variadic_results values;
try try
{ {
@ -236,7 +236,7 @@ namespace MWLua
return values; return values;
}; };
handle["read"] = [](sol::this_state lua, FileHandle& self, const sol::variadic_args args) { fileHandle["read"] = [](sol::this_state lua, FileHandle& self, const sol::variadic_args args) {
validateFile(self); validateFile(self);
if (args.size() > sMaximumReadArguments) if (args.size() > sMaximumReadArguments)

2
apps/openmw/mwmechanics/mechanicsmanagerimp.cpp
View file

@ -157,7 +157,7 @@ namespace MWMechanics
int bonus = 0; int bonus = 0;
int index = ESM::Skill::refIdToIndex(skill.mId); int index = ESM::Skill::refIdToIndex(skill.mId);
auto bonusIt = std::find_if(race->mData.mBonus.begin(), race->mData.mBonus.end(), auto bonusIt = std::find_if(race->mData.mBonus.begin(), race->mData.mBonus.end(),
[&](const auto& bonus) { return bonus.mSkill == index; }); [&](const auto& v) { return v.mSkill == index; });
if (bonusIt != race->mData.mBonus.end()) if (bonusIt != race->mData.mBonus.end())
bonus = bonusIt->mBonus; bonus = bonusIt->mBonus;

6
apps/openmw/mwworld/esmstore.cpp
View file

@ -472,10 +472,10 @@ namespace MWWorld
{ {
if (listener != nullptr) if (listener != nullptr)
listener->setProgressRange(::EsmLoader::fileProgress); listener->setProgressRange(::EsmLoader::fileProgress);
auto visitorRec = [this, listener](ESM4::Reader& reader) { auto visitorRec = [this, listener](ESM4::Reader& r) {
bool result = ESMStoreImp::readRecord(reader, *this); bool result = ESMStoreImp::readRecord(r, *this);
if (listener != nullptr) if (listener != nullptr)
listener->setProgress(::EsmLoader::fileProgress * reader.getFileOffset() / reader.getFileSize()); listener->setProgress(::EsmLoader::fileProgress * r.getFileOffset() / r.getFileSize());
return result; return result;
}; };
ESM4::ReaderUtils::readAll(reader, visitorRec, [](ESM4::Reader&) {}); ESM4::ReaderUtils::readAll(reader, visitorRec, [](ESM4::Reader&) {});

10
apps/openmw/mwworld/manualref.cpp
View file

@ -8,9 +8,9 @@ namespace
{ {
template <typename T> template <typename T>
void create(const MWWorld::Store<T>& list, const ESM::RefId& name, std::any& refValue, MWWorld::Ptr& ptrValue) void create(const MWWorld::Store<T>& store, const ESM::RefId& name, std::any& refValue, MWWorld::Ptr& ptrValue)
{ {
const T* base = list.find(name); const T* base = store.find(name);
ESM::CellRef cellRef; ESM::CellRef cellRef;
cellRef.blank(); cellRef.blank();
@ -22,7 +22,7 @@ namespace
template <typename T> template <typename T>
void create( void create(
const MWWorld::Store<T>& list, const MWWorld::Ptr& templatePtr, std::any& refValue, MWWorld::Ptr& ptrValue) const MWWorld::Store<T>& /*store*/, const MWWorld::Ptr& templatePtr, std::any& refValue, MWWorld::Ptr& ptrValue)
{ {
refValue = *static_cast<MWWorld::LiveCellRef<T>*>(templatePtr.getBase()); refValue = *static_cast<MWWorld::LiveCellRef<T>*>(templatePtr.getBase());
ptrValue = MWWorld::Ptr(&std::any_cast<MWWorld::LiveCellRef<T>&>(refValue), nullptr); ptrValue = MWWorld::Ptr(&std::any_cast<MWWorld::LiveCellRef<T>&>(refValue), nullptr);
@ -92,7 +92,7 @@ namespace
MWWorld::ManualRef::ManualRef(const MWWorld::ESMStore& store, const ESM::RefId& name, const int count) MWWorld::ManualRef::ManualRef(const MWWorld::ESMStore& store, const ESM::RefId& name, const int count)
{ {
auto cb = [&](const auto& store) { create(store, name, mRef, mPtr); }; auto cb = [&](const auto& typedStore) { create(typedStore, name, mRef, mPtr); };
visitRefStore(store, name, cb); visitRefStore(store, name, cb);
mPtr.getCellRef().setCount(count); mPtr.getCellRef().setCount(count);
@ -100,7 +100,7 @@ MWWorld::ManualRef::ManualRef(const MWWorld::ESMStore& store, const ESM::RefId&
MWWorld::ManualRef::ManualRef(const ESMStore& store, const Ptr& template_, const int count) MWWorld::ManualRef::ManualRef(const ESMStore& store, const Ptr& template_, const int count)
{ {
auto cb = [&](const auto& store) { create(store, template_, mRef, mPtr); }; auto cb = [&](const auto& typedStore) { create(typedStore, template_, mRef, mPtr); };
visitRefStore(store, template_.getCellRef().getRefId(), cb); visitRefStore(store, template_.getCellRef().getRefId(), cb);
mPtr.getCellRef().setCount(count); mPtr.getCellRef().setCount(count);

14
apps/openmw/mwworld/scene.cpp
View file

@ -401,11 +401,11 @@ namespace MWWorld
mNavigator.removeWater(osg::Vec2i(cellX, cellY), navigatorUpdateGuard); mNavigator.removeWater(osg::Vec2i(cellX, cellY), navigatorUpdateGuard);
ESM::visit(ESM::VisitOverload{ ESM::visit(ESM::VisitOverload{
[&](const ESM::Cell& cell) { [&](const ESM::Cell& c) {
if (const auto pathgrid = mWorld.getStore().get<ESM::Pathgrid>().search(cell)) if (const auto pathgrid = mWorld.getStore().get<ESM::Pathgrid>().search(c))
mNavigator.removePathgrid(*pathgrid); mNavigator.removePathgrid(*pathgrid);
}, },
[&](const ESM4::Cell& cell) {}, [&](const ESM4::Cell& /*c*/) {},
}, },
*cell->getCell()); *cell->getCell());
@ -482,11 +482,11 @@ namespace MWWorld
} }
ESM::visit(ESM::VisitOverload{ ESM::visit(ESM::VisitOverload{
[&](const ESM::Cell& cell) { [&](const ESM::Cell& c) {
if (const auto pathgrid = mWorld.getStore().get<ESM::Pathgrid>().search(cell)) if (const auto pathgrid = mWorld.getStore().get<ESM::Pathgrid>().search(c))
mNavigator.addPathgrid(cell, *pathgrid); mNavigator.addPathgrid(c, *pathgrid);
}, },
[&](const ESM4::Cell& cell) {}, [&](const ESM4::Cell& /*c*/) {},
}, },
*cell.getCell()); *cell.getCell());

3
apps/wizard/mainwizard.cpp
View file

@ -335,8 +335,7 @@ void Wizard::MainWizard::addInstallation(const QString& path)
// Add it to the openmw.cfg too // Add it to the openmw.cfg too
const auto& dataDirs = mGameSettings.getDataDirs(); const auto& dataDirs = mGameSettings.getDataDirs();
if (std::none_of( if (std::none_of(dataDirs.begin(), dataDirs.end(), [&](const Config::SettingValue& d) { return d.value == path; }))
dataDirs.begin(), dataDirs.end(), [&](const Config::SettingValue& dir) { return dir.value == path; }))
{ {
mGameSettings.setMultiValue(QLatin1String("data"), { path }); mGameSettings.setMultiValue(QLatin1String("data"), { path });
mGameSettings.addDataDir({ path }); mGameSettings.addDataDir({ path });

14
apps/wizard/unshield/unshieldworker.cpp
View file

@ -361,9 +361,9 @@ bool Wizard::UnshieldWorker::installDirectories(
QStringList directories(findDirectories(dirName, path, recursive)); QStringList directories(findDirectories(dirName, path, recursive));
for (const QString& dir : directories) for (const QString& subDir : directories)
{ {
QFileInfo info(dir); QFileInfo info(subDir);
emit textChanged(tr("Installing: %1 directory").arg(info.fileName())); emit textChanged(tr("Installing: %1 directory").arg(info.fileName()));
if (!copyDirectory(info.absoluteFilePath(), getPath() + QDir::separator() + info.fileName(), keepSource)) if (!copyDirectory(info.absoluteFilePath(), getPath() + QDir::separator() + info.fileName(), keepSource))
return false; return false;
@ -769,15 +769,15 @@ bool Wizard::UnshieldWorker::installComponent(Component component, const QString
QStringList datafiles(findDirectories(QLatin1String("Data Files"), temp.absolutePath())); QStringList datafiles(findDirectories(QLatin1String("Data Files"), temp.absolutePath()));
datafiles.append(findDirectories(QLatin1String("Data Files"), info.absolutePath())); datafiles.append(findDirectories(QLatin1String("Data Files"), info.absolutePath()));
for (const QString& dir : datafiles) for (const QString& dataDir : datafiles)
{ {
QFileInfo info(dir); QFileInfo dataDirInfo(dataDir);
emit textChanged(tr("Installing: %1 directory").arg(info.fileName())); emit textChanged(tr("Installing: %1 directory").arg(dataDirInfo.fileName()));
if (!copyDirectory(info.absoluteFilePath(), getPath())) if (!copyDirectory(dataDirInfo.absoluteFilePath(), getPath()))
{ {
emit error(tr("Could not install directory!"), emit error(tr("Could not install directory!"),
tr("Installing %1 to %2 failed.").arg(info.absoluteFilePath(), getPath())); tr("Installing %1 to %2 failed.").arg(dataDirInfo.absoluteFilePath(), getPath()));
return false; return false;
} }
} }

4
components/CMakeLists.txt
View file

@ -324,6 +324,10 @@ add_component_dir (files
istreamptr streamwithbuffer istreamptr streamwithbuffer
) )
if(NOT CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND NOT CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
set_source_files_properties(files/configfileparser.cpp PROPERTIES COMPILE_FLAGS -Wno-shadow)
endif()
add_component_dir (compiler add_component_dir (compiler
context controlparser errorhandler exception exprparser extensions fileparser generator context controlparser errorhandler exception exprparser extensions fileparser generator
lineparser literals locals output parser scanner scriptparser skipparser streamerrorhandler lineparser literals locals output parser scanner scriptparser skipparser streamerrorhandler

4
components/compiler/scanner.hpp
View file

@ -209,7 +209,7 @@ namespace Compiler
bool mIgnoreSpecial; bool mIgnoreSpecial;
public: public:
enum keyword enum Keyword
{ {
K_begin, K_begin,
K_end, K_end,
@ -228,7 +228,7 @@ namespace Compiler
K_to K_to
}; };
enum special enum Special
{ {
S_newline, S_newline,
S_open, S_open,

12
components/detournavigator/asyncnavmeshupdater.cpp
View file

@ -316,7 +316,7 @@ namespace DetourNavigator
{ {
if (mPushed.emplace(agentBounds, changedTile).second) if (mPushed.emplace(agentBounds, changedTile).second)
{ {
const auto processTime = [&, changedTile = changedTile, changeType = changeType] { const std::chrono::steady_clock::time_point processTime = [&] {
if (changeType != ChangeType::update) if (changeType != ChangeType::update)
return std::chrono::steady_clock::time_point(); return std::chrono::steady_clock::time_point();
const auto lastUpdate = mLastUpdates.find(std::tie(agentBounds, changedTile)); const auto lastUpdate = mLastUpdates.find(std::tie(agentBounds, changedTile));
@ -947,11 +947,11 @@ namespace DetourNavigator
mNextTileId = TileId(mDb->getMaxTileId() + 1); mNextTileId = TileId(mDb->getMaxTileId() + 1);
Log(Debug::Info) << "Updated navmeshdb tile_id to: " << mNextTileId; Log(Debug::Info) << "Updated navmeshdb tile_id to: " << mNextTileId;
} }
catch (const std::exception& e) catch (const std::exception& exception)
{ {
mWriteToDb = false; mWriteToDb = false;
Log(Debug::Warning) Log(Debug::Warning) << "Failed to update next tile_id, writes to navmeshdb are disabled: "
<< "Failed to update next tile_id, writes to navmeshdb are disabled: " << e.what(); << exception.what();
} }
} }
} }
@ -960,12 +960,12 @@ namespace DetourNavigator
if (isWritingDbJob(*job)) if (isWritingDbJob(*job))
{ {
process([&](JobIt job) { processWritingJob(job); }); process([&](JobIt it) { processWritingJob(it); });
mUpdater.removeJob(job); mUpdater.removeJob(job);
return; return;
} }
process([&](JobIt job) { processReadingJob(job); }); process([&](JobIt it) { processReadingJob(it); });
job->mState = JobState::WithDbResult; job->mState = JobState::WithDbResult;
mUpdater.enqueueJob(job); mUpdater.enqueueJob(job);
} }

4
components/detournavigator/offmeshconnectionsmanager.cpp
View file

@ -77,8 +77,8 @@ namespace DetourNavigator
if (itByTilePosition == values->mByTilePosition.end()) if (itByTilePosition == values->mByTilePosition.end())
return result; return result;
std::for_each(itByTilePosition->second.begin(), itByTilePosition->second.end(), [&](const ObjectId v) { std::for_each(itByTilePosition->second.begin(), itByTilePosition->second.end(), [&](const ObjectId id) {
const auto byId = values->mById.equal_range(v); const auto byId = values->mById.equal_range(id);
std::for_each(byId.first, byId.second, [&](const auto& v) { std::for_each(byId.first, byId.second, [&](const auto& v) {
if (getTilePosition(mSettings, v.second.mStart) == tilePosition if (getTilePosition(mSettings, v.second.mStart) == tilePosition
|| getTilePosition(mSettings, v.second.mEnd) == tilePosition) || getTilePosition(mSettings, v.second.mEnd) == tilePosition)

2
components/detournavigator/recastmeshbuilder.cpp
View file

@ -237,7 +237,7 @@ namespace DetourNavigator
BulletHelpers::getHeightfieldShift(cellPosition.x(), cellPosition.y(), cellSize, minHeight, maxHeight)); BulletHelpers::getHeightfieldShift(cellPosition.x(), cellPosition.y(), cellSize, minHeight, maxHeight));
const float stepSize = getHeightfieldScale(cellSize, size); const float stepSize = getHeightfieldScale(cellSize, size);
const int halfCellSize = cellSize / 2; const int halfCellSize = cellSize / 2;
const auto local = [&](float v, float shift) { return (v - shift + halfCellSize) / stepSize; }; const auto local = [&](float v, float offset) { return (v - offset + halfCellSize) / stepSize; };
const auto index = [&](float v, int add) { return std::clamp<int>(static_cast<int>(v) + add, 0, size); }; const auto index = [&](float v, int add) { return std::clamp<int>(static_cast<int>(v) + add, 0, size); };
const std::size_t minX = index(std::round(local(intersection->mMin.x(), shift.x())), -1); const std::size_t minX = index(std::round(local(intersection->mMin.x(), shift.x())), -1);
const std::size_t minY = index(std::round(local(intersection->mMin.y(), shift.y())), -1); const std::size_t minY = index(std::round(local(intersection->mMin.y(), shift.y())), -1);

6
components/files/configurationmanager.cpp
View file

@ -475,11 +475,11 @@ namespace Files
return istream; return istream;
} }
PathContainer asPathContainer(const MaybeQuotedPathContainer& MaybeQuotedPathContainer) PathContainer asPathContainer(const MaybeQuotedPathContainer& value)
{ {
PathContainer res; PathContainer res;
res.reserve(MaybeQuotedPathContainer.size()); res.reserve(value.size());
for (const auto& maybeQuotedPath : MaybeQuotedPathContainer) for (const auto& maybeQuotedPath : value)
{ {
res.emplace_back(maybeQuotedPath.u8string()); // This call to u8string is redundant, but required to build res.emplace_back(maybeQuotedPath.u8string()); // This call to u8string is redundant, but required to build
// on MSVC 14.26 due to implementation bugs. // on MSVC 14.26 due to implementation bugs.

2
components/files/configurationmanager.hpp
View file

@ -97,7 +97,7 @@ namespace Files
typedef std::vector<MaybeQuotedPath> MaybeQuotedPathContainer; typedef std::vector<MaybeQuotedPath> MaybeQuotedPathContainer;
PathContainer asPathContainer(const MaybeQuotedPathContainer& MaybeQuotedPathContainer); PathContainer asPathContainer(const MaybeQuotedPathContainer& value);
} /* namespace Files */ } /* namespace Files */

8
components/lua/luastate.hpp
View file

@ -89,18 +89,18 @@ namespace LuaUtil
// Pushing to the stack from outside a Lua context crashes the engine if no memory can be allocated to grow the // Pushing to the stack from outside a Lua context crashes the engine if no memory can be allocated to grow the
// stack // stack
template <class Lambda> template <class Function>
[[nodiscard]] int invokeProtectedCall(Lambda&& f) const [[nodiscard]] int invokeProtectedCall(Function&& function) const
{ {
if (!lua_checkstack(mSol.lua_state(), 2)) if (!lua_checkstack(mSol.lua_state(), 2))
return LUA_ERRMEM; return LUA_ERRMEM;
lua_pushcfunction(mSol.lua_state(), [](lua_State* L) { lua_pushcfunction(mSol.lua_state(), [](lua_State* L) {
void* f = lua_touserdata(L, 1); void* f = lua_touserdata(L, 1);
LuaView view(L); LuaView view(L);
(*static_cast<Lambda*>(f))(view); (*static_cast<Function*>(f))(view);
return 0; return 0;
}); });
lua_pushlightuserdata(mSol.lua_state(), &f); lua_pushlightuserdata(mSol.lua_state(), &function);
return lua_pcall(mSol.lua_state(), 1, 0, 0); return lua_pcall(mSol.lua_state(), 1, 0, 0);
} }

6
components/lua/scriptscontainer.cpp
View file

@ -359,10 +359,10 @@ namespace LuaUtil
if (it == data.mEventHandlers.end()) if (it == data.mEventHandlers.end())
return; return;
mLua.protectedCall([&](LuaView& view) { mLua.protectedCall([&](LuaView& view) {
sol::object data; sol::object object;
try try
{ {
data = LuaUtil::deserialize(view.sol(), eventData, mSerializer); object = LuaUtil::deserialize(view.sol(), eventData, mSerializer);
} }
catch (std::exception& e) catch (std::exception& e)
{ {
@ -375,7 +375,7 @@ namespace LuaUtil
const Handler& h = list[i]; const Handler& h = list[i];
try try
{ {
sol::object res = LuaUtil::call({ this, h.mScriptId }, h.mFn, data); sol::object res = LuaUtil::call({ this, h.mScriptId }, h.mFn, object);
if (res.is<bool>() && !res.as<bool>()) if (res.is<bool>() && !res.as<bool>())
break; // Skip other handlers if 'false' was returned. break; // Skip other handlers if 'false' was returned.
} }

6
components/lua/utilpackage.cpp
View file

@ -394,12 +394,12 @@ namespace LuaUtil
} }
util["loadCode"] = [](const std::string& code, const sol::table& env, sol::this_state s) { util["loadCode"] = [](const std::string& code, const sol::table& env, sol::this_state s) {
sol::state_view lua(s); sol::state_view thisState(s);
sol::load_result res = lua.load(code, "", sol::load_mode::text); sol::load_result res = thisState.load(code, "", sol::load_mode::text);
if (!res.valid()) if (!res.valid())
throw std::runtime_error("Lua error: " + res.get<std::string>()); throw std::runtime_error("Lua error: " + res.get<std::string>());
sol::function fn = res; sol::function fn = res;
sol::environment newEnv(lua, sol::create, env); sol::environment newEnv(thisState, sol::create, env);
newEnv[sol::metatable_key][sol::meta_function::new_index] = env; newEnv[sol::metatable_key][sol::meta_function::new_index] = env;
sol::set_environment(newEnv, fn); sol::set_environment(newEnv, fn);
return fn; return fn;

20
components/nif/recordptr.hpp
View file

@ -19,7 +19,7 @@ namespace Nif
union union
{ {
intptr_t index; intptr_t index;
X* ptr; X* mPtr;
}; };
public: public:
@ -29,7 +29,7 @@ namespace Nif
} }
RecordPtrT(X* ptr) RecordPtrT(X* ptr)
: ptr(ptr) : mPtr(ptr)
{ {
} }
@ -48,26 +48,26 @@ namespace Nif
void post(Reader& nif) void post(Reader& nif)
{ {
if (index < 0) if (index < 0)
ptr = nullptr; mPtr = nullptr;
else else
{ {
Record* r = nif.getRecord(index); Record* r = nif.getRecord(index);
// And cast it // And cast it
ptr = dynamic_cast<X*>(r); mPtr = dynamic_cast<X*>(r);
assert(ptr != nullptr); assert(mPtr != nullptr);
} }
} }
/// Look up the actual object from the index /// Look up the actual object from the index
const X* getPtr() const const X* getPtr() const
{ {
assert(ptr != nullptr); assert(mPtr != nullptr);
return ptr; return mPtr;
} }
X* getPtr() X* getPtr()
{ {
assert(ptr != nullptr); assert(mPtr != nullptr);
return ptr; return mPtr;
} }
const X& get() const { return *getPtr(); } const X& get() const { return *getPtr(); }
@ -78,7 +78,7 @@ namespace Nif
X* operator->() { return getPtr(); } X* operator->() { return getPtr(); }
/// Pointers are allowed to be empty /// Pointers are allowed to be empty
bool empty() const { return ptr == nullptr; } bool empty() const { return mPtr == nullptr; }
}; };
/** A list of references to other records. These are read as a list, /** A list of references to other records. These are read as a list,

2
components/nifosg/controller.cpp
View file

@ -375,7 +375,7 @@ namespace NifOsg
return true; return true;
auto iter = std::upper_bound(mData->begin(), mData->end(), time, auto iter = std::upper_bound(mData->begin(), mData->end(), time,
[](float time, const std::pair<float, bool>& key) { return time < key.first; }); [](float t, const std::pair<float, bool>& key) { return t < key.first; });
if (iter != mData->begin()) if (iter != mData->begin())
--iter; --iter;
return iter->second; return iter->second;

6
components/stereo/stereomanager.cpp
View file

@ -32,18 +32,18 @@ namespace Stereo
{ {
public: public:
StereoUpdateCallback(Manager* stereoView) StereoUpdateCallback(Manager* stereoView)
: stereoView(stereoView) : mStereoView(stereoView)
{ {
} }
bool run(osg::Object* object, osg::Object* data) override bool run(osg::Object* object, osg::Object* data) override
{ {
auto b = traverse(object, data); auto b = traverse(object, data);
stereoView->update(); mStereoView->update();
return b; return b;
} }
Manager* stereoView; Manager* mStereoView;
}; };
// Update states during cull // Update states during cull