Merge branch 'uniquely_made' into 'master'

Replace operator new with make_unique

See merge request OpenMW/openmw!1945

apps/essimporter/importer.cpp

@@ -273,38 +273,38 @@ namespace ESSImport
         const unsigned int recSPLM = ESM::fourCC("SPLM");
 
         std::map<unsigned int, std::unique_ptr<Converter>> converters;
-        converters[ESM::REC_GLOB] = std::unique_ptr<Converter>(new ConvertGlobal());
+        converters[ESM::REC_GLOB] = std::make_unique<ConvertGlobal>();
-        converters[ESM::REC_BOOK] = std::unique_ptr<Converter>(new ConvertBook());
+        converters[ESM::REC_BOOK] = std::make_unique<ConvertBook>();
-        converters[ESM::REC_NPC_] = std::unique_ptr<Converter>(new ConvertNPC());
+        converters[ESM::REC_NPC_] = std::make_unique<ConvertNPC>();
-        converters[ESM::REC_CREA] = std::unique_ptr<Converter>(new ConvertCREA());
+        converters[ESM::REC_CREA] = std::make_unique<ConvertCREA>();
-        converters[ESM::REC_NPCC] = std::unique_ptr<Converter>(new ConvertNPCC());
+        converters[ESM::REC_NPCC] = std::make_unique<ConvertNPCC>();
-        converters[ESM::REC_CREC] = std::unique_ptr<Converter>(new ConvertCREC());
+        converters[ESM::REC_CREC] = std::make_unique<ConvertCREC>();
-        converters[recREFR      ] = std::unique_ptr<Converter>(new ConvertREFR());
+        converters[recREFR      ] = std::make_unique<ConvertREFR>();
-        converters[recPCDT      ] = std::unique_ptr<Converter>(new ConvertPCDT());
+        converters[recPCDT      ] = std::make_unique<ConvertPCDT>();
-        converters[recFMAP      ] = std::unique_ptr<Converter>(new ConvertFMAP());
+        converters[recFMAP      ] = std::make_unique<ConvertFMAP>();
-        converters[recKLST      ] = std::unique_ptr<Converter>(new ConvertKLST());
+        converters[recKLST      ] = std::make_unique<ConvertKLST>();
-        converters[recSTLN      ] = std::unique_ptr<Converter>(new ConvertSTLN());
+        converters[recSTLN      ] = std::make_unique<ConvertSTLN>();
-        converters[recGAME      ] = std::unique_ptr<Converter>(new ConvertGAME());
+        converters[recGAME      ] = std::make_unique<ConvertGAME>();
-        converters[ESM::REC_CELL] = std::unique_ptr<Converter>(new ConvertCell());
+        converters[ESM::REC_CELL] = std::make_unique<ConvertCell>();
-        converters[ESM::REC_ALCH] = std::unique_ptr<Converter>(new DefaultConverter<ESM::Potion>());
+        converters[ESM::REC_ALCH] = std::make_unique<DefaultConverter<ESM::Potion>>();
-        converters[ESM::REC_CLAS] = std::unique_ptr<Converter>(new ConvertClass());
+        converters[ESM::REC_CLAS] = std::make_unique<ConvertClass>();
-        converters[ESM::REC_SPEL] = std::unique_ptr<Converter>(new DefaultConverter<ESM::Spell>());
+        converters[ESM::REC_SPEL] = std::make_unique<DefaultConverter<ESM::Spell>>();
-        converters[ESM::REC_ARMO] = std::unique_ptr<Converter>(new DefaultConverter<ESM::Armor>());
+        converters[ESM::REC_ARMO] = std::make_unique<DefaultConverter<ESM::Armor>>();
-        converters[ESM::REC_WEAP] = std::unique_ptr<Converter>(new DefaultConverter<ESM::Weapon>());
+        converters[ESM::REC_WEAP] = std::make_unique<DefaultConverter<ESM::Weapon>>();
-        converters[ESM::REC_CLOT] = std::unique_ptr<Converter>(new DefaultConverter<ESM::Clothing>());
+        converters[ESM::REC_CLOT] = std::make_unique<DefaultConverter<ESM::Clothing>>();
-        converters[ESM::REC_ENCH] = std::unique_ptr<Converter>(new DefaultConverter<ESM::Enchantment>());
+        converters[ESM::REC_ENCH] = std::make_unique<DefaultConverter<ESM::Enchantment>>();
-        converters[ESM::REC_WEAP] = std::unique_ptr<Converter>(new DefaultConverter<ESM::Weapon>());
+        converters[ESM::REC_WEAP] = std::make_unique<DefaultConverter<ESM::Weapon>>();
-        converters[ESM::REC_LEVC] = std::unique_ptr<Converter>(new DefaultConverter<ESM::CreatureLevList>());
+        converters[ESM::REC_LEVC] = std::make_unique<DefaultConverter<ESM::CreatureLevList>>();
-        converters[ESM::REC_LEVI] = std::unique_ptr<Converter>(new DefaultConverter<ESM::ItemLevList>());
+        converters[ESM::REC_LEVI] = std::make_unique<DefaultConverter<ESM::ItemLevList>>();
-        converters[ESM::REC_CNTC] = std::unique_ptr<Converter>(new ConvertCNTC());
+        converters[ESM::REC_CNTC] = std::make_unique<ConvertCNTC>();
-        converters[ESM::REC_FACT] = std::unique_ptr<Converter>(new ConvertFACT());
+        converters[ESM::REC_FACT] = std::make_unique<ConvertFACT>();
-        converters[ESM::REC_INFO] = std::unique_ptr<Converter>(new ConvertINFO());
+        converters[ESM::REC_INFO] = std::make_unique<ConvertINFO>();
-        converters[ESM::REC_DIAL] = std::unique_ptr<Converter>(new ConvertDIAL());
+        converters[ESM::REC_DIAL] = std::make_unique<ConvertDIAL>();
-        converters[ESM::REC_QUES] = std::unique_ptr<Converter>(new ConvertQUES());
+        converters[ESM::REC_QUES] = std::make_unique<ConvertQUES>();
-        converters[recJOUR      ] = std::unique_ptr<Converter>(new ConvertJOUR());
+        converters[recJOUR      ] = std::make_unique<ConvertJOUR>();
-        converters[ESM::REC_SCPT] = std::unique_ptr<Converter>(new ConvertSCPT());
+        converters[ESM::REC_SCPT] = std::make_unique<ConvertSCPT>();
-        converters[ESM::REC_PROJ] = std::unique_ptr<Converter>(new ConvertPROJ());
+        converters[ESM::REC_PROJ] = std::make_unique<ConvertPROJ>();
-        converters[recSPLM] = std::unique_ptr<Converter>(new ConvertSPLM());
+        converters[recSPLM] = std::make_unique<ConvertSPLM>();
 
         // TODO:
         // - REGN (weather in certain regions?)

apps/opencs/model/doc/document.cpp

