Replace new with make_unique in openmw

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