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

Replace new with make_unique in openmw

Browse source
This commit is contained in:
Evil Eye 2022-05-29 13:24:48 +02:00
parent a95b6e050a
commit 3c83117e99
47 changed files with 137 additions and 142 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
apps/openmw/main.cpp
View file

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

4
apps/openmw/mwclass/activator.cpp
View file

@ -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>();
}

2
apps/openmw/mwclass/apparatus.cpp
View file

@ -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

2
apps/openmw/mwclass/armor.cpp
View file

@ -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));

6
apps/openmw/mwclass/book.cpp
View file

@ -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

2
apps/openmw/mwclass/clothing.cpp
View file

@ -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));

14
apps/openmw/mwclass/container.cpp
View file

@ -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 action;
return std::make_unique<MWWorld::ActionHarvest>(ptr);
}
std::unique_ptr<MWWorld::Action> action (new MWWorld::ActionOpen(ptr));
return action;
return std::make_unique<MWWorld::ActionOpen>(ptr);
}
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;
}

14
apps/openmw/mwclass/creature.cpp
View file

@ -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>();

13
apps/openmw/mwclass/door.cpp
View file

@ -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 action;
return std::make_unique<MWWorld::FailedAction>();
}
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;
}

2
apps/openmw/mwclass/ingredient.cpp
View file

@ -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");

6
apps/openmw/mwclass/light.cpp
View file

@ -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));

2
apps/openmw/mwclass/lockpick.cpp
View file

@ -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));

5
apps/openmw/mwclass/misc.cpp
View file

@ -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());
else
return std::unique_ptr<MWWorld::Action>(new MWWorld::ActionSoulgem(ptr));
return std::make_unique<MWWorld::NullAction>();
return std::make_unique<MWWorld::ActionSoulgem>(ptr);
}
bool Miscellaneous::canSell (const MWWorld::ConstPtr& item, int npcServices) const

18
apps/openmw/mwclass/npc.cpp
View file

@ -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)

2
apps/openmw/mwclass/probe.cpp
View file

@ -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));

2
apps/openmw/mwclass/repair.cpp
View file

@ -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

2
apps/openmw/mwclass/weapon.cpp
View file

@ -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));

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

@ -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 ();

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

@ -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);

2
apps/openmw/mwgui/loadingscreen.cpp
View file

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

12
apps/openmw/mwgui/mapwindow.cpp
View file

@ -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));

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

@ -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));

2
apps/openmw/mwgui/savegamedialog.cpp
View file

@ -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));

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

@ -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));

6
apps/openmw/mwgui/windowmanagerimp.cpp
View file

@ -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()

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

@ -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();

6
apps/openmw/mwmechanics/aicombat.cpp
View file

@ -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;

12
apps/openmw/mwmechanics/aicombataction.cpp
View file

@ -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);

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

@ -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;

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

@ -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;

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

@ -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;

16
apps/openmw/mwmechanics/aisequence.cpp
View file

@ -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:

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

@ -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;

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

@ -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;

2
apps/openmw/mwphysics/actor.cpp
View file

@ -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());

6
apps/openmw/mwphysics/physicssystem.cpp
View file

@ -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());
mWaterCollisionShape.reset(new btStaticPlaneShape(btVector3(0,0,1), mWaterHeight));
mWaterCollisionObject = std::make_unique<btCollisionObject>();
mWaterCollisionShape = std::make_unique<btStaticPlaneShape>(btVector3(0,0,1), mWaterHeight);
mWaterCollisionObject->setCollisionShape(mWaterCollisionShape.get());
mTaskScheduler->addCollisionObject(mWaterCollisionObject.get(), CollisionType_Water,
CollisionType_Actor|CollisionType_Projectile);

4
apps/openmw/mwrender/creatureanimation.cpp
View file

@ -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);

4
apps/openmw/mwrender/localmap.cpp
View file

@ -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();

38
apps/openmw/mwrender/renderingmanager.cpp
View file

@ -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"),
parseNavMeshMode(Settings::Manager::getString("nav mesh render mode", "Navigator"))));
mActorsPaths.reset(new ActorsPaths(mRootNode, Settings::Manager::getBool("enable agents paths render", "Navigator")));
mRecastMesh.reset(new RecastMesh(mRootNode, Settings::Manager::getBool("enable recast mesh render", "Navigator")));
mPathgrid.reset(new Pathgrid(mRootNode));
mNavMesh = std::make_unique<NavMesh>(mRootNode, mWorkQueue, Settings::Manager::getBool("enable nav mesh render", "Navigator"),
parseNavMeshMode(Settings::Manager::getString("nav mesh render mode", "Navigator")));
mActorsPaths = std::make_unique<ActorsPaths>(mRootNode, Settings::Manager::getBool("enable agents paths render", "Navigator"));
mRecastMesh = std::make_unique<RecastMesh>(mRootNode, Settings::Manager::getBool("enable recast mesh render", "Navigator"));
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);

6
apps/openmw/mwrender/sky.cpp
View file

@ -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));
mSecunda.reset(new Moon(mEarlyRenderBinRoot, *mSceneManager, Fallback::Map::getFloat("Moons_Secunda_Size")/125, Moon::Type_Secunda));
mMasser = std::make_unique<Moon>(mEarlyRenderBinRoot, *mSceneManager, Fallback::Map::getFloat("Moons_Masser_Size")/125, Moon::Type_Masser);
mSecunda = std::make_unique<Moon>(mEarlyRenderBinRoot, *mSceneManager, Fallback::Map::getFloat("Moons_Secunda_Size")/125, Moon::Type_Secunda);
mCloudNode = new osg::Group;
mEarlyRenderBinRoot->addChild(mCloudNode);

2
apps/openmw/mwrender/water.cpp
View file

@ -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);

2
apps/openmw/mwsound/movieaudiofactory.cpp
View file

@ -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();

4
apps/openmw/mwsound/openal_output.cpp
View file

@ -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>())
{
}

2
apps/openmw/mwworld/cellstore.cpp
View file

@ -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);
}

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

@ -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;

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

@ -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"));

16
apps/openmw/mwworld/worldimp.cpp
View file

@ -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));
mProjectileManager.reset(new ProjectileManager(mRendering->getLightRoot()->asGroup(), resourceSystem, mRendering.get(), mPhysics.get()));
mRendering = std::make_unique<MWRender::RenderingManager>(viewer, rootNode, resourceSystem, workQueue, resourcePath, *mNavigator, mGroundcoverStore);
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