@@ -116,7 +116,7 @@ void CSMDoc::Document::addOptionalGmst (const ESM::GameSetting& gmst)
 {
     if (getData().getGmsts().searchId (gmst.mId)==-1)
     {
-        std::unique_ptr<CSMWorld::Record<ESM::GameSetting> > record(new CSMWorld::Record<ESM::GameSetting>);
+        auto record = std::make_unique<CSMWorld::Record<ESM::GameSetting>>();
         record->mBase = gmst;
         record->mState = CSMWorld::RecordBase::State_BaseOnly;
         getData().getGmsts().appendRecord (std::move(record));
@@ -127,7 +127,7 @@ void CSMDoc::Document::addOptionalGlobal (const ESM::Global& global)
 {
     if (getData().getGlobals().searchId (global.mId)==-1)
     {
-        std::unique_ptr<CSMWorld::Record<ESM::Global> > record(new CSMWorld::Record<ESM::Global>);
+        auto record = std::make_unique<CSMWorld::Record<ESM::Global>>();
         record->mBase = global;
         record->mState = CSMWorld::RecordBase::State_BaseOnly;
         getData().getGlobals().appendRecord (std::move(record));
@@ -138,7 +138,7 @@ void CSMDoc::Document::addOptionalMagicEffect (const ESM::MagicEffect& magicEffe
 {
     if (getData().getMagicEffects().searchId (magicEffect.mId)==-1)
     {
-        std::unique_ptr<CSMWorld::Record<ESM::MagicEffect> > record(new CSMWorld::Record<ESM::MagicEffect>);
+        auto record = std::make_unique<CSMWorld::Record<ESM::MagicEffect>>();
         record->mBase = magicEffect;
         record->mState = CSMWorld::RecordBase::State_BaseOnly;
         getData().getMagicEffects().appendRecord (std::move(record));

apps/opencs/model/filter/parser.cpp

@@ -579,7 +579,7 @@ bool CSMFilter::Parser::parse (const std::string& filter, bool allowPredefined)
         else
         {
             // Empty filter string equals to filter "true".
-            mFilter.reset (new BooleanNode (true));
+            mFilter = std::make_shared<BooleanNode>(true);
         }
 
         return true;

apps/opencs/model/world/actoradapter.cpp

@@ -228,7 +228,7 @@ namespace CSMWorld
         }
 
         // Create the actor data
-        data.reset(new ActorData());
+        data = std::make_shared<ActorData>();
         setupActor(id, data);
         mCachedActors.insert(id, data);
         return data;
@@ -431,7 +431,7 @@ namespace CSMWorld
         if (data) return data;
 
         // Create the race data
-        data.reset(new RaceData());
+        data = std::make_shared<RaceData>();
         setupRace(id, data);
         mCachedRaces.insert(id, data);
         return data;

apps/opencs/model/world/collection.hpp

@@ -249,12 +249,13 @@ namespace CSMWorld
     int Collection<ESXRecordT, IdAccessorT>::cloneRecordImp(const std::string& origin,
         const std::string& destination, UniversalId::Type type)
     {
-       std::unique_ptr<Record<ESXRecordT> > copy(new Record<ESXRecordT>);
+        auto copy = std::make_unique<Record<ESXRecordT>>();
-       copy->mModified = getRecord(origin).get();
+        copy->mModified = getRecord(origin).get();
-       copy->mState = RecordBase::State_ModifiedOnly;
+        copy->mState = RecordBase::State_ModifiedOnly;
-       IdAccessorT().setId(copy->get(), destination);
+        IdAccessorT().setId(copy->get(), destination);
 
-        if (type == UniversalId::Type_Reference) {
+        if (type == UniversalId::Type_Reference)
+        {
             CSMWorld::CellRef* ptr = (CSMWorld::CellRef*) &copy->mModified;
             ptr->mRefNum.mIndex = 0;
         }
@@ -338,7 +339,7 @@ namespace CSMWorld
 
         if (iter==mIndex.end())
         {
-            std::unique_ptr<Record<ESXRecordT> > record2(new Record<ESXRecordT>);
+            auto record2 = std::make_unique<Record<ESXRecordT>>();
             record2->mState = Record<ESXRecordT>::State_ModifiedOnly;
             record2->mModified = record;
 
@@ -469,7 +470,7 @@ namespace CSMWorld
         IdAccessorT().setId(record, id);
         record.blank();
 
-        std::unique_ptr<Record<ESXRecordT> > record2(new Record<ESXRecordT>);
+        auto record2 = std::make_unique<Record<ESXRecordT>>();
         record2->mState = Record<ESXRecordT>::State_ModifiedOnly;
         record2->mModified = record;
 

apps/opencs/model/world/commanddispatcher.cpp

@@ -170,14 +170,13 @@ void CSMWorld::CommandDispatcher::executeModify (QAbstractItemModel *model, cons
                 if (cellId.find ('#')!=std::string::npos)
                 {
                     // Need to recalculate the cell
-                    modifyCell.reset (new UpdateCellCommand (model2, row));
+                    modifyCell = std::make_unique<UpdateCellCommand>(model2, row);
                 }
             }
         }
     }
 
-    std::unique_ptr<CSMWorld::ModifyCommand> modifyData (
+    auto modifyData = std::make_unique<CSMWorld::ModifyCommand>(*model, index, new_);
-        new CSMWorld::ModifyCommand (*model, index, new_));
 
     if (modifyCell.get())
     {

apps/opencs/model/world/data.cpp

@@ -70,11 +70,11 @@ CSMWorld::Data::Data (ToUTF8::FromType encoding, bool fsStrict, const Files::Pat
   mReader (nullptr), mDialogue (nullptr), mReaderIndex(1),
   mFsStrict(fsStrict), mDataPaths(dataPaths), mArchives(archives)
 {
-    mVFS.reset(new VFS::Manager(mFsStrict));
+    mVFS = std::make_unique<VFS::Manager>(mFsStrict);
     VFS::registerArchives(mVFS.get(), Files::Collections(mDataPaths, !mFsStrict), mArchives, true);
 
     mResourcesManager.setVFS(mVFS.get());
-    mResourceSystem.reset(new Resource::ResourceSystem(mVFS.get()));
+    mResourceSystem = std::make_unique<Resource::ResourceSystem>(mVFS.get());
 
     Shader::ShaderManager::DefineMap defines = mResourceSystem->getSceneManager()->getShaderManager().getGlobalDefines();
     Shader::ShaderManager::DefineMap shadowDefines = SceneUtil::ShadowManager::getShadowsDisabledDefines();
@@ -602,7 +602,7 @@ CSMWorld::Data::Data (ToUTF8::FromType encoding, bool fsStrict, const Files::Pat
         UniversalId::Type_Video);
     addModel (new IdTable (&mMetaData), UniversalId::Type_MetaData);
 
-    mActorAdapter.reset(new ActorAdapter(*this));
+    mActorAdapter = std::make_unique<ActorAdapter>(*this);
 
     mRefLoadCache.clear(); // clear here rather than startLoading() and continueLoading() for multiple content files
 }
@@ -963,7 +963,7 @@ int CSMWorld::Data::getTotalRecords (const std::vector<boost::filesystem::path>&
 {
     int records = 0;
 
-    std::unique_ptr<ESM::ESMReader> reader = std::unique_ptr<ESM::ESMReader>(new ESM::ESMReader);
+    std::unique_ptr<ESM::ESMReader> reader = std::make_unique<ESM::ESMReader>();
 
     for (unsigned int i = 0; i < files.size(); ++i)
     {
@@ -1032,7 +1032,7 @@ void CSMWorld::Data::loadFallbackEntries()
             ESM::Static newMarker;
             newMarker.mId = marker.first;
             newMarker.mModel = marker.second;
-            std::unique_ptr<CSMWorld::Record<ESM::Static> > record(new CSMWorld::Record<ESM::Static>);
+            auto record = std::make_unique<CSMWorld::Record<ESM::Static>>();
             record->mBase = newMarker;
             record->mState = CSMWorld::RecordBase::State_BaseOnly;
             mReferenceables.appendRecord (std::move(record), CSMWorld::UniversalId::Type_Static);
@@ -1046,7 +1046,7 @@ void CSMWorld::Data::loadFallbackEntries()
             ESM::Door newMarker;
             newMarker.mId = marker.first;
             newMarker.mModel = marker.second;
-            std::unique_ptr<CSMWorld::Record<ESM::Door> > record(new CSMWorld::Record<ESM::Door>);
+            auto record = std::make_unique<CSMWorld::Record<ESM::Door>>();
             record->mBase = newMarker;
             record->mState = CSMWorld::RecordBase::State_BaseOnly;
             mReferenceables.appendRecord (std::move(record), CSMWorld::UniversalId::Type_Door);

apps/opencs/model/world/idcollection.cpp

@@ -32,7 +32,7 @@ namespace CSMWorld
                 return -1;
             }
 
-            std::unique_ptr<Record<Pathgrid> > baseRecord(new Record<Pathgrid>(this->getRecord(index)));
+            auto baseRecord = std::make_unique<Record<Pathgrid>>(this->getRecord(index));
             baseRecord->mState = RecordBase::State_Deleted;
             this->setRecord(index, std::move(baseRecord));
             return index;

apps/opencs/model/world/idcollection.hpp

@@ -84,7 +84,7 @@ namespace CSMWorld
                 return -1;
             }
 
-            std::unique_ptr<Record<ESXRecordT> > baseRecord(new Record<ESXRecordT>(this->getRecord(index)));
+            auto baseRecord = std::make_unique<Record<ESXRecordT>>(this->getRecord(index));
             baseRecord->mState = RecordBase::State_Deleted;
             this->setRecord(index, std::move(baseRecord));
             return index;
@@ -103,7 +103,7 @@ namespace CSMWorld
         if (index==-1)
         {
             // new record
-            std::unique_ptr<Record<ESXRecordT> > record2(new Record<ESXRecordT>);
+            auto record2 = std::make_unique<Record<ESXRecordT>>();
             record2->mState = base ? RecordBase::State_BaseOnly : RecordBase::State_ModifiedOnly;
             (base ? record2->mBase : record2->mModified) = record;
 
@@ -113,8 +113,7 @@ namespace CSMWorld
         else
         {
             // old record
-            std::unique_ptr<Record<ESXRecordT> > record2(
+            auto record2 = std::make_unique<Record<ESXRecordT>>(Collection<ESXRecordT, IdAccessorT>::getRecord(index));
-                    new Record<ESXRecordT>(Collection<ESXRecordT, IdAccessorT>::getRecord(index)));
 
             if (base)
                 record2->mBase = record;
@@ -146,8 +145,7 @@ namespace CSMWorld
         }
         else
         {
-            std::unique_ptr<Record<ESXRecordT> > record2(
+            auto record2 = std::make_unique<Record<ESXRecordT>>(Collection<ESXRecordT, IdAccessorT>::getRecord(index));
-                    new Record<ESXRecordT>(Collection<ESXRecordT, IdAccessorT>::getRecord(index)));
             record2->mState = RecordBase::State_Deleted;
             this->setRecord(index, std::move(record2));
         }

apps/opencs/model/world/infocollection.cpp

@@ -77,7 +77,7 @@ void CSMWorld::InfoCollection::load (const Info& record, bool base)
     if (index==-1)
     {
         // new record
-        std::unique_ptr<Record<Info> > record2(new Record<Info>);
+        auto record2 = std::make_unique<Record<Info>>();
         record2->mState = base ? RecordBase::State_BaseOnly : RecordBase::State_ModifiedOnly;
         (base ? record2->mBase : record2->mModified) = record;
 
@@ -86,7 +86,7 @@ void CSMWorld::InfoCollection::load (const Info& record, bool base)
     else
     {
         // old record
-        std::unique_ptr<Record<Info> > record2(new Record<Info>(getRecord(index)));
+        auto record2 = std::make_unique<Record<Info>>(getRecord(index));
 
         if (base)
             record2->mBase = record;
@@ -220,7 +220,7 @@ void CSMWorld::InfoCollection::load (ESM::ESMReader& reader, bool base, const ES
         }
         else
         {
-            std::unique_ptr<Record<Info> > record(new Record<Info>(getRecord(index)));
+            auto record = std::make_unique<Record<Info>>(getRecord(index));
             record->mState = RecordBase::State_Deleted;
             setRecord (index, std::move(record));
         }
@@ -281,7 +281,7 @@ void CSMWorld::InfoCollection::removeDialogueInfos(const std::string& dialogueId
             }
             else
             {
-                std::unique_ptr<Record<Info> > record2(new Record<Info>(record));
+                auto record2 = std::make_unique<Record<Info>>(record);
                 record2->mState = RecordBase::State_Deleted;
                 setRecord(range.first - getRecords().begin(), std::move(record2));
             }
@@ -335,7 +335,7 @@ void CSMWorld::InfoCollection::removeRows (int index, int count)
 
 void  CSMWorld::InfoCollection::appendBlankRecord (const std::string& id, UniversalId::Type type)
 {
-    std::unique_ptr<Record<Info> > record2(new Record<Info>);
+    auto record2 = std::make_unique<Record<Info>>();
 
     record2->mState = Record<Info>::State_ModifiedOnly;
     record2->mModified.blank();

apps/opencs/model/world/nestedidcollection.hpp

@@ -90,7 +90,7 @@ namespace CSMWorld
     template<typename ESXRecordT, typename IdAccessorT>
     void NestedIdCollection<ESXRecordT, IdAccessorT>::addNestedRow(int row, int column, int position)
     {
-        std::unique_ptr<Record<ESXRecordT> > record(new Record<ESXRecordT>);
+        auto record = std::make_unique<Record<ESXRecordT>>();
         record->assign(Collection<ESXRecordT, IdAccessorT>::getRecord(row));
 
         getAdapter(Collection<ESXRecordT, IdAccessorT>::getColumn(column)).addRow(*record, position);
@@ -101,7 +101,7 @@ namespace CSMWorld
     template<typename ESXRecordT, typename IdAccessorT>
     void NestedIdCollection<ESXRecordT, IdAccessorT>::removeNestedRows(int row, int column, int subRow)
     {
-        std::unique_ptr<Record<ESXRecordT> > record(new Record<ESXRecordT>);
+        auto record = std::make_unique<Record<ESXRecordT>>();
         record->assign(Collection<ESXRecordT, IdAccessorT>::getRecord(row));
 
         getAdapter(Collection<ESXRecordT, IdAccessorT>::getColumn(column)).removeRow(*record, subRow);
@@ -121,7 +121,7 @@ namespace CSMWorld
     void NestedIdCollection<ESXRecordT, IdAccessorT>::setNestedData(int row,
             int column, const QVariant& data, int subRow, int subColumn)
     {
-        std::unique_ptr<Record<ESXRecordT> > record(new Record<ESXRecordT>);
+        auto record = std::make_unique<Record<ESXRecordT>>();
         record->assign(Collection<ESXRecordT, IdAccessorT>::getRecord(row));
 
         getAdapter(Collection<ESXRecordT, IdAccessorT>::getColumn(column)).setData(
@@ -142,7 +142,7 @@ namespace CSMWorld
     void NestedIdCollection<ESXRecordT, IdAccessorT>::setNestedTable(int row,
             int column, const CSMWorld::NestedTableWrapperBase& nestedTable)
     {
-        std::unique_ptr<Record<ESXRecordT> > record(new Record<ESXRecordT>);
+        auto record = std::make_unique<Record<ESXRecordT>>();
         record->assign(Collection<ESXRecordT, IdAccessorT>::getRecord(row));
 
         getAdapter(Collection<ESXRecordT, IdAccessorT>::getColumn(column)).setTable(

apps/opencs/model/world/nestedinfocollection.cpp

@@ -35,7 +35,7 @@ namespace CSMWorld
 
     void NestedInfoCollection::addNestedRow(int row, int column, int position)
     {
-        std::unique_ptr<Record<Info> > record(new Record<Info>);
+        auto record = std::make_unique<Record<Info>>();
         record->assign(Collection<Info, IdAccessor<Info> >::getRecord(row));
 
         getAdapter(Collection<Info, IdAccessor<Info> >::getColumn(column)).addRow(*record, position);
@@ -45,7 +45,7 @@ namespace CSMWorld
 
     void NestedInfoCollection::removeNestedRows(int row, int column, int subRow)
     {
-        std::unique_ptr<Record<Info> > record(new Record<Info>);
+        auto record = std::make_unique<Record<Info>>();
         record->assign(Collection<Info, IdAccessor<Info> >::getRecord(row));
 
         getAdapter(Collection<Info, IdAccessor<Info> >::getColumn(column)).removeRow(*record, subRow);
@@ -63,7 +63,7 @@ namespace CSMWorld
     void NestedInfoCollection::setNestedData(int row,
             int column, const QVariant& data, int subRow, int subColumn)
     {
-        std::unique_ptr<Record<Info> > record(new Record<Info>);
+        auto record = std::make_unique<Record<Info>>();
         record->assign(Collection<Info, IdAccessor<Info> >::getRecord(row));
 
         getAdapter(Collection<Info, IdAccessor<Info> >::getColumn(column)).setData(
@@ -82,7 +82,7 @@ namespace CSMWorld
     void NestedInfoCollection::setNestedTable(int row,
             int column, const CSMWorld::NestedTableWrapperBase& nestedTable)
     {
-        std::unique_ptr<Record<Info> > record(new Record<Info>);
+        auto record = std::make_unique<Record<Info>>();
         record->assign(Collection<Info, IdAccessor<Info> >::getRecord(row));
 
         getAdapter(Collection<Info, IdAccessor<Info> >::getColumn(column)).setTable(

apps/opencs/model/world/refcollection.cpp

@@ -123,7 +123,7 @@ void CSMWorld::RefCollection::load (ESM::ESMReader& reader, int cellIndex, bool
             ref.mId = getRecord(index).get().mId;
             ref.mIdNum = extractIdNum(ref.mId);
 
-            std::unique_ptr<Record<CellRef> > record(new Record<CellRef>);
+            auto record = std::make_unique<Record<CellRef>>();
             // TODO: check whether a base record be moved
             record->mState = base ? RecordBase::State_BaseOnly : RecordBase::State_ModifiedOnly;
             (base ? record->mBase : record->mModified) = std::move(ref);
@@ -158,7 +158,7 @@ void CSMWorld::RefCollection::load (ESM::ESMReader& reader, int cellIndex, bool
             }
             else
             {
-                std::unique_ptr<Record<CellRef> > record(new Record<CellRef>(getRecord(index)));
+                auto record = std::make_unique<Record<CellRef>>(getRecord(index));
                 record->mState = RecordBase::State_Deleted;
                 setRecord(index, std::move(record));
             }
@@ -174,7 +174,7 @@ void CSMWorld::RefCollection::load (ESM::ESMReader& reader, int cellIndex, bool
 
             cache.emplace(refNum, ref.mIdNum);
 
-            std::unique_ptr<Record<CellRef> > record(new Record<CellRef>);
+            auto record = std::make_unique<Record<CellRef>>();
             record->mState = base ? RecordBase::State_BaseOnly : RecordBase::State_ModifiedOnly;
             (base ? record->mBase : record->mModified) = std::move(ref);
 
@@ -205,7 +205,7 @@ void CSMWorld::RefCollection::load (ESM::ESMReader& reader, int cellIndex, bool
             ref.mId = getRecord(index).get().mId;
             ref.mIdNum = extractIdNum(ref.mId);
 
-            std::unique_ptr<Record<CellRef> > record(new Record<CellRef>(getRecord(index)));
+            auto record = std::make_unique<Record<CellRef>>(getRecord(index));
             record->mState = base ? RecordBase::State_BaseOnly : RecordBase::State_Modified;
             (base ? record->mBase : record->mModified) = std::move(ref);
 
@@ -273,7 +273,7 @@ void CSMWorld::RefCollection::removeRows (int index, int count)
 
 void  CSMWorld::RefCollection::appendBlankRecord (const std::string& id, UniversalId::Type type)
 {
-    std::unique_ptr<Record<CellRef> > record(new Record<CellRef>);
+    auto record = std::make_unique<Record<CellRef>>();
 
     record->mState = Record<CellRef>::State_ModifiedOnly;
     record->mModified.blank();
@@ -288,15 +288,15 @@ void CSMWorld::RefCollection::cloneRecord (const std::string& origin,
                                            const std::string& destination,
                                            const UniversalId::Type type)
 {
-   std::unique_ptr<Record<CellRef> > copy(new Record<CellRef>);
+    auto copy = std::make_unique<Record<CellRef>>();
 
-   copy->mModified = getRecord(origin).get();
+    copy->mModified = getRecord(origin).get();
-   copy->mState = RecordBase::State_ModifiedOnly;
+    copy->mState = RecordBase::State_ModifiedOnly;
 
-   copy->get().mId = destination;
+    copy->get().mId = destination;
-   copy->get().mIdNum = extractIdNum(destination);
+    copy->get().mIdNum = extractIdNum(destination);
 
-   insertRecord(std::move(copy), getAppendIndex(destination, type)); // call RefCollection::insertRecord()
+    insertRecord(std::move(copy), getAppendIndex(destination, type)); // call RefCollection::insertRecord()
 }
 
 int CSMWorld::RefCollection::searchId(std::string_view id) const

apps/opencs/model/world/refiddata.hpp

@@ -130,7 +130,7 @@ namespace CSMWorld
     template<typename RecordT>
     void RefIdDataContainer<RecordT>::appendRecord (const std::string& id, bool base)
     {
-        std::unique_ptr<Record<RecordT> > record(new Record<RecordT>);
+        auto record = std::make_unique<Record<RecordT>>();
 
         record->mState = base ? RecordBase::State_BaseOnly : RecordBase::State_ModifiedOnly;
 

apps/opencs/view/render/cell.cpp

@@ -85,7 +85,7 @@ bool CSVRender::Cell::addObjects (int start, int end)
         {
             std::string id = Misc::StringUtils::lowerCase (collection.getRecord (i).get().mId);
 
-            std::unique_ptr<Object> object (new Object (mData, mCellNode, id, false));
+            auto object = std::make_unique<Object>(mData, mCellNode, id, false);
 
             if (mSubModeElementMask & Mask_Reference)
                 object->setSubMode (mSubMode);
@@ -128,14 +128,14 @@ void CSVRender::Cell::updateLand()
             }
             else
             {
-                mTerrain.reset(new Terrain::TerrainGrid(mCellNode, mCellNode,
+                mTerrain = std::make_unique<Terrain::TerrainGrid>(mCellNode, mCellNode,
-                    mData.getResourceSystem().get(), mTerrainStorage, Mask_Terrain));
+                    mData.getResourceSystem().get(), mTerrainStorage, Mask_Terrain);
             }
 
             mTerrain->loadCell(esmLand.mX, esmLand.mY);
 
             if (!mCellBorder)
-                mCellBorder.reset(new CellBorder(mCellNode, mCoordinates));
+                mCellBorder = std::make_unique<CellBorder>(mCellNode, mCoordinates);
 
             mCellBorder->buildShape(esmLand);
 
@@ -186,8 +186,8 @@ CSVRender::Cell::Cell (CSMWorld::Data& data, osg::Group* rootNode, const std::st
 
         updateLand();
 
-        mPathgrid.reset(new Pathgrid(mData, mCellNode, mId, mCoordinates));
+        mPathgrid = std::make_unique<Pathgrid>(mData, mCellNode, mId, mCoordinates);
-        mCellWater.reset(new CellWater(mData, mCellNode, mId, mCoordinates));
+        mCellWater = std::make_unique<CellWater>(mData, mCellNode, mId, mCoordinates);
     }
 }
 
@@ -546,7 +546,7 @@ void CSVRender::Cell::setCellArrows (int mask)
         if (enable!=(mCellArrows[i].get()!=nullptr))
         {
             if (enable)
-                mCellArrows[i].reset (new CellArrow (mCellNode, direction, mCoordinates));
+                mCellArrows[i] = std::make_unique<CellArrow>(mCellNode, direction, mCoordinates);
             else
                 mCellArrows[i].reset (nullptr);
         }
@@ -567,7 +567,7 @@ void CSVRender::Cell::setCellMarker()
     }
 
     if (!isInteriorCell) {
-        mCellMarker.reset(new CellMarker(mCellNode, mCoordinates, cellExists));
+        mCellMarker = std::make_unique<CellMarker>(mCellNode, mCoordinates, cellExists);
     }
 }
 

apps/opencs/view/render/object.cpp

@@ -117,7 +117,7 @@ void CSVRender::Object::update()
     {
         if (recordType == CSMWorld::UniversalId::Type_Npc || recordType == CSMWorld::UniversalId::Type_Creature)
         {
-            if (!mActor) mActor.reset(new Actor(mReferenceableId, mData));
+            if (!mActor) mActor = std::make_unique<Actor>(mReferenceableId, mData);
             mActor->update();
             mBaseNode->addChild(mActor->getBaseNode());
         }

apps/opencs/view/render/pagedworldspacewidget.cpp

@@ -55,8 +55,8 @@ bool CSVRender::PagedWorldspaceWidget::adjustCells()
                 {
                     modified = true;
 
-                    std::unique_ptr<Cell> cell (new Cell (mDocument.getData(), mRootNode,
+                    auto cell = std::make_unique<Cell>(mDocument.getData(), mRootNode,
-                        iter->first.getId (mWorldspace), deleted));
+                        iter->first.getId (mWorldspace), deleted);
 
                     delete iter->second;
                     iter->second = cell.release();
@@ -443,9 +443,7 @@ void CSVRender::PagedWorldspaceWidget::addCellToScene (
     bool deleted = index==-1 ||
         cells.getRecord (index).mState==CSMWorld::RecordBase::State_Deleted;
 
-    std::unique_ptr<Cell> cell (
+    auto cell = std::make_unique<Cell>(mDocument.getData(), mRootNode, coordinates.getId (mWorldspace), deleted);
-        new Cell (mDocument.getData(), mRootNode, coordinates.getId (mWorldspace),
-        deleted));
     EditMode *editMode = getEditMode();
     cell->setSubMode (editMode->getSubMode(), editMode->getInteractionMask());
 

apps/opencs/view/render/terrainshapemode.cpp

@@ -41,7 +41,7 @@ void CSVRender::TerrainShapeMode::activate(CSVWidget::SceneToolbar* toolbar)
 {
     if (!mTerrainShapeSelection)
     {
-        mTerrainShapeSelection.reset(new TerrainSelection(mParentNode, &getWorldspaceWidget(), TerrainSelectionType::Shape));
+        mTerrainShapeSelection = std::make_shared<TerrainSelection>(mParentNode, &getWorldspaceWidget(), TerrainSelectionType::Shape);
     }
 
     if(!mShapeBrushScenetool)
@@ -56,7 +56,7 @@ void CSVRender::TerrainShapeMode::activate(CSVWidget::SceneToolbar* toolbar)
     }
 
     if (!mBrushDraw)
-        mBrushDraw.reset(new BrushDraw(mParentNode));
+        mBrushDraw = std::make_unique<BrushDraw>(mParentNode);
 
     EditMode::activate(toolbar);
     toolbar->addTool (mShapeBrushScenetool);
@@ -956,15 +956,15 @@ bool CSVRender::TerrainShapeMode::limitAlteredHeights(const CSMWorld::CellCoordi
 
                     // Check for height limits on x-axis
                     if (leftHeight - thisHeight > limitHeightChange)
-                        limitedAlteredHeightXAxis.reset(new float(leftHeight - limitHeightChange - (thisHeight - thisAlteredHeight)));
+                        limitedAlteredHeightXAxis = std::make_unique<float>(leftHeight - limitHeightChange - (thisHeight - thisAlteredHeight));
                     else if (leftHeight - thisHeight < -limitHeightChange)
-                        limitedAlteredHeightXAxis.reset(new float(leftHeight + limitHeightChange - (thisHeight - thisAlteredHeight)));
+                        limitedAlteredHeightXAxis = std::make_unique<float>(leftHeight + limitHeightChange - (thisHeight - thisAlteredHeight));
 
                     // Check for height limits on y-axis
                     if (upHeight - thisHeight > limitHeightChange)
-                        limitedAlteredHeightYAxis.reset(new float(upHeight - limitHeightChange - (thisHeight - thisAlteredHeight)));
+                        limitedAlteredHeightYAxis = std::make_unique<float>(upHeight - limitHeightChange - (thisHeight - thisAlteredHeight));
                     else if (upHeight - thisHeight < -limitHeightChange)
-                        limitedAlteredHeightYAxis.reset(new float(upHeight + limitHeightChange - (thisHeight - thisAlteredHeight)));
+                        limitedAlteredHeightYAxis = std::make_unique<float>(upHeight + limitHeightChange - (thisHeight - thisAlteredHeight));
 
                     // Limit altered height value based on x or y, whichever is the smallest
                     compareAndLimit(cellCoords, inCellX, inCellY, limitedAlteredHeightXAxis.get(), limitedAlteredHeightYAxis.get(), &steepnessIsWithinLimits);
@@ -985,15 +985,15 @@ bool CSVRender::TerrainShapeMode::limitAlteredHeights(const CSMWorld::CellCoordi
 
                     // Check for height limits on x-axis
                     if (rightHeight - thisHeight > limitHeightChange)
-                        limitedAlteredHeightXAxis.reset(new float(rightHeight - limitHeightChange - (thisHeight - thisAlteredHeight)));
+                        limitedAlteredHeightXAxis = std::make_unique<float>(rightHeight - limitHeightChange - (thisHeight - thisAlteredHeight));
                     else if (rightHeight - thisHeight < -limitHeightChange)
-                        limitedAlteredHeightXAxis.reset(new float(rightHeight + limitHeightChange - (thisHeight - thisAlteredHeight)));
+                        limitedAlteredHeightXAxis = std::make_unique<float>(rightHeight + limitHeightChange - (thisHeight - thisAlteredHeight));
 
                     // Check for height limits on y-axis
                     if (downHeight - thisHeight > limitHeightChange)
-                        limitedAlteredHeightYAxis.reset(new float(downHeight - limitHeightChange - (thisHeight - thisAlteredHeight)));
+                        limitedAlteredHeightYAxis = std::make_unique<float>(downHeight - limitHeightChange - (thisHeight - thisAlteredHeight));
                     else if (downHeight - thisHeight < -limitHeightChange)
-                        limitedAlteredHeightYAxis.reset(new float(downHeight + limitHeightChange - (thisHeight - thisAlteredHeight)));
+                        limitedAlteredHeightYAxis = std::make_unique<float>(downHeight + limitHeightChange - (thisHeight - thisAlteredHeight));
 
                     // Limit altered height value based on x or y, whichever is the smallest
                     compareAndLimit(cellCoords, inCellX, inCellY, limitedAlteredHeightXAxis.get(), limitedAlteredHeightYAxis.get(), &steepnessIsWithinLimits);
@@ -1298,8 +1298,7 @@ bool CSVRender::TerrainShapeMode::allowLandShapeEditing(const std::string& cellI
 
         if (mode=="Create cell and land, then edit" && useTool)
         {
-            std::unique_ptr<CSMWorld::CreateCommand> createCommand (
+            auto createCommand = std::make_unique<CSMWorld::CreateCommand>(cellTable, cellId);
-                new CSMWorld::CreateCommand (cellTable, cellId));
             int parentIndex = cellTable.findColumnIndex (CSMWorld::Columns::ColumnId_Cell);
             int index = cellTable.findNestedColumnIndex (parentIndex, CSMWorld::Columns::ColumnId_Interior);
             createCommand->addNestedValue (parentIndex, index, false);

apps/opencs/view/render/terraintexturemode.cpp

@@ -65,11 +65,11 @@ void CSVRender::TerrainTextureMode::activate(CSVWidget::SceneToolbar* toolbar)
 
     if (!mTerrainTextureSelection)
     {
-        mTerrainTextureSelection.reset(new TerrainSelection(mParentNode, &getWorldspaceWidget(), TerrainSelectionType::Texture));
+        mTerrainTextureSelection = std::make_shared<TerrainSelection>(mParentNode, &getWorldspaceWidget(), TerrainSelectionType::Texture);
     }
 
     if (!mBrushDraw)
-        mBrushDraw.reset(new BrushDraw(mParentNode, true));
+        mBrushDraw = std::make_unique<BrushDraw>(mParentNode, true);
 
     EditMode::activate(toolbar);
     toolbar->addTool (mTextureBrushScenetool);
@@ -662,8 +662,7 @@ bool CSVRender::TerrainTextureMode::allowLandTextureEditing(std::string cellId)
 
         if (mode=="Create cell and land, then edit")
         {
-            std::unique_ptr<CSMWorld::CreateCommand> createCommand (
+            auto createCommand = std::make_unique<CSMWorld::CreateCommand>(cellTable, cellId);
-                new CSMWorld::CreateCommand (cellTable, cellId));
             int parentIndex = cellTable.findColumnIndex (CSMWorld::Columns::ColumnId_Cell);
             int index = cellTable.findNestedColumnIndex (parentIndex, CSMWorld::Columns::ColumnId_Interior);
             createCommand->addNestedValue (parentIndex, index, false);

apps/opencs/view/render/unpagedworldspacewidget.cpp

@@ -56,7 +56,7 @@ CSVRender::UnpagedWorldspaceWidget::UnpagedWorldspaceWidget (const std::string&
 
     update();
 
-    mCell.reset (new Cell (document.getData(), mRootNode, mCellId));
+    mCell = std::make_unique<Cell>(document.getData(), mRootNode, mCellId);
 }
 
 void CSVRender::UnpagedWorldspaceWidget::cellDataChanged (const QModelIndex& topLeft,
@@ -105,7 +105,7 @@ bool CSVRender::UnpagedWorldspaceWidget::handleDrop (const std::vector<CSMWorld:
 
     mCellId = universalIdData.begin()->getId();
 
-    mCell.reset (new Cell (getDocument().getData(), mRootNode, mCellId));
+    mCell = std::make_unique<Cell>(getDocument().getData(), mRootNode, mCellId);
     mCamPositionSet = false;
     mOrbitCamControl->reset();
 

apps/opencs/view/world/creator.hpp

@@ -96,7 +96,7 @@ namespace CSVWorld
     Creator *CreatorFactory<CreatorT, scope>::makeCreator (CSMDoc::Document& document,
                                                            const CSMWorld::UniversalId& id) const
     {
-        std::unique_ptr<CreatorT> creator (new CreatorT (document.getData(), document.getUndoStack(), id));
+        auto creator = std::make_unique<CreatorT>(document.getData(), document.getUndoStack(), id);
 
         creator->setScope (scope);
 

apps/opencs/view/world/dialoguesubview.cpp

@@ -133,7 +133,7 @@ void CSVWorld::DialogueDelegateDispatcherProxy::editorDataCommited()
 
 void CSVWorld::DialogueDelegateDispatcherProxy::setIndex(const QModelIndex& index)
 {
-    mIndexWrapper.reset(new refWrapper(index));
+    mIndexWrapper = std::make_unique<refWrapper>(index);
 }
 
 QWidget* CSVWorld::DialogueDelegateDispatcherProxy::getEditor() const

apps/opencs/view/world/genericcreator.cpp

@@ -238,13 +238,13 @@ void CSVWorld::GenericCreator::create()
 
         if (mCloneMode)
         {
-            command.reset (new CSMWorld::CloneCommand (
+            command = std::make_unique<CSMWorld::CloneCommand>(
-                dynamic_cast<CSMWorld::IdTable&> (*mData.getTableModel(mListId)), mClonedId, id, mClonedType));
+                dynamic_cast<CSMWorld::IdTable&> (*mData.getTableModel(mListId)), mClonedId, id, mClonedType);
         }
         else
         {
-            command.reset (new CSMWorld::CreateCommand (
+            command = std::make_unique<CSMWorld::CreateCommand>(
-                dynamic_cast<CSMWorld::IdTable&> (*mData.getTableModel (mListId)), id));
+                dynamic_cast<CSMWorld::IdTable&> (*mData.getTableModel (mListId)), id);
 
         }
 

apps/openmw/main.cpp

@@ -213,8 +213,7 @@ int runApplication(int argc, char *argv[])
 
     osg::setNotifyHandler(new OSGLogHandler());
     Files::ConfigurationManager cfgMgr;
-    std::unique_ptr<OMW::Engine> engine;
+    std::unique_ptr<OMW::Engine> engine = std::make_unique<OMW::Engine>(cfgMgr);
-    engine.reset(new OMW::Engine(cfgMgr));
 
     if (parseOptions(argc, argv, *engine, cfgMgr))
     {

apps/openmw/mwclass/activator.cpp

@@ -119,12 +119,12 @@ namespace MWClass
             auto& prng = MWBase::Environment::get().getWorld()->getPrng();
             const ESM::Sound *sound = store.get<ESM::Sound>().searchRandom("WolfActivator", prng);
 
-            std::unique_ptr<MWWorld::Action> action(new MWWorld::FailedAction("#{sWerewolfRefusal}"));
+            std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::FailedAction>("#{sWerewolfRefusal}");
             if(sound) action->setSound(sound->mId);
 
             return action;
         }
-        return std::unique_ptr<MWWorld::Action>(new MWWorld::NullAction);
+        return std::make_unique<MWWorld::NullAction>();
     }
 
 

apps/openmw/mwclass/apparatus.cpp

@@ -110,7 +110,7 @@ namespace MWClass
 
     std::unique_ptr<MWWorld::Action> Apparatus::use (const MWWorld::Ptr& ptr, bool force) const
     {
-        return std::unique_ptr<MWWorld::Action>(new MWWorld::ActionAlchemy(force));
+        return std::make_unique<MWWorld::ActionAlchemy>(force);
     }
 
     MWWorld::Ptr Apparatus::copyToCellImpl(const MWWorld::ConstPtr &ptr, MWWorld::CellStore &cell) const

apps/openmw/mwclass/armor.cpp

@@ -336,7 +336,7 @@ namespace MWClass
 
     std::unique_ptr<MWWorld::Action> Armor::use (const MWWorld::Ptr& ptr, bool force) const
     {
-        std::unique_ptr<MWWorld::Action> action(new MWWorld::ActionEquip(ptr, force));
+        std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::ActionEquip>(ptr, force);
 
         action->setSound(getUpSoundId(ptr));
 

apps/openmw/mwclass/book.cpp

@@ -63,13 +63,13 @@ namespace MWClass
             auto& prng = MWBase::Environment::get().getWorld()->getPrng();
             const ESM::Sound *sound = store.get<ESM::Sound>().searchRandom("WolfItem", prng);
 
-            std::unique_ptr<MWWorld::Action> action(new MWWorld::FailedAction("#{sWerewolfRefusal}"));
+            std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::FailedAction>("#{sWerewolfRefusal}");
             if(sound) action->setSound(sound->mId);
 
             return action;
         }
 
-        return std::unique_ptr<MWWorld::Action>(new MWWorld::ActionRead(ptr));
+        return std::make_unique<MWWorld::ActionRead>(ptr);
     }
 
     std::string Book::getScript (const MWWorld::ConstPtr& ptr) const
@@ -151,7 +151,7 @@ namespace MWClass
 
     std::unique_ptr<MWWorld::Action> Book::use (const MWWorld::Ptr& ptr, bool force) const
     {
-        return std::unique_ptr<MWWorld::Action>(new MWWorld::ActionRead(ptr));
+        return std::make_unique<MWWorld::ActionRead>(ptr);
     }
 
     MWWorld::Ptr Book::copyToCellImpl(const MWWorld::ConstPtr &ptr, MWWorld::CellStore &cell) const

apps/openmw/mwclass/clothing.cpp

@@ -230,7 +230,7 @@ namespace MWClass
 
     std::unique_ptr<MWWorld::Action> Clothing::use (const MWWorld::Ptr& ptr, bool force) const
     {
-        std::unique_ptr<MWWorld::Action> action(new MWWorld::ActionEquip(ptr, force));
+        std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::ActionEquip>(ptr, force);
 
         action->setSound(getUpSoundId(ptr));
 

apps/openmw/mwclass/container.cpp

@@ -135,7 +135,7 @@ namespace MWClass
         const MWWorld::Ptr& actor) const
     {
         if (!MWBase::Environment::get().getWindowManager()->isAllowed(MWGui::GW_Inventory))
-            return std::unique_ptr<MWWorld::Action> (new MWWorld::NullAction ());
+            return std::make_unique<MWWorld::NullAction>();
 
         if(actor.getClass().isNpc() && actor.getClass().getNpcStats(actor).isWerewolf())
         {
@@ -143,7 +143,7 @@ namespace MWClass
             auto& prng = MWBase::Environment::get().getWorld()->getPrng();
             const ESM::Sound *sound = store.get<ESM::Sound>().searchRandom("WolfContainer", prng);
 
-            std::unique_ptr<MWWorld::Action> action(new MWWorld::FailedAction("#{sWerewolfRefusal}"));
+            std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::FailedAction>("#{sWerewolfRefusal}");
             if(sound) action->setSound(sound->mId);
 
             return action;
@@ -191,24 +191,22 @@ namespace MWClass
             {
                 if (canBeHarvested(ptr))
                 {
-                    std::unique_ptr<MWWorld::Action> action (new MWWorld::ActionHarvest(ptr));
+                    return std::make_unique<MWWorld::ActionHarvest>(ptr);
-                    return action;
                 }
 
-                std::unique_ptr<MWWorld::Action> action (new MWWorld::ActionOpen(ptr));
+                return std::make_unique<MWWorld::ActionOpen>(ptr);
-                return action;
             }
             else
             {
                 // Activate trap
-                std::unique_ptr<MWWorld::Action> action(new MWWorld::ActionTrap(ptr.getCellRef().getTrap(), ptr));
+                std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::ActionTrap>(ptr.getCellRef().getTrap(), ptr);
                 action->setSound(trapActivationSound);
                 return action;
             }
         }
         else
         {
-            std::unique_ptr<MWWorld::Action> action(new MWWorld::FailedAction(std::string(), ptr));
+            std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::FailedAction>(std::string(), ptr);
             action->setSound(lockedSound);
             return action;
         }

apps/openmw/mwclass/creature.cpp

@@ -439,7 +439,7 @@ namespace MWClass
             auto& prng = MWBase::Environment::get().getWorld()->getPrng();
             const ESM::Sound *sound = store.get<ESM::Sound>().searchRandom("WolfCreature", prng);
 
-            std::unique_ptr<MWWorld::Action> action(new MWWorld::FailedAction("#{sWerewolfRefusal}"));
+            std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::FailedAction>("#{sWerewolfRefusal}");
             if(sound) action->setSound(sound->mId);
 
             return action;
@@ -453,20 +453,20 @@ namespace MWClass
 
             // by default user can loot friendly actors during death animation
             if (canLoot && !stats.getAiSequence().isInCombat())
-                return std::unique_ptr<MWWorld::Action>(new MWWorld::ActionOpen(ptr));
+                return std::make_unique<MWWorld::ActionOpen>(ptr);
 
             // otherwise wait until death animation
             if(stats.isDeathAnimationFinished())
-                return std::unique_ptr<MWWorld::Action>(new MWWorld::ActionOpen(ptr));
+                return std::make_unique<MWWorld::ActionOpen>(ptr);
         }
         else if (!stats.getAiSequence().isInCombat() && !stats.getKnockedDown())
-            return std::unique_ptr<MWWorld::Action>(new MWWorld::ActionTalk(ptr));
+            return std::make_unique<MWWorld::ActionTalk>(ptr);
 
         // Tribunal and some mod companions oddly enough must use open action as fallback
         if (!getScript(ptr).empty() && ptr.getRefData().getLocals().getIntVar(getScript(ptr), "companion"))
-            return std::unique_ptr<MWWorld::Action>(new MWWorld::ActionOpen(ptr));
+            return std::make_unique<MWWorld::ActionOpen>(ptr);
 
-        return std::unique_ptr<MWWorld::Action>(new MWWorld::FailedAction(""));
+        return std::make_unique<MWWorld::FailedAction>();
     }
 
     MWWorld::ContainerStore& Creature::getContainerStore (const MWWorld::Ptr& ptr) const
@@ -763,7 +763,7 @@ namespace MWClass
                 else
                 {
                     // Create a CustomData, but don't fill it from ESM records (not needed)
-                    std::unique_ptr<CreatureCustomData> data (new CreatureCustomData);
+                    auto data = std::make_unique<CreatureCustomData>();
 
                     if (hasInventoryStore(ptr))
                         data->mContainerStore = std::make_unique<MWWorld::InventoryStore>();

apps/openmw/mwclass/door.cpp

@@ -131,7 +131,7 @@ namespace MWClass
         // Make such activation a no-op for now, like how it is in the vanilla game.
         if (actor != MWMechanics::getPlayer() && ptr.getCellRef().getTeleport())
         {
-            std::unique_ptr<MWWorld::Action> action(new MWWorld::FailedAction(std::string(), ptr));
+            std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::FailedAction>(std::string(), ptr);
             action->setSound(lockedSound);
             return action;
         }
@@ -182,7 +182,7 @@ namespace MWClass
             if(isTrapped)
             {
                 // Trap activation
-                std::unique_ptr<MWWorld::Action> action(new MWWorld::ActionTrap(ptr.getCellRef().getTrap(), ptr));
+                std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::ActionTrap>(ptr.getCellRef().getTrap(), ptr);
                 action->setSound(trapActivationSound);
                 return action;
             }
@@ -192,12 +192,11 @@ namespace MWClass
                 if (actor == MWMechanics::getPlayer() && MWBase::Environment::get().getWorld()->getDistanceToFacedObject() > MWBase::Environment::get().getWorld()->getMaxActivationDistance())
                 {
                     // player activated teleport door with telekinesis
-                    std::unique_ptr<MWWorld::Action> action(new MWWorld::FailedAction);
+                    return std::make_unique<MWWorld::FailedAction>();
-                    return action;
                 }
                 else
                 {
-                    std::unique_ptr<MWWorld::Action> action(new MWWorld::ActionTeleport (ptr.getCellRef().getDestCell(), ptr.getCellRef().getDoorDest(), true));
+                    std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::ActionTeleport>(ptr.getCellRef().getDestCell(), ptr.getCellRef().getDoorDest(), true);
                     action->setSound(openSound);
                     return action;
                 }
@@ -205,7 +204,7 @@ namespace MWClass
             else
             {
                 // animated door
-                std::unique_ptr<MWWorld::Action> action(new MWWorld::ActionDoor(ptr));
+                std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::ActionDoor>(ptr);
                 const auto doorState = getDoorState(ptr);
                 bool opening = true;
                 float doorRot = ptr.getRefData().getPosition().rot[2] - ptr.getCellRef().getPosition().rot[2];
@@ -239,7 +238,7 @@ namespace MWClass
         else
         {
             // locked, and we can't open.
-            std::unique_ptr<MWWorld::Action> action(new MWWorld::FailedAction(std::string(), ptr));
+            std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::FailedAction>(std::string(), ptr);
             action->setSound(lockedSound);
             return action;
         }

apps/openmw/mwclass/ingredient.cpp

@@ -74,7 +74,7 @@ namespace MWClass
 
     std::unique_ptr<MWWorld::Action> Ingredient::use (const MWWorld::Ptr& ptr, bool force) const
     {
-        std::unique_ptr<MWWorld::Action> action (new MWWorld::ActionEat (ptr));
+        std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::ActionEat>(ptr);
 
         action->setSound ("Swallow");
 

apps/openmw/mwclass/light.cpp

@@ -89,11 +89,11 @@ namespace MWClass
         const MWWorld::Ptr& actor) const
     {
         if(!MWBase::Environment::get().getWindowManager()->isAllowed(MWGui::GW_Inventory))
-            return std::unique_ptr<MWWorld::Action>(new MWWorld::NullAction());
+            return std::make_unique<MWWorld::NullAction>();
 
         MWWorld::LiveCellRef<ESM::Light> *ref = ptr.get<ESM::Light>();
         if(!(ref->mBase->mData.mFlags&ESM::Light::Carry))
-            return std::unique_ptr<MWWorld::Action>(new MWWorld::FailedAction());
+            return std::make_unique<MWWorld::FailedAction>();
 
         return defaultItemActivate(ptr, actor);
     }
@@ -186,7 +186,7 @@ namespace MWClass
 
     std::unique_ptr<MWWorld::Action> Light::use (const MWWorld::Ptr& ptr, bool force) const
     {
-        std::unique_ptr<MWWorld::Action> action(new MWWorld::ActionEquip(ptr, force));
+        std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::ActionEquip>(ptr, force);
 
         action->setSound(getUpSoundId(ptr));
 

apps/openmw/mwclass/lockpick.cpp

@@ -126,7 +126,7 @@ namespace MWClass
 
     std::unique_ptr<MWWorld::Action> Lockpick::use (const MWWorld::Ptr& ptr, bool force) const
     {
-        std::unique_ptr<MWWorld::Action> action(new MWWorld::ActionEquip(ptr, force));
+        std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::ActionEquip>(ptr, force);
 
         action->setSound(getUpSoundId(ptr));
 

apps/openmw/mwclass/misc.cpp

@@ -206,9 +206,8 @@ namespace MWClass
     std::unique_ptr<MWWorld::Action> Miscellaneous::use (const MWWorld::Ptr& ptr, bool force) const
     {
         if (ptr.getCellRef().getSoul().empty() || !MWBase::Environment::get().getWorld()->getStore().get<ESM::Creature>().search(ptr.getCellRef().getSoul()))
-            return std::unique_ptr<MWWorld::Action>(new MWWorld::NullAction());
+            return std::make_unique<MWWorld::NullAction>();
-        else
+        return std::make_unique<MWWorld::ActionSoulgem>(ptr);
-            return std::unique_ptr<MWWorld::Action>(new MWWorld::ActionSoulgem(ptr));
     }
 
     bool Miscellaneous::canSell (const MWWorld::ConstPtr& item, int npcServices) const

apps/openmw/mwclass/npc.cpp

@@ -865,7 +865,7 @@ namespace MWClass
     {
         // player got activated by another NPC
         if(ptr == MWMechanics::getPlayer())
-            return std::unique_ptr<MWWorld::Action>(new MWWorld::ActionTalk(actor));
+            return std::make_unique<MWWorld::ActionTalk>(actor);
 
         // Werewolfs can't activate NPCs
         if(actor.getClass().isNpc() && actor.getClass().getNpcStats(actor).isWerewolf())
@@ -874,7 +874,7 @@ namespace MWClass
             auto& prng = MWBase::Environment::get().getWorld()->getPrng();
             const ESM::Sound *sound = store.get<ESM::Sound>().searchRandom("WolfNPC", prng);
 
-            std::unique_ptr<MWWorld::Action> action(new MWWorld::FailedAction("#{sWerewolfRefusal}"));
+            std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::FailedAction>("#{sWerewolfRefusal}");
             if(sound) action->setSound(sound->mId);
 
             return action;
@@ -888,33 +888,33 @@ namespace MWClass
 
             // by default user can loot friendly actors during death animation
             if (canLoot && !stats.getAiSequence().isInCombat())
-                return std::unique_ptr<MWWorld::Action>(new MWWorld::ActionOpen(ptr));
+                return std::make_unique<MWWorld::ActionOpen>(ptr);
 
             // otherwise wait until death animation
             if(stats.isDeathAnimationFinished())
-                return std::unique_ptr<MWWorld::Action>(new MWWorld::ActionOpen(ptr));
+                return std::make_unique<MWWorld::ActionOpen>(ptr);
         }
         else if (!stats.getAiSequence().isInCombat())
         {
             if (stats.getKnockedDown() || MWBase::Environment::get().getMechanicsManager()->isSneaking(actor))
-                return std::unique_ptr<MWWorld::Action>(new MWWorld::ActionOpen(ptr)); // stealing
+                return std::make_unique<MWWorld::ActionOpen>(ptr); // stealing
 
             // Can't talk to werewolves
             if (!getNpcStats(ptr).isWerewolf())
-                return std::unique_ptr<MWWorld::Action>(new MWWorld::ActionTalk(ptr));
+                return std::make_unique<MWWorld::ActionTalk>(ptr);
         }
         else // In combat
         {
             const bool stealingInCombat = Settings::Manager::getBool ("always allow stealing from knocked out actors", "Game");
             if (stealingInCombat && stats.getKnockedDown())
-                return std::unique_ptr<MWWorld::Action>(new MWWorld::ActionOpen(ptr)); // stealing
+                return std::make_unique<MWWorld::ActionOpen>(ptr); // stealing
         }
 
         // Tribunal and some mod companions oddly enough must use open action as fallback
         if (!getScript(ptr).empty() && ptr.getRefData().getLocals().getIntVar(getScript(ptr), "companion"))
-            return std::unique_ptr<MWWorld::Action>(new MWWorld::ActionOpen(ptr));
+            return std::make_unique<MWWorld::ActionOpen>(ptr);
 
-        return std::unique_ptr<MWWorld::Action> (new MWWorld::FailedAction(""));
+        return std::make_unique<MWWorld::FailedAction>();
     }
 
     MWWorld::ContainerStore& Npc::getContainerStore (const MWWorld::Ptr& ptr)

apps/openmw/mwclass/probe.cpp

@@ -126,7 +126,7 @@ namespace MWClass
 
     std::unique_ptr<MWWorld::Action> Probe::use (const MWWorld::Ptr& ptr, bool force) const
     {
-        std::unique_ptr<MWWorld::Action> action(new MWWorld::ActionEquip(ptr, force));
+        std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::ActionEquip>(ptr, force);
 
         action->setSound(getUpSoundId(ptr));
 

apps/openmw/mwclass/repair.cpp

@@ -134,7 +134,7 @@ namespace MWClass
 
     std::unique_ptr<MWWorld::Action> Repair::use (const MWWorld::Ptr& ptr, bool force) const
     {
-        return std::unique_ptr<MWWorld::Action>(new MWWorld::ActionRepair(ptr, force));
+        return std::make_unique<MWWorld::ActionRepair>(ptr, force);
     }
 
     bool Repair::canSell (const MWWorld::ConstPtr& item, int npcServices) const

apps/openmw/mwclass/weapon.cpp

@@ -301,7 +301,7 @@ namespace MWClass
 
     std::unique_ptr<MWWorld::Action> Weapon::use (const MWWorld::Ptr& ptr, bool force) const
     {
-        std::unique_ptr<MWWorld::Action> action(new MWWorld::ActionEquip(ptr, force));
+        std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::ActionEquip>(ptr, force);
 
         action->setSound(getUpSoundId(ptr));
 

apps/openmw/mwgui/bookpage.cpp

@@ -1116,7 +1116,7 @@ public:
 
             if (j == this_->mActiveTextFormats.end ())
             {
-                std::unique_ptr<TextFormat> textFormat(new TextFormat (Font, this_));
+                auto textFormat = std::make_unique<TextFormat>(Font, this_);
 
                 textFormat->mTexture = Font->getTextureFont ();
 

apps/openmw/mwgui/inventorywindow.cpp

@@ -63,11 +63,11 @@ namespace MWGui
         , mGuiMode(GM_Inventory)
         , mLastXSize(0)
         , mLastYSize(0)
-        , mPreview(new MWRender::InventoryPreview(parent, resourceSystem, MWMechanics::getPlayer()))
+        , mPreview(std::make_unique<MWRender::InventoryPreview>(parent, resourceSystem, MWMechanics::getPlayer()))
         , mTrading(false)
         , mUpdateTimer(0.f)
     {
-        mPreviewTexture.reset(new osgMyGUI::OSGTexture(mPreview->getTexture(), mPreview->getTextureStateSet()));
+        mPreviewTexture = std::make_unique<osgMyGUI::OSGTexture>(mPreview->getTexture(), mPreview->getTextureStateSet());
         mPreview->rebuild();
 
         mMainWidget->castType<MyGUI::Window>()->eventWindowChangeCoord += MyGUI::newDelegate(this, &InventoryWindow::onWindowResize);

apps/openmw/mwgui/loadingscreen.cpp

@@ -297,7 +297,7 @@ namespace MWGui
 
         if (!mGuiTexture.get())
         {
-            mGuiTexture.reset(new osgMyGUI::OSGTexture(mTexture));
+            mGuiTexture = std::make_unique<osgMyGUI::OSGTexture>(mTexture);
         }
 
         if (!mCopyFramebufferToTextureCallback)

apps/openmw/mwgui/mapwindow.cpp

@@ -596,27 +596,27 @@ namespace MWGui
                 osg::ref_ptr<osg::Texture2D> texture = mLocalMapRender->getMapTexture(entry.mCellX, entry.mCellY);
                 if (texture)
                 {
-                    entry.mMapTexture.reset(new osgMyGUI::OSGTexture(texture));
+                    entry.mMapTexture = std::make_unique<osgMyGUI::OSGTexture>(texture);
                     entry.mMapWidget->setRenderItemTexture(entry.mMapTexture.get());
                     entry.mMapWidget->getSubWidgetMain()->_setUVSet(MyGUI::FloatRect(0.f, 0.f, 1.f, 1.f));
                     needRedraw = true;
                 }
                 else
-                    entry.mMapTexture.reset(new osgMyGUI::OSGTexture("", nullptr));
+                    entry.mMapTexture = std::make_unique<osgMyGUI::OSGTexture>(std::string(), nullptr);
             }
             if (!entry.mFogTexture && mFogOfWarToggled && mFogOfWarEnabled)
             {
                 osg::ref_ptr<osg::Texture2D> tex = mLocalMapRender->getFogOfWarTexture(entry.mCellX, entry.mCellY);
                 if (tex)
                 {
-                    entry.mFogTexture.reset(new osgMyGUI::OSGTexture(tex));
+                    entry.mFogTexture = std::make_unique<osgMyGUI::OSGTexture>(tex);
                     entry.mFogWidget->setRenderItemTexture(entry.mFogTexture.get());
                     entry.mFogWidget->getSubWidgetMain()->_setUVSet(MyGUI::FloatRect(0.f, 1.f, 1.f, 0.f));
                 }
                 else
                 {
                     entry.mFogWidget->setImageTexture("black");
-                    entry.mFogTexture.reset(new osgMyGUI::OSGTexture("", nullptr));
+                    entry.mFogTexture = std::make_unique<osgMyGUI::OSGTexture>(std::string(), nullptr);
                 }
                 needRedraw = true;
             }
@@ -1279,11 +1279,11 @@ namespace MWGui
     {
         if (!mGlobalMapTexture.get())
         {
-            mGlobalMapTexture.reset(new osgMyGUI::OSGTexture(mGlobalMapRender->getBaseTexture()));
+            mGlobalMapTexture = std::make_unique<osgMyGUI::OSGTexture>(mGlobalMapRender->getBaseTexture());
             mGlobalMapImage->setRenderItemTexture(mGlobalMapTexture.get());
             mGlobalMapImage->getSubWidgetMain()->_setUVSet(MyGUI::FloatRect(0.f, 0.f, 1.f, 1.f));
 
-            mGlobalMapOverlayTexture.reset(new osgMyGUI::OSGTexture(mGlobalMapRender->getOverlayTexture()));
+            mGlobalMapOverlayTexture = std::make_unique<osgMyGUI::OSGTexture>(mGlobalMapRender->getOverlayTexture());
             mGlobalMapOverlay->setRenderItemTexture(mGlobalMapOverlayTexture.get());
             mGlobalMapOverlay->getSubWidgetMain()->_setUVSet(MyGUI::FloatRect(0.f, 0.f, 1.f, 1.f));
 

apps/openmw/mwgui/race.cpp

@@ -134,11 +134,11 @@ namespace MWGui
         mPreview.reset(nullptr);
         mPreviewTexture.reset(nullptr);
 
-        mPreview.reset(new MWRender::RaceSelectionPreview(mParent, mResourceSystem));
+        mPreview = std::make_unique<MWRender::RaceSelectionPreview>(mParent, mResourceSystem);
         mPreview->rebuild();
         mPreview->setAngle (mCurrentAngle);
 
-        mPreviewTexture.reset(new osgMyGUI::OSGTexture(mPreview->getTexture(), mPreview->getTextureStateSet()));
+        mPreviewTexture = std::make_unique<osgMyGUI::OSGTexture>(mPreview->getTexture(), mPreview->getTextureStateSet());
         mPreviewImage->setRenderItemTexture(mPreviewTexture.get());
         mPreviewImage->getSubWidgetMain()->_setUVSet(MyGUI::FloatRect(0.f, 0.f, 1.f, 1.f));
 

apps/openmw/mwgui/savegamedialog.cpp

@@ -458,7 +458,7 @@ namespace MWGui
         texture->setResizeNonPowerOfTwoHint(false);
         texture->setUnRefImageDataAfterApply(true);
 
-        mScreenshotTexture.reset(new osgMyGUI::OSGTexture(texture));
+        mScreenshotTexture = std::make_unique<osgMyGUI::OSGTexture>(texture);
 
         mScreenshot->setRenderItemTexture(mScreenshotTexture.get());
         mScreenshot->getSubWidgetMain()->_setUVSet(MyGUI::FloatRect(0.f, 0.f, 1.f, 1.f));

apps/openmw/mwgui/videowidget.cpp

@@ -18,7 +18,7 @@ namespace MWGui
 VideoWidget::VideoWidget()
     : mVFS(nullptr)
 {
-    mPlayer.reset(new Video::VideoPlayer());
+    mPlayer = std::make_unique<Video::VideoPlayer>();
     setNeedKeyFocus(true);
 }
 
@@ -50,7 +50,7 @@ void VideoWidget::playVideo(const std::string &video)
     if (!texture)
         return;
 
-    mTexture.reset(new osgMyGUI::OSGTexture(texture));
+    mTexture = std::make_unique<osgMyGUI::OSGTexture>(texture);
 
     setRenderItemTexture(mTexture.get());
     getSubWidgetMain()->_setUVSet(MyGUI::FloatRect(0.f, 1.f, 1.f, 0.f));

apps/openmw/mwgui/windowmanagerimp.cpp

@@ -206,7 +206,7 @@ namespace MWGui
         MyGUI::LanguageManager::getInstance().eventRequestTag = MyGUI::newDelegate(this, &WindowManager::onRetrieveTag);
 
         // Load fonts
-        mFontLoader.reset(new Gui::FontLoader(encoding, resourceSystem->getVFS(), userDataPath, mScalingFactor));
+        mFontLoader = std::make_unique<Gui::FontLoader>(encoding, resourceSystem->getVFS(), userDataPath, mScalingFactor);
         mFontLoader->loadBitmapFonts(exportFonts);
 
         //Register own widgets with MyGUI
@@ -238,7 +238,7 @@ namespace MWGui
         WindowManager::loadUserFonts();
 
         bool keyboardNav = Settings::Manager::getBool("keyboard navigation", "GUI");
-        mKeyboardNavigation.reset(new KeyboardNavigation());
+        mKeyboardNavigation = std::make_unique<KeyboardNavigation>();
         mKeyboardNavigation->setEnabled(keyboardNav);
         Gui::ImageButton::setDefaultNeedKeyFocus(keyboardNav);
 
@@ -288,7 +288,7 @@ namespace MWGui
         if (useShaders)
             mGuiPlatform->getRenderManagerPtr()->enableShaders(mResourceSystem->getSceneManager()->getShaderManager());
 
-        mStatsWatcher.reset(new StatsWatcher());
+        mStatsWatcher = std::make_unique<StatsWatcher>();
     }
 
     void WindowManager::loadUserFonts()

apps/openmw/mwmechanics/aiactivate.cpp

@@ -46,7 +46,7 @@ namespace MWMechanics
 
     void AiActivate::writeState(ESM::AiSequence::AiSequence &sequence) const
     {
-        std::unique_ptr<ESM::AiSequence::AiActivate> activate(new ESM::AiSequence::AiActivate());
+        auto activate = std::make_unique<ESM::AiSequence::AiActivate>();
         activate->mTargetId = mObjectId;
         activate->mRepeat = getRepeat();
 

apps/openmw/mwmechanics/aicombat.cpp

@@ -200,7 +200,7 @@ namespace MWMechanics
         }
         else
         {
-            currentAction.reset(new ActionFlee());
+            currentAction = std::make_unique<ActionFlee>();
             actionCooldown = currentAction->getActionCooldown();
         }
 
@@ -300,7 +300,7 @@ namespace MWMechanics
                     storage.mUseCustomDestination = false;
                     storage.stopAttack();
                     actor.getClass().getCreatureStats(actor).setAttackingOrSpell(false);
-                    currentAction.reset(new ActionFlee());
+                    currentAction = std::make_unique<ActionFlee>();
                     actionCooldown = currentAction->getActionCooldown();
                     storage.startFleeing();
                     MWBase::Environment::get().getDialogueManager()->say(actor, "flee");
@@ -460,7 +460,7 @@ namespace MWMechanics
 
     void AiCombat::writeState(ESM::AiSequence::AiSequence &sequence) const
     {
-        std::unique_ptr<ESM::AiSequence::AiCombat> combat(new ESM::AiSequence::AiCombat());
+        auto combat = std::make_unique<ESM::AiSequence::AiCombat>();
         combat->mTargetActorId = mTargetActorId;
 
         ESM::AiSequence::AiPackageContainer package;

apps/openmw/mwmechanics/aicombataction.cpp

@@ -148,7 +148,7 @@ namespace MWMechanics
         float bestActionRating = 0.f;
         float antiFleeRating = 0.f;
         // Default to hand-to-hand combat
-        std::unique_ptr<Action> bestAction (new ActionWeapon(MWWorld::Ptr()));
+        std::unique_ptr<Action> bestAction = std::make_unique<ActionWeapon>(MWWorld::Ptr());
         if (actor.getClass().isNpc() && actor.getClass().getNpcStats(actor).isWerewolf())
         {
             bestAction->prepare(actor);
@@ -165,7 +165,7 @@ namespace MWMechanics
                 if (rating > bestActionRating)
                 {
                     bestActionRating = rating;
-                    bestAction.reset(new ActionPotion(*it));
+                    bestAction = std::make_unique<ActionPotion>(*it);
                     antiFleeRating = std::numeric_limits<float>::max();
                 }
             }
@@ -176,7 +176,7 @@ namespace MWMechanics
                 if (rating > bestActionRating)
                 {
                     bestActionRating = rating;
-                    bestAction.reset(new ActionEnchantedItem(it));
+                    bestAction = std::make_unique<ActionEnchantedItem>(it);
                     antiFleeRating = std::numeric_limits<float>::max();
                 }
             }
@@ -202,7 +202,7 @@ namespace MWMechanics
                         ammo = bestBolt;
 
                     bestActionRating = rating;
-                    bestAction.reset(new ActionWeapon(*it, ammo));
+                    bestAction = std::make_unique<ActionWeapon>(*it, ammo);
                     antiFleeRating = vanillaRateWeaponAndAmmo(*it, ammo, actor, enemy);
                 }
             }
@@ -214,13 +214,13 @@ namespace MWMechanics
             if (rating > bestActionRating)
             {
                 bestActionRating = rating;
-                bestAction.reset(new ActionSpell(spell->mId));
+                bestAction = std::make_unique<ActionSpell>(spell->mId);
                 antiFleeRating = vanillaRateSpell(spell, actor, enemy);
             }
         }
 
         if (makeFleeDecision(actor, enemy, antiFleeRating))
-            bestAction.reset(new ActionFlee());
+            bestAction = std::make_unique<ActionFlee>();
 
         if (bestAction.get())
             bestAction->prepare(actor);

apps/openmw/mwmechanics/aiescort.cpp

@@ -96,7 +96,7 @@ namespace MWMechanics
 
     void AiEscort::writeState(ESM::AiSequence::AiSequence &sequence) const
     {
-        std::unique_ptr<ESM::AiSequence::AiEscort> escort(new ESM::AiSequence::AiEscort());
+        auto escort = std::make_unique<ESM::AiSequence::AiEscort>();
         escort->mData.mX = mX;
         escort->mData.mY = mY;
         escort->mData.mZ = mZ;

apps/openmw/mwmechanics/aifollow.cpp

@@ -201,7 +201,7 @@ bool AiFollow::isCommanded() const
 
 void AiFollow::writeState(ESM::AiSequence::AiSequence &sequence) const
 {
-    std::unique_ptr<ESM::AiSequence::AiFollow> follow(new ESM::AiSequence::AiFollow());
+    auto follow = std::make_unique<ESM::AiSequence::AiFollow>();
     follow->mData.mX = mX;
     follow->mData.mY = mY;
     follow->mData.mZ = mZ;

apps/openmw/mwmechanics/aipursue.cpp

@@ -84,7 +84,7 @@ MWWorld::Ptr AiPursue::getTarget() const
 
 void AiPursue::writeState(ESM::AiSequence::AiSequence &sequence) const
 {
-    std::unique_ptr<ESM::AiSequence::AiPursue> pursue(new ESM::AiSequence::AiPursue());
+    auto pursue = std::make_unique<ESM::AiSequence::AiPursue>();
     pursue->mTargetActorId = mTargetActorId;
 
     ESM::AiSequence::AiPackageContainer package;

apps/openmw/mwmechanics/aisequence.cpp

@@ -498,41 +498,41 @@ void AiSequence::readState(const ESM::AiSequence::AiSequence &sequence)
         {
         case ESM::AiSequence::Ai_Wander:
         {
-            package.reset(new AiWander(&static_cast<const ESM::AiSequence::AiWander&>(*container.mPackage)));
+            package = std::make_unique<AiWander>(&static_cast<const ESM::AiSequence::AiWander&>(*container.mPackage));
             break;
         }
         case ESM::AiSequence::Ai_Travel:
         {
             const ESM::AiSequence::AiTravel& source = static_cast<const ESM::AiSequence::AiTravel&>(*container.mPackage);
             if (source.mHidden)
-                package.reset(new AiInternalTravel(&source));
+                package = std::make_unique<AiInternalTravel>(&source);
             else
-                package.reset(new AiTravel(&source));
+                package = std::make_unique<AiTravel>(&source);
             break;
         }
         case ESM::AiSequence::Ai_Escort:
         {
-            package.reset(new AiEscort(&static_cast<const ESM::AiSequence::AiEscort&>(*container.mPackage)));
+            package = std::make_unique<AiEscort>(&static_cast<const ESM::AiSequence::AiEscort&>(*container.mPackage));
             break;
         }
         case ESM::AiSequence::Ai_Follow:
         {
-            package.reset(new AiFollow(&static_cast<const ESM::AiSequence::AiFollow&>(*container.mPackage)));
+            package = std::make_unique<AiFollow>(&static_cast<const ESM::AiSequence::AiFollow&>(*container.mPackage));
             break;
         }
         case ESM::AiSequence::Ai_Activate:
         {
-            package.reset(new AiActivate(&static_cast<const ESM::AiSequence::AiActivate&>(*container.mPackage)));
+            package = std::make_unique<AiActivate>(&static_cast<const ESM::AiSequence::AiActivate&>(*container.mPackage));
             break;
         }
         case ESM::AiSequence::Ai_Combat:
         {
-            package.reset(new AiCombat(&static_cast<const ESM::AiSequence::AiCombat&>(*container.mPackage)));
+            package = std::make_unique<AiCombat>(&static_cast<const ESM::AiSequence::AiCombat&>(*container.mPackage));
             break;
         }
         case ESM::AiSequence::Ai_Pursue:
         {
-            package.reset(new AiPursue(&static_cast<const ESM::AiSequence::AiPursue&>(*container.mPackage)));
+            package = std::make_unique<AiPursue>(&static_cast<const ESM::AiSequence::AiPursue&>(*container.mPackage));
             break;
         }
         default:

apps/openmw/mwmechanics/aitravel.cpp

@@ -123,7 +123,7 @@ namespace MWMechanics
 
     void AiTravel::writeState(ESM::AiSequence::AiSequence &sequence) const
     {
-        std::unique_ptr<ESM::AiSequence::AiTravel> travel(new ESM::AiSequence::AiTravel());
+        auto travel = std::make_unique<ESM::AiSequence::AiTravel>();
         travel->mData.mX = mX;
         travel->mData.mY = mY;
         travel->mData.mZ = mZ;

apps/openmw/mwmechanics/aiwander.cpp

@@ -899,7 +899,7 @@ namespace MWMechanics
         else
             remainingDuration = mDuration;
 
-        std::unique_ptr<ESM::AiSequence::AiWander> wander(new ESM::AiSequence::AiWander());
+        auto wander = std::make_unique<ESM::AiSequence::AiWander>();
         wander->mData.mDistance = mDistance;
         wander->mData.mDuration = mDuration;
         wander->mData.mTimeOfDay = mTimeOfDay;

apps/openmw/mwphysics/actor.cpp

@@ -55,7 +55,7 @@ Actor::Actor(const MWWorld::Ptr& ptr, const Resource::BulletShape* shape, Physic
             Log(Debug::Error) << "Error: Failed to calculate bounding box for actor \"" << ptr.getCellRef().getRefId() << "\".";
     }
 
-    mShape.reset(new btBoxShape(Misc::Convert::toBullet(mOriginalHalfExtents)));
+    mShape = std::make_unique<btBoxShape>(Misc::Convert::toBullet(mOriginalHalfExtents));
     mRotationallyInvariant = (mMeshTranslation.x() == 0.0 && mMeshTranslation.y() == 0.0) && std::fabs(mOriginalHalfExtents.x() - mOriginalHalfExtents.y()) < 2.2;
 
     mConvexShape = static_cast<btConvexShape*>(mShape.get());

apps/openmw/mwphysics/physicssystem.cpp

@@ -98,7 +98,7 @@ namespace
 namespace MWPhysics
 {
     PhysicsSystem::PhysicsSystem(Resource::ResourceSystem* resourceSystem, osg::ref_ptr<osg::Group> parentNode)
-        : mShapeManager(new Resource::BulletShapeManager(resourceSystem->getVFS(), resourceSystem->getSceneManager(), resourceSystem->getNifFileManager()))
+        : mShapeManager(std::make_unique<Resource::BulletShapeManager>(resourceSystem->getVFS(), resourceSystem->getSceneManager(), resourceSystem->getNifFileManager()))
         , mResourceSystem(resourceSystem)
         , mDebugDrawEnabled(false)
         , mTimeAccum(0.0f)
@@ -891,8 +891,8 @@ namespace MWPhysics
             return;
         }
 
-        mWaterCollisionObject.reset(new btCollisionObject());
+        mWaterCollisionObject = std::make_unique<btCollisionObject>();
-        mWaterCollisionShape.reset(new btStaticPlaneShape(btVector3(0,0,1), mWaterHeight));
+        mWaterCollisionShape = std::make_unique<btStaticPlaneShape>(btVector3(0,0,1), mWaterHeight);
         mWaterCollisionObject->setCollisionShape(mWaterCollisionShape.get());
         mTaskScheduler->addCollisionObject(mWaterCollisionObject.get(), CollisionType_Water,
                                                     CollisionType_Actor|CollisionType_Projectile);

apps/openmw/mwrender/creatureanimation.cpp

@@ -147,7 +147,7 @@ void CreatureWeaponAnimation::updatePart(PartHolderPtr& scene, int slot)
     {
         osg::ref_ptr<osg::Node> attached = attach(itemModel, bonename, bonename, item.getType() == ESM::Light::sRecordId);
 
-        scene.reset(new PartHolder(attached));
+        scene = std::make_unique<PartHolder>(attached);
 
         if (!item.getClass().getEnchantment(item).empty())
             mGlowUpdater = SceneUtil::addEnchantedGlow(attached, mResourceSystem, item.getClass().getEnchantmentColor(item));
@@ -173,7 +173,7 @@ void CreatureWeaponAnimation::updatePart(PartHolderPtr& scene, int slot)
         if (slot == MWWorld::InventoryStore::Slot_CarriedRight)
             source = mWeaponAnimationTime;
         else
-            source.reset(new NullAnimationTime);
+            source = std::make_shared<NullAnimationTime>();
 
         SceneUtil::AssignControllerSourcesVisitor assignVisitor(source);
         attached->accept(assignVisitor);

apps/openmw/mwrender/localmap.cpp

@@ -122,7 +122,7 @@ void LocalMap::saveFogOfWar(MWWorld::CellStore* cell)
 
         if (segment.mFogOfWarImage && segment.mHasFogState)
         {
-            std::unique_ptr<ESM::FogState> fog (new ESM::FogState());
+            auto fog = std::make_unique<ESM::FogState>();
             fog->mFogTextures.emplace_back();
 
             segment.saveFogOfWar(fog->mFogTextures.back());
@@ -134,7 +134,7 @@ void LocalMap::saveFogOfWar(MWWorld::CellStore* cell)
     {
         auto segments = divideIntoSegments(mBounds, mMapWorldSize);
 
-        std::unique_ptr<ESM::FogState> fog (new ESM::FogState());
+        auto fog = std::make_unique<ESM::FogState>();
 
         fog->mBounds.mMinX = mBounds.xMin();
         fog->mBounds.mMaxX = mBounds.xMax();

apps/openmw/mwrender/renderingmanager.cpp

@@ -401,7 +401,7 @@ namespace MWRender
         if (Settings::Manager::getBool("terrain shadows", "Shadows"))
             shadowCastingTraversalMask |= Mask_Terrain;
 
-        mShadowManager.reset(new SceneUtil::ShadowManager(sceneRoot, mRootNode, shadowCastingTraversalMask, indoorShadowCastingTraversalMask, Mask_Terrain|Mask_Object|Mask_Static, mResourceSystem->getSceneManager()->getShaderManager()));
+        mShadowManager = std::make_unique<SceneUtil::ShadowManager>(sceneRoot, mRootNode, shadowCastingTraversalMask, indoorShadowCastingTraversalMask, Mask_Terrain|Mask_Object|Mask_Static, mResourceSystem->getSceneManager()->getShaderManager());
 
         Shader::ShaderManager::DefineMap shadowDefines = mShadowManager->getShadowDefines();
         Shader::ShaderManager::DefineMap lightDefines = sceneRoot->getLightDefines();
@@ -435,13 +435,13 @@ namespace MWRender
         // It is unnecessary to stop/start the viewer as no frames are being rendered yet.
         mResourceSystem->getSceneManager()->getShaderManager().setGlobalDefines(globalDefines);
 
-        mNavMesh.reset(new NavMesh(mRootNode, mWorkQueue, Settings::Manager::getBool("enable nav mesh render", "Navigator"),
+        mNavMesh = std::make_unique<NavMesh>(mRootNode, mWorkQueue, Settings::Manager::getBool("enable nav mesh render", "Navigator"),
-                                   parseNavMeshMode(Settings::Manager::getString("nav mesh render mode", "Navigator"))));
+                                   parseNavMeshMode(Settings::Manager::getString("nav mesh render mode", "Navigator")));
-        mActorsPaths.reset(new ActorsPaths(mRootNode, Settings::Manager::getBool("enable agents paths render", "Navigator")));
+        mActorsPaths = std::make_unique<ActorsPaths>(mRootNode, Settings::Manager::getBool("enable agents paths render", "Navigator"));
-        mRecastMesh.reset(new RecastMesh(mRootNode, Settings::Manager::getBool("enable recast mesh render", "Navigator")));
+        mRecastMesh = std::make_unique<RecastMesh>(mRootNode, Settings::Manager::getBool("enable recast mesh render", "Navigator"));
-        mPathgrid.reset(new Pathgrid(mRootNode));
+        mPathgrid = std::make_unique<Pathgrid>(mRootNode);
 
-        mObjects.reset(new Objects(mResourceSystem, sceneRoot));
+        mObjects = std::make_unique<Objects>(mResourceSystem, sceneRoot);
 
         if (getenv("OPENMW_DONT_PRECOMPILE") == nullptr)
         {
@@ -451,7 +451,7 @@ namespace MWRender
 
         mResourceSystem->getSceneManager()->setIncrementalCompileOperation(mViewer->getIncrementalCompileOperation());
 
-        mEffectManager.reset(new EffectManager(sceneRoot, mResourceSystem));
+        mEffectManager = std::make_unique<EffectManager>(sceneRoot, mResourceSystem);
 
         const std::string normalMapPattern = Settings::Manager::getString("normal map pattern", "Shaders");
         const std::string heightMapPattern = Settings::Manager::getString("normal height map pattern", "Shaders");
@@ -459,7 +459,7 @@ namespace MWRender
         const bool useTerrainNormalMaps = Settings::Manager::getBool("auto use terrain normal maps", "Shaders");
         const bool useTerrainSpecularMaps = Settings::Manager::getBool("auto use terrain specular maps", "Shaders");
 
-        mTerrainStorage.reset(new TerrainStorage(mResourceSystem, normalMapPattern, heightMapPattern, useTerrainNormalMaps, specularMapPattern, useTerrainSpecularMaps));
+        mTerrainStorage = std::make_unique<TerrainStorage>(mResourceSystem, normalMapPattern, heightMapPattern, useTerrainNormalMaps, specularMapPattern, useTerrainSpecularMaps);
         const float lodFactor = Settings::Manager::getFloat("lod factor", "Terrain");
 
         bool groundcover = Settings::Manager::getBool("enabled", "Groundcover");
@@ -474,18 +474,18 @@ namespace MWRender
             float maxCompGeometrySize = Settings::Manager::getFloat("max composite geometry size", "Terrain");
             maxCompGeometrySize = std::max(maxCompGeometrySize, 1.f);
             bool debugChunks = Settings::Manager::getBool("debug chunks", "Terrain");
-            mTerrain.reset(new Terrain::QuadTreeWorld(
+            mTerrain = std::make_unique<Terrain::QuadTreeWorld>(
                 sceneRoot, mRootNode, mResourceSystem, mTerrainStorage.get(), Mask_Terrain, Mask_PreCompile, Mask_Debug,
-                compMapResolution, compMapLevel, lodFactor, vertexLodMod, maxCompGeometrySize, debugChunks));
+                compMapResolution, compMapLevel, lodFactor, vertexLodMod, maxCompGeometrySize, debugChunks);
             if (Settings::Manager::getBool("object paging", "Terrain"))
             {
-                mObjectPaging.reset(new ObjectPaging(mResourceSystem->getSceneManager()));
+                mObjectPaging = std::make_unique<ObjectPaging>(mResourceSystem->getSceneManager());
                 static_cast<Terrain::QuadTreeWorld*>(mTerrain.get())->addChunkManager(mObjectPaging.get());
                 mResourceSystem->addResourceManager(mObjectPaging.get());
             }
         }
         else
-            mTerrain.reset(new Terrain::TerrainGrid(sceneRoot, mRootNode, mResourceSystem, mTerrainStorage.get(), Mask_Terrain, Mask_PreCompile, Mask_Debug));
+            mTerrain = std::make_unique<Terrain::TerrainGrid>(sceneRoot, mRootNode, mResourceSystem, mTerrainStorage.get(), Mask_Terrain, Mask_PreCompile, Mask_Debug);
 
         mTerrain->setTargetFrameRate(Settings::Manager::getFloat("target framerate", "Cells"));
 
@@ -494,7 +494,7 @@ namespace MWRender
             float density = Settings::Manager::getFloat("density", "Groundcover");
             density = std::clamp(density, 0.f, 1.f);
 
-            mGroundcover.reset(new Groundcover(mResourceSystem->getSceneManager(), density, groundcoverDistance, groundcoverStore));
+            mGroundcover = std::make_unique<Groundcover>(mResourceSystem->getSceneManager(), density, groundcoverDistance, groundcoverStore);
             static_cast<Terrain::QuadTreeWorld*>(mTerrain.get())->addChunkManager(mGroundcover.get());
             mResourceSystem->addResourceManager(mGroundcover.get());
         }
@@ -513,11 +513,11 @@ namespace MWRender
         resourceSystem->getSceneManager()->setSupportsNormalsRT(mPostProcessor->getSupportsNormalsRT());
 
         // water goes after terrain for correct waterculling order
-        mWater.reset(new Water(sceneRoot->getParent(0), sceneRoot, mResourceSystem, mViewer->getIncrementalCompileOperation(), resourcePath));
+        mWater = std::make_unique<Water>(sceneRoot->getParent(0), sceneRoot, mResourceSystem, mViewer->getIncrementalCompileOperation(), resourcePath);
 
-        mCamera.reset(new Camera(mViewer->getCamera()));
+        mCamera = std::make_unique<Camera>(mViewer->getCamera());
 
-        mScreenshotManager.reset(new ScreenshotManager(viewer, mRootNode, sceneRoot, mResourceSystem, mWater.get()));
+        mScreenshotManager = std::make_unique<ScreenshotManager>(viewer, mRootNode, sceneRoot, mResourceSystem, mWater.get());
 
         mViewer->setLightingMode(osgViewer::View::NO_LIGHT);
 
@@ -544,9 +544,9 @@ namespace MWRender
         sceneRoot->getOrCreateStateSet()->addUniform(new osg::Uniform("emissiveMult", 1.f));
         sceneRoot->getOrCreateStateSet()->addUniform(new osg::Uniform("specStrength", 1.f));
 
-        mFog.reset(new FogManager());
+        mFog = std::make_unique<FogManager>();
 
-        mSky.reset(new SkyManager(sceneRoot, resourceSystem->getSceneManager()));
+        mSky = std::make_unique<SkyManager>(sceneRoot, resourceSystem->getSceneManager());
         mSky->setCamera(mViewer->getCamera());
 
         source->setStateSetModes(*mRootNode->getOrCreateStateSet(), osg::StateAttribute::ON);

apps/openmw/mwrender/sky.cpp

@@ -303,10 +303,10 @@ namespace MWRender
         mAtmosphereNightUpdater = new AtmosphereNightUpdater(mSceneManager->getImageManager(), forceShaders);
         atmosphereNight->addUpdateCallback(mAtmosphereNightUpdater);
 
-        mSun.reset(new Sun(mEarlyRenderBinRoot, *mSceneManager));
+        mSun = std::make_unique<Sun>(mEarlyRenderBinRoot, *mSceneManager);
         mSun->setSunglare(mSunglareEnabled);
-        mMasser.reset(new Moon(mEarlyRenderBinRoot, *mSceneManager, Fallback::Map::getFloat("Moons_Masser_Size")/125, Moon::Type_Masser));
+        mMasser = std::make_unique<Moon>(mEarlyRenderBinRoot, *mSceneManager, Fallback::Map::getFloat("Moons_Masser_Size")/125, Moon::Type_Masser);
-        mSecunda.reset(new Moon(mEarlyRenderBinRoot, *mSceneManager, Fallback::Map::getFloat("Moons_Secunda_Size")/125, Moon::Type_Secunda));
+        mSecunda = std::make_unique<Moon>(mEarlyRenderBinRoot, *mSceneManager, Fallback::Map::getFloat("Moons_Secunda_Size")/125, Moon::Type_Secunda);
 
         mCloudNode = new osg::Group;
         mEarlyRenderBinRoot->addChild(mCloudNode);

apps/openmw/mwrender/water.cpp

@@ -456,7 +456,7 @@ Water::Water(osg::Group *parent, osg::Group* sceneRoot, Resource::ResourceSystem
     , mCullCallback(nullptr)
     , mShaderWaterStateSetUpdater(nullptr)
 {
-    mSimulation.reset(new RippleSimulation(mSceneRoot, resourceSystem));
+    mSimulation = std::make_unique<RippleSimulation>(mSceneRoot, resourceSystem);
 
     mWaterGeom = SceneUtil::createWaterGeometry(Constants::CellSizeInUnits*150, 40, 900);
     mWaterGeom->setDrawCallback(new DepthClampCallback);

apps/openmw/mwsound/movieaudiofactory.cpp

@@ -155,7 +155,7 @@ namespace MWSound
 
     std::unique_ptr<Video::MovieAudioDecoder> MovieAudioFactory::createDecoder(Video::VideoState* videoState)
     {
-        std::unique_ptr<MWSound::MovieAudioDecoder> decoder(new MWSound::MovieAudioDecoder(videoState));
+        auto decoder = std::make_unique<MWSound::MovieAudioDecoder>(videoState);
         decoder->setupFormat();
 
         MWBase::SoundManager *sndMgr = MWBase::Environment::get().getSoundManager();

apps/openmw/mwsound/openal_output.cpp

@@ -428,7 +428,7 @@ bool OpenAL_SoundStream::init(bool getLoudnessData)
     mBufferSize *= mFrameSize;
 
     if (getLoudnessData)
-        mLoudnessAnalyzer.reset(new Sound_Loudness(sLoudnessFPS, mSampleRate, chans, type));
+        mLoudnessAnalyzer = std::make_unique<Sound_Loudness>(sLoudnessFPS, mSampleRate, chans, type);
 
     mIsFinished = false;
     return true;
@@ -1501,7 +1501,7 @@ OpenAL_Output::OpenAL_Output(SoundManager &mgr)
   , mDevice(nullptr), mContext(nullptr)
   , mListenerPos(0.0f, 0.0f, 0.0f), mListenerEnv(Env_Normal)
   , mWaterFilter(0), mWaterEffect(0), mDefaultEffect(0), mEffectSlot(0)
-  , mStreamThread(new StreamThread)
+  , mStreamThread(std::make_unique<StreamThread>())
 {
 }
 

apps/openmw/mwworld/cellstore.cpp

@@ -792,7 +792,7 @@ namespace MWWorld
 
     void CellStore::readFog(ESM::ESMReader &reader)
     {
-        mFogState.reset(new ESM::FogState());
+        mFogState = std::make_unique<ESM::FogState>();
         mFogState->load(reader);
     }
 

apps/openmw/mwworld/class.cpp

@@ -117,12 +117,12 @@ namespace MWWorld
 
     std::unique_ptr<Action> Class::activate (const Ptr& ptr, const Ptr& actor) const
     {
-        return std::unique_ptr<Action> (new NullAction);
+        return std::make_unique<NullAction>();
     }
 
     std::unique_ptr<Action> Class::use (const Ptr& ptr, bool force) const
     {
-        return std::unique_ptr<Action> (new NullAction);
+        return std::make_unique<NullAction>();
     }
 
     ContainerStore& Class::getContainerStore (const Ptr& ptr) const
@@ -332,7 +332,7 @@ namespace MWWorld
     std::unique_ptr<Action> Class::defaultItemActivate(const Ptr &ptr, const Ptr &actor) const
     {
         if(!MWBase::Environment::get().getWindowManager()->isAllowed(MWGui::GW_Inventory))
-            return std::unique_ptr<Action>(new NullAction());
+            return std::make_unique<NullAction>();
 
         if(actor.getClass().isNpc() && actor.getClass().getNpcStats(actor).isWerewolf())
         {
@@ -340,13 +340,13 @@ namespace MWWorld
             auto& prng = MWBase::Environment::get().getWorld()->getPrng();
             const ESM::Sound *sound = store.get<ESM::Sound>().searchRandom("WolfItem", prng);
 
-            std::unique_ptr<MWWorld::Action> action(new MWWorld::FailedAction("#{sWerewolfRefusal}"));
+            std::unique_ptr<MWWorld::Action> action = std::make_unique<MWWorld::FailedAction>("#{sWerewolfRefusal}");
             if(sound) action->setSound(sound->mId);
 
             return action;
         }
 
-        std::unique_ptr<MWWorld::Action> action(new ActionTake(ptr));
+        std::unique_ptr<MWWorld::Action> action = std::make_unique<ActionTake>(ptr);
         action->setSound(getUpSoundId(ptr));
 
         return action;

apps/openmw/mwworld/scene.cpp

@@ -772,7 +772,7 @@ namespace MWWorld
     , mPreloadFastTravel(Settings::Manager::getBool("preload fast travel", "Cells"))
     , mPredictionTime(Settings::Manager::getFloat("prediction time", "Cells"))
     {
-        mPreloader.reset(new CellPreloader(rendering.getResourceSystem(), physics->getShapeManager(), rendering.getTerrain(), rendering.getLandManager()));
+        mPreloader = std::make_unique<CellPreloader>(rendering.getResourceSystem(), physics->getShapeManager(), rendering.getTerrain(), rendering.getLandManager());
         mPreloader->setWorkQueue(mRendering.getWorkQueue());
 
         rendering.getResourceSystem()->setExpiryDelay(Settings::Manager::getFloat("cache expiry delay", "Cells"));

apps/openmw/mwworld/worldimp.cpp

@@ -175,7 +175,7 @@ namespace MWWorld
             break;
         }
 
-        mCurrentDate.reset(new DateTimeManager());
+        mCurrentDate = std::make_unique<DateTimeManager>();
 
         fillGlobalVariables();
 
@@ -184,7 +184,7 @@ namespace MWWorld
 
         mSwimHeightScale = mStore.get<ESM::GameSetting>().find("fSwimHeightScale")->mValue.getFloat();
 
-        mPhysics.reset(new MWPhysics::PhysicsSystem(resourceSystem, rootNode));
+        mPhysics = std::make_unique<MWPhysics::PhysicsSystem>(resourceSystem, rootNode);
 
         if (Settings::Manager::getBool("enable", "Navigator"))
         {
@@ -197,13 +197,13 @@ namespace MWWorld
             mNavigator = DetourNavigator::makeNavigatorStub();
         }
 
-        mRendering.reset(new MWRender::RenderingManager(viewer, rootNode, resourceSystem, workQueue, resourcePath, *mNavigator, mGroundcoverStore));
+        mRendering = std::make_unique<MWRender::RenderingManager>(viewer, rootNode, resourceSystem, workQueue, resourcePath, *mNavigator, mGroundcoverStore);
-        mProjectileManager.reset(new ProjectileManager(mRendering->getLightRoot()->asGroup(), resourceSystem, mRendering.get(), mPhysics.get()));
+        mProjectileManager = std::make_unique<ProjectileManager>(mRendering->getLightRoot()->asGroup(), resourceSystem, mRendering.get(), mPhysics.get());
         mRendering->preloadCommonAssets();
 
-        mWeatherManager.reset(new MWWorld::WeatherManager(*mRendering, mStore));
+        mWeatherManager = std::make_unique<MWWorld::WeatherManager>(*mRendering, mStore);
 
-        mWorldScene.reset(new Scene(*this, *mRendering.get(), mPhysics.get(), *mNavigator));
+        mWorldScene = std::make_unique<Scene>(*this, *mRendering.get(), mPhysics.get(), *mNavigator);
     }
 
     void World::fillGlobalVariables()
@@ -231,7 +231,7 @@ namespace MWWorld
         // we don't want old weather to persist on a new game
         // Note that if reset later, the initial ChangeWeather that the chargen script calls will be lost.
         mWeatherManager.reset();
-        mWeatherManager.reset(new MWWorld::WeatherManager(*mRendering.get(), mStore));
+        mWeatherManager = std::make_unique<MWWorld::WeatherManager>(*mRendering.get(), mStore);
 
         if (!bypass)
         {
@@ -2443,7 +2443,7 @@ namespace MWWorld
     {
         const ESM::NPC *player = mStore.get<ESM::NPC>().find("player");
         if (!mPlayer)
-            mPlayer.reset(new MWWorld::Player(player));
+            mPlayer = std::make_unique<MWWorld::Player>(player);
         else
         {
             // Remove the old CharacterController

components/myguiplatform/myguidatamanager.cpp

@@ -21,8 +21,7 @@ void DataManager::setResourcePath(const std::string &path)
 MyGUI::IDataStream *DataManager::getData(const std::string &name) const
 {
     std::string fullpath = getDataPath(name);
-    std::unique_ptr<std::ifstream> stream;
+    auto stream = std::make_unique<std::ifstream>();
-    stream.reset(new std::ifstream);
     stream->open(fullpath, std::ios::binary);
     if (stream->fail())
     {

components/nifbullet/bulletnifloader.cpp

@@ -140,7 +140,7 @@ std::monostate fillTriangleMesh(std::unique_ptr<btTriangleMesh>& mesh, const Nif
     return handleNiGeometry(geometry, [&] (const auto& data)
     {
         if (mesh == nullptr)
-            mesh.reset(new btTriangleMesh(false));
+            mesh = std::make_unique<btTriangleMesh>(false);
         fillTriangleMesh(*mesh, data, transform);
         return std::monostate {};
     });
@@ -150,7 +150,7 @@ std::unique_ptr<btTriangleMesh> makeChildMesh(const Nif::NiGeometry& geometry)
 {
     return handleNiGeometry(geometry, [&] (const auto& data)
     {
-        std::unique_ptr<btTriangleMesh> mesh(new btTriangleMesh);
+        auto mesh = std::make_unique<btTriangleMesh>();
         fillTriangleMesh(*mesh, data, osg::Matrixf());
         return mesh;
     });
@@ -197,8 +197,8 @@ osg::ref_ptr<Resource::BulletShape> BulletNifLoader::load(const Nif::File& nif)
         {
             const btVector3 extents = Misc::Convert::toBullet(mShape->mCollisionBox.mExtents);
             const btVector3 center = Misc::Convert::toBullet(mShape->mCollisionBox.mCenter);
-            std::unique_ptr<btCompoundShape> compound (new btCompoundShape);
+            auto compound = std::make_unique<btCompoundShape>();
-            std::unique_ptr<btBoxShape> boxShape(new btBoxShape(extents));
+            auto boxShape = std::make_unique<btBoxShape>(extents);
             btTransform transform = btTransform::getIdentity();
             transform.setOrigin(center);
             compound->addChildShape(transform, boxShape.get());
@@ -226,7 +226,7 @@ osg::ref_ptr<Resource::BulletShape> BulletNifLoader::load(const Nif::File& nif)
         {
             btTransform trans;
             trans.setIdentity();
-            std::unique_ptr<btCollisionShape> child(new Resource::TriangleMeshShape(mStaticMesh.get(), true));
+            std::unique_ptr<btCollisionShape> child = std::make_unique<Resource::TriangleMeshShape>(mStaticMesh.get(), true);
             mCompoundShape->addChildShape(trans, child.get());
             child.release();
             mStaticMesh.release();
@@ -407,7 +407,7 @@ void BulletNifLoader::handleNiTriShape(const Nif::NiGeometry& niGeometry, const
         if (!mCompoundShape)
             mCompoundShape.reset(new btCompoundShape);
 
-        std::unique_ptr<Resource::TriangleMeshShape> childShape(new Resource::TriangleMeshShape(childMesh.get(), true));
+        auto childShape = std::make_unique<Resource::TriangleMeshShape>(childMesh.get(), true);
         childMesh.release();
 
         float scale = niGeometry.trafo.scale;

components/resource/resourcesystem.cpp

@@ -13,10 +13,10 @@ namespace Resource
     ResourceSystem::ResourceSystem(const VFS::Manager *vfs)
         : mVFS(vfs)
     {
-        mNifFileManager.reset(new NifFileManager(vfs));
+        mNifFileManager = std::make_unique<NifFileManager>(vfs);
-        mImageManager.reset(new ImageManager(vfs));
+        mImageManager = std::make_unique<ImageManager>(vfs);
-        mSceneManager.reset(new SceneManager(vfs, mImageManager.get(), mNifFileManager.get()));
+        mSceneManager = std::make_unique<SceneManager>(vfs, mImageManager.get(), mNifFileManager.get());
-        mKeyframeManager.reset(new KeyframeManager(vfs, mSceneManager.get()));
+        mKeyframeManager = std::make_unique<KeyframeManager>(vfs, mSceneManager.get());
 
         addResourceManager(mNifFileManager.get());
         addResourceManager(mKeyframeManager.get());

components/sceneutil/skeleton.cpp

@@ -69,7 +69,7 @@ Bone* Skeleton::getBone(const std::string &name)
 
     if (!mRootBone.get())
     {
-        mRootBone.reset(new Bone);
+        mRootBone = std::make_unique<Bone>();
     }
 
     Bone* bone = mRootBone.get();

components/terrain/quadtreeworld.cpp

@@ -287,7 +287,7 @@ QuadTreeWorld::QuadTreeWorld(osg::Group *parent, osg::Group *compileRoot, Resour
 
     if (mDebugTerrainChunks)
     {
-        mDebugChunkManager = std::unique_ptr<DebugChunkManager>(new DebugChunkManager(mResourceSystem->getSceneManager(), mStorage, borderMask));
+        mDebugChunkManager = std::make_unique<DebugChunkManager>(mResourceSystem->getSceneManager(), mStorage, borderMask);
         addChunkManager(mDebugChunkManager.get());
     }
 }

components/terrain/world.cpp

@@ -41,10 +41,10 @@ World::World(osg::Group* parent, osg::Group* compileRoot, Resource::ResourceSyst
 
     mParent->addChild(mTerrainRoot);
 
-    mTextureManager.reset(new TextureManager(mResourceSystem->getSceneManager()));
+    mTextureManager = std::make_unique<TextureManager>(mResourceSystem->getSceneManager());
-    mChunkManager.reset(new ChunkManager(mStorage, mResourceSystem->getSceneManager(), mTextureManager.get(), mCompositeMapRenderer));
+    mChunkManager = std::make_unique<ChunkManager>(mStorage, mResourceSystem->getSceneManager(), mTextureManager.get(), mCompositeMapRenderer);
     mChunkManager->setNodeMask(nodeMask);
-    mCellBorder.reset(new CellBorder(this,mTerrainRoot.get(),borderMask,mResourceSystem->getSceneManager()));
+    mCellBorder = std::make_unique<CellBorder>(this,mTerrainRoot.get(),borderMask,mResourceSystem->getSceneManager());
 
     mResourceSystem->addResourceManager(mChunkManager.get());
     mResourceSystem->addResourceManager(mTextureManager.get());