teamnwah/openmw-tes3coop
2
0
Fork 1
forked from mirror/openmw-tes3mp
Code Issues Pull requests 1 Releases Wiki Activity

Merge remote-tracking branch 'mark76/multiple_esm_esp' into nif-cleanup

Browse source
This commit is contained in:
scrawl 2012-07-21 23:50:56 +02:00
commit 546b640022
12 changed files with 148 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
apps/openmw/engine.cpp
View file

@ -207,18 +207,32 @@ void OMW::Engine::setCell (const std::string& cellName)
// Set master file (esm)
// - If the given name does not have an extension, ".esm" is added automatically
// - Currently OpenMW only supports one master at the same time.
void OMW::Engine::addMaster (const std::string& master)
{
assert (mMaster.empty());
mMaster = master;
mMaster.push_back(master);
std::string &str = mMaster.back();
// Append .esm if not already there
std::string::size_type sep = mMaster.find_last_of (".");
// Append .esm if not already there
std::string::size_type sep = str.find_last_of (".");
if (sep == std::string::npos)
{
mMaster += ".esm";
str += ".esm";
}
}
// Add plugin file (esp)
void OMW::Engine::addPlugin (const std::string& plugin)
{
mPlugins.push_back(plugin);
std::string &str = mPlugins.back();
// Append .esp if not already there
std::string::size_type sep = str.find_last_of (".");
if (sep == std::string::npos)
{
str += ".esp";
}
}
@ -320,8 +334,8 @@ void OMW::Engine::go()
MWGui::CursorReplace replacer;
// Create the world
mEnvironment.setWorld (new MWWorld::World (*mOgre, mFileCollections, mMaster,
mResDir, mNewGame, mEncoding, mFallbackMap));
mEnvironment.setWorld( new MWWorld::World (*mOgre, mFileCollections, mMaster, mPlugins,
mResDir, mNewGame, mEncoding, mFallbackMap) );
// Create window manager - this manages all the MW-specific GUI windows
MWScript::registerExtensions (mExtensions);

8
apps/openmw/engine.hpp
View file

@ -64,7 +64,8 @@ namespace OMW
boost::filesystem::path mResDir;
OEngine::Render::OgreRenderer *mOgre;
std::string mCellName;
std::string mMaster;
std::vector<std::string> mMaster;
std::vector<std::string> mPlugins;
int mFpsLevel;
bool mDebug;
bool mVerboseScripts;
@ -120,9 +121,12 @@ namespace OMW
/// Set master file (esm)
/// - If the given name does not have an extension, ".esm" is added automatically
/// - Currently OpenMW only supports one master at the same time.
void addMaster(const std::string& master);
/// Same as "addMaster", but for plugin files (esp)
/// - If the given name does not have an extension, ".esp" is added automatically
void addPlugin(const std::string& plugin);
/// Enable fps counter
void showFPS(int level);

26
apps/openmw/main.cpp
View file

@ -224,19 +224,23 @@ bool parseOptions (int argc, char** argv, OMW::Engine& engine, Files::Configurat
master.push_back("Morrowind");
}
if (master.size() > 1)
{
std::cout
<< "Ignoring all but the first master file (multiple master files not yet supported)."
<< std::endl;
}
engine.addMaster(master[0]);
StringsVector plugin = variables["plugin"].as<StringsVector>();
if (!plugin.empty())
{
std::cout << "Ignoring plugin files (plugins not yet supported)." << std::endl;
int cnt = master.size() + plugin.size();
if (cnt > 255)
{
std::cerr
<< "Error: Trying to load more than 255 master and plugin files! This will break all combaibility and is not supported!"
<< std::endl;
return false;
}
for (std::vector<std::string>::size_type i = 0; i < master.size(); i++)
{
engine.addMaster(master[i]);
}
for (std::vector<std::string>::size_type i = 0; i < plugin.size(); i++)
{
engine.addPlugin(plugin[i]);
}
// startup-settings
engine.setCell(variables["start"].as<std::string>());

24
apps/openmw/mwrender/terrain.cpp
View file

@ -161,7 +161,7 @@ namespace MWRender
std::map<uint16_t, int> indexes;
initTerrainTextures(&terrainData, cellX, cellY,
x * numTextures, y * numTextures,
numTextures, indexes);
numTextures, indexes, land->plugin);
if (mTerrainGroup.getTerrain(terrainX, terrainY) == NULL)
{
@ -223,8 +223,14 @@ namespace MWRender
void TerrainManager::initTerrainTextures(Terrain::ImportData* terrainData,
int cellX, int cellY,
int fromX, int fromY, int size,
std::map<uint16_t, int>& indexes)
std::map<uint16_t, int>& indexes,
size_t plugin)
{
// FIXME: In a multiple esm configuration, we have multiple palettes. Since this code
// crosses cell boundaries, we no longer have a unique terrain palette. Instead, we need
// to adopt the following code for a dynamic palette. And this is evil - the current design
// does not work well for this task...
assert(terrainData != NULL && "Must have valid terrain data");
assert(fromX >= 0 && fromY >= 0 &&
"Can't get a terrain texture on terrain outside the current cell");
@ -237,12 +243,16 @@ namespace MWRender
//
//If we don't sort the ltex indexes, the splatting order may differ between
//cells which may lead to inconsistent results when shading between cells
int num = MWBase::Environment::get().getWorld()->getStore().landTexts.getSizePlugin(plugin);
std::set<uint16_t> ltexIndexes;
for ( int y = fromY - 1; y < fromY + size + 1; y++ )
{
for ( int x = fromX - 1; x < fromX + size + 1; x++ )
{
ltexIndexes.insert(getLtexIndexAt(cellX, cellY, x, y));
int idx = getLtexIndexAt(cellX, cellY, x, y);
if (idx > num)
idx = 0;
ltexIndexes.insert(idx);
}
}
@ -254,7 +264,7 @@ namespace MWRender
iter != ltexIndexes.end();
++iter )
{
const uint16_t ltexIndex = *iter;
uint16_t ltexIndex = *iter;
//this is the base texture, so we can ignore this at present
if ( ltexIndex == baseTexture )
{
@ -267,8 +277,10 @@ namespace MWRender
{
//NB: All vtex ids are +1 compared to the ltex ids
assert( (int)MWBase::Environment::get().getWorld()->getStore().landTexts.getSize() >= (int)ltexIndex - 1 &&
/*
assert( (int)mEnvironment.mWorld->getStore().landTexts.getSizePlugin(plugin) >= (int)ltexIndex - 1 &&
"LAND.VTEX must be within the bounds of the LTEX array");
*/
std::string texture;
if ( ltexIndex == 0 )
@ -277,7 +289,7 @@ namespace MWRender
}
else
{
texture = MWBase::Environment::get().getWorld()->getStore().landTexts.search(ltexIndex-1)->texture;
texture = MWBase::Environment::get().getWorld()->getStore().landTexts.search(ltexIndex-1, plugin)->texture;
//TODO this is needed due to MWs messed up texture handling
texture = texture.substr(0, texture.rfind(".")) + ".dds";
}

5
apps/openmw/mwrender/terrain.hpp
View file

@ -71,11 +71,14 @@ namespace MWRender{
* @param size the size (number of splats) to get
* @param indexes a mapping of ltex index to the terrain texture layer that
* can be used by initTerrainBlendMaps
* @param plugin the index of the plugin providing the texture list for this
* cell data; required because MW uses texture data on a per-plugin base
*/
void initTerrainTextures(Ogre::Terrain::ImportData* terrainData,
int cellX, int cellY,
int fromX, int fromY, int size,
std::map<uint16_t, int>& indexes);
std::map<uint16_t, int>& indexes,
size_t plugin = 0);
/**
* Creates the blend (splatting maps) for the given terrain from the ltex data.

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

@ -167,7 +167,8 @@ namespace MWWorld
World::World (OEngine::Render::OgreRenderer& renderer,
const Files::Collections& fileCollections,
const std::string& master, const boost::filesystem::path& resDir, bool newGame,
const std::vector<std::string>& master,
const std::vector<std::string>& plugins, const boost::filesystem::path& resDir, bool newGame,
const std::string& encoding, std::map<std::string,std::string> fallbackMap)
: mPlayer (0), mLocalScripts (mStore), mGlobalVariables (0),
mSky (true), mNextDynamicRecord (0), mCells (mStore, mEsm),
@ -180,15 +181,32 @@ namespace MWWorld
mWeatherManager = new MWWorld::WeatherManager(mRendering);
boost::filesystem::path masterPath (fileCollections.getCollection (".esm").getPath (master));
int idx = 0;
for (std::vector<std::string>::size_type i = 0; i < master.size(); i++, idx++)
{
boost::filesystem::path masterPath (fileCollections.getCollection (".esm").getPath (master[i]));
std::cout << "Loading ESM " << masterPath.string() << "\n";
std::cout << "Loading ESM " << masterPath.string() << "\n";
// This parses the ESM file and loads a sample cell
mEsm.setEncoding(encoding);
mEsm.open (masterPath.string());
mEsm.setIndex(idx);
mStore.load (mEsm);
}
// This parses the ESM file and loads a sample cell
mEsm.setEncoding(encoding);
mEsm.open (masterPath.string());
mStore.load (mEsm);
for (std::vector<std::string>::size_type i = 0; i < plugins.size(); i++, idx++)
{
boost::filesystem::path pluginPath (fileCollections.getCollection (".esp").getPath (plugins[i]));
std::cout << "Loading ESP " << pluginPath.string() << "\n";
// This parses the ESP file and loads a sample cell
mEsm.setEncoding(encoding);
mEsm.open (pluginPath.string());
mEsm.setIndex(idx);
mStore.load (mEsm);
}
MWRender::Player* play = &(mRendering->getPlayer());
mPlayer = new MWWorld::Player (play, mStore.npcs.find ("player"), *this);
mPhysics->addActor (mPlayer->getPlayer().getRefData().getHandle(), "", Ogre::Vector3 (0, 0, 0));

3
apps/openmw/mwworld/worldimp.hpp
View file

@ -93,7 +93,8 @@ namespace MWWorld
World (OEngine::Render::OgreRenderer& renderer,
const Files::Collections& fileCollections,
const std::string& master, const boost::filesystem::path& resDir, bool newGame,
const std::vector<std::string>& master,
const std::vector<std::string>& plugins, const boost::filesystem::path& resDir, bool newGame,
const std::string& encoding, std::map<std::string,std::string> fallbackMap);
virtual ~World();

8
components/esm/esm_reader.hpp
View file

@ -189,6 +189,14 @@ public:
void openRaw(const std::string &file);
// This is a quick hack for multiple esm/esp files. Each plugin introduces its own
// terrain palette, but ESMReader does not pass a reference to the correct plugin
// to the individual load() methods. This hack allows to pass this reference
// indirectly to the load() method.
int idx;
void setIndex(const int index) {idx = index;}
const int getIndex() {return idx;}
/*************************************************************************
*
* Medium-level reading shortcuts

1
components/esm/loadland.cpp
View file

@ -23,6 +23,7 @@ Land::~Land()
void Land::load(ESMReader &esm)
{
mEsm = &esm;
plugin = mEsm->getIndex();
// Get the grid location
esm.getSubNameIs("INTV");

1
components/esm/loadland.hpp
View file

@ -17,6 +17,7 @@ struct Land
int flags; // Only first four bits seem to be used, don't know what
// they mean.
int X, Y; // Map coordinates.
int plugin; // Plugin index, used to reference the correct material palette.
// File context. This allows the ESM reader to be 'reset' to this
// location later when we are ready to load the full data set.

50
components/esm_store/reclists.hpp
View file

@ -26,6 +26,7 @@ namespace ESMS
virtual void load(ESMReader &esm, const std::string &id) = 0;
virtual int getSize() = 0;
virtual void remove(const std::string &id) {};
virtual void listIdentifier (std::vector<std::string>& identifier) const = 0;
static std::string toLower (const std::string& name)
@ -57,6 +58,14 @@ namespace ESMS
list[id2].load(esm);
}
// Delete the given object ID
void remove(const std::string &id)
{
std::string id2 = toLower (id);
list.erase(id2);
}
// Find the given object ID, or return NULL if not found.
const X* search(const std::string &id) const
{
@ -268,38 +277,57 @@ namespace ESMS
{
virtual ~LTexList() {}
// TODO: For multiple ESM/ESP files we need one list per file.
std::vector<LandTexture> ltex;
// For multiple ESM/ESP files we need one list per file.
typedef std::vector<LandTexture> LandTextureList;
std::vector<LandTextureList> ltex;
LTexList()
{
ltex.push_back(LandTextureList());
LandTextureList &ltexl = ltex[0];
// More than enough to hold Morrowind.esm.
ltex.reserve(128);
ltexl.reserve(128);
}
const LandTexture* search(size_t index) const
const LandTexture* search(size_t index, size_t plugin) const
{
assert(index < ltex.size());
return &ltex.at(index);
assert(plugin < ltex.size());
const LandTextureList &ltexl = ltex[plugin];
assert(index < ltexl.size());
return &ltexl.at(index);
}
int getSize() { return ltex.size(); }
int getSize() const { return ltex.size(); }
virtual void listIdentifier (std::vector<std::string>& identifier) const {}
int getSizePlugin(size_t plugin) { assert(plugin < ltex.size()); return ltex[plugin].size(); }
int getSizePlugin(size_t plugin) const { assert(plugin < ltex.size()); return ltex[plugin].size(); }
void load(ESMReader &esm, const std::string &id)
virtual void listIdentifier (std::vector<std::string>& identifier) const {}
void load(ESMReader &esm, const std::string &id, size_t plugin)
{
LandTexture lt;
lt.load(esm);
lt.id = id;
// Make sure we have room for the structure
if(lt.index + 1 > (int)ltex.size())
ltex.resize(lt.index+1);
if (plugin >= ltex.size()) {
ltex.resize(plugin+1);
}
LandTextureList &ltexl = ltex[plugin];
if(lt.index + 1 > (int)ltexl.size())
ltexl.resize(lt.index+1);
// Store it
ltex[lt.index] = lt;
ltexl[lt.index] = lt;
}
void load(ESMReader &esm, const std::string &id)
{
size_t plugin = esm.getIndex();
load(esm, id, plugin);
}
};

7
components/esm_store/store.cpp
View file

@ -67,6 +67,13 @@ void ESMStore::load(ESMReader &esm)
{
// Load it
std::string id = esm.getHNOString("NAME");
// ... unless it got deleted!
if (esm.isNextSub("DELE")) {
esm.skipRecord();
all.erase(id);
it->second->remove(id);
continue;
}
it->second->load(esm, id);
if (n.val==ESM::REC_DIAL)