mirror/openmw-tes3mp
1
0
Fork 1
mirror of https://github.com/TES3MP/openmw-tes3mp.git synced 2025-01-30 02:15:32 +00:00
Code Issues Releases Wiki Activity

Move global map render to the worker thread

Browse source
This commit is contained in:
scrawl 2017-02-14 03:55:29 +01:00
parent 026a05718f
commit 72c6b11cf8
7 changed files with 218 additions and 141 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
apps/openmw/engine.cpp
View file

@ -496,7 +496,7 @@ void OMW::Engine::prepareEngine (Settings::Manager & settings)
guiRoot->setName("GUI Root");
guiRoot->setNodeMask(MWRender::Mask_GUI);
rootNode->addChild(guiRoot);
MWGui::WindowManager* window = new MWGui::WindowManager(mViewer, guiRoot, mResourceSystem.get(),
MWGui::WindowManager* window = new MWGui::WindowManager(mViewer, guiRoot, mResourceSystem.get(), mWorkQueue.get(),
mCfgMgr.getLogPath().string() + std::string("/"), myguiResources,
mScriptConsoleMode, mTranslationDataStorage, mEncoding, mExportFonts, mFallbackMap,
Version::getOpenmwVersionDescription(mResDir.string()));

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

@ -622,7 +622,7 @@ namespace MWGui
// ------------------------------------------------------------------------------------------
MapWindow::MapWindow(CustomMarkerCollection &customMarkers, DragAndDrop* drag, MWRender::LocalMap* localMapRender)
MapWindow::MapWindow(CustomMarkerCollection &customMarkers, DragAndDrop* drag, MWRender::LocalMap* localMapRender, SceneUtil::WorkQueue* workQueue)
: WindowPinnableBase("openmw_map_window.layout")
, LocalMapBase(customMarkers, localMapRender)
, NoDrop(drag, mMainWidget)
@ -632,7 +632,7 @@ namespace MWGui
, mGlobal(false)
, mEventBoxGlobal(NULL)
, mEventBoxLocal(NULL)
, mGlobalMapRender(new MWRender::GlobalMap(localMapRender->getRoot()))
, mGlobalMapRender(new MWRender::GlobalMap(localMapRender->getRoot(), workQueue))
, mEditNoteDialog()
{
static bool registered = false;
@ -774,19 +774,11 @@ namespace MWGui
mLastScrollWindowCoordinates = currentCoordinates;
}
void MapWindow::renderGlobalMap(Loading::Listener* loadingListener)
void MapWindow::renderGlobalMap()
{
mGlobalMapRender->render(loadingListener);
mGlobalMapRender->render();
mGlobalMap->setCanvasSize (mGlobalMapRender->getWidth(), mGlobalMapRender->getHeight());
mGlobalMapImage->setSize(mGlobalMapRender->getWidth(), mGlobalMapRender->getHeight());
mGlobalMapTexture.reset(new 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()));
mGlobalMapOverlay->setRenderItemTexture(mGlobalMapOverlayTexture.get());
mGlobalMapOverlay->getSubWidgetMain()->_setUVSet(MyGUI::FloatRect(0.f, 0.f, 1.f, 1.f));
}
MapWindow::~MapWindow()
@ -940,6 +932,8 @@ namespace MWGui
void MapWindow::open()
{
ensureGlobalMapLoaded();
globalMapUpdatePlayer();
}
@ -984,6 +978,20 @@ namespace MWGui
rotatingSubskin->setAngle(angle);
}
void MapWindow::ensureGlobalMapLoaded()
{
if (!mGlobalMapTexture.get())
{
mGlobalMapTexture.reset(new 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()));
mGlobalMapOverlay->setRenderItemTexture(mGlobalMapOverlayTexture.get());
mGlobalMapOverlay->getSubWidgetMain()->_setUVSet(MyGUI::FloatRect(0.f, 0.f, 1.f, 1.f));
}
}
void MapWindow::clear()
{
mMarkers.clear();

11
apps/openmw/mwgui/mapwindow.hpp
View file

@ -33,6 +33,11 @@ namespace Loading
class Listener;
}
namespace SceneUtil
{
class WorkQueue;
}
namespace MWGui
{
@ -193,14 +198,14 @@ namespace MWGui
class MapWindow : public MWGui::WindowPinnableBase, public LocalMapBase, public NoDrop
{
public:
MapWindow(CustomMarkerCollection& customMarkers, DragAndDrop* drag, MWRender::LocalMap* localMapRender);
MapWindow(CustomMarkerCollection& customMarkers, DragAndDrop* drag, MWRender::LocalMap* localMapRender, SceneUtil::WorkQueue* workQueue);
virtual ~MapWindow();
void setCellName(const std::string& cellName);
virtual void setAlpha(float alpha);
void renderGlobalMap(Loading::Listener* loadingListener);
void renderGlobalMap();
/// adds the marker to the global map
/// @param name The ESM::Cell::mName
@ -212,6 +217,8 @@ namespace MWGui
void setGlobalMapPlayerPosition (float worldX, float worldY);
void setGlobalMapPlayerDir(const float x, const float y);
void ensureGlobalMapLoaded();
virtual void open();
void onFrame(float dt);

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

@ -30,6 +30,8 @@
#include <components/resource/resourcesystem.hpp>
#include <components/resource/imagemanager.hpp>
#include <components/sceneutil/workqueue.hpp>
#include <components/translation/translation.hpp>
#include <components/myguiplatform/myguiplatform.hpp>
@ -115,11 +117,12 @@ namespace MWGui
{
WindowManager::WindowManager(
osgViewer::Viewer* viewer, osg::Group* guiRoot, Resource::ResourceSystem* resourceSystem
, const std::string& logpath, const std::string& resourcePath, bool consoleOnlyScripts,
osgViewer::Viewer* viewer, osg::Group* guiRoot, Resource::ResourceSystem* resourceSystem, SceneUtil::WorkQueue* workQueue,
const std::string& logpath, const std::string& resourcePath, bool consoleOnlyScripts,
Translation::Storage& translationDataStorage, ToUTF8::FromType encoding, bool exportFonts, const std::map<std::string, std::string>& fallbackMap, const std::string& versionDescription)
: mStore(NULL)
, mResourceSystem(resourceSystem)
, mWorkQueue(workQueue)
, mViewer(viewer)
, mConsoleOnlyScripts(consoleOnlyScripts)
, mCurrentModals()
@ -285,7 +288,7 @@ namespace MWGui
mRecharge = new Recharge();
mMenu = new MainMenu(w, h, mResourceSystem->getVFS(), mVersionDescription);
mLocalMapRender = new MWRender::LocalMap(mViewer->getSceneData()->asGroup());
mMap = new MapWindow(mCustomMarkers, mDragAndDrop, mLocalMapRender);
mMap = new MapWindow(mCustomMarkers, mDragAndDrop, mLocalMapRender, mWorkQueue);
trackWindow(mMap, "map");
mStatsWindow = new StatsWindow(mDragAndDrop);
trackWindow(mStatsWindow, "stats");
@ -373,7 +376,7 @@ namespace MWGui
void WindowManager::renderWorldMap()
{
mMap->renderGlobalMap(mLoadingScreen);
mMap->renderGlobalMap();
}
void WindowManager::setNewGame(bool newgame)

10
apps/openmw/mwgui/windowmanagerimp.hpp
View file

@ -9,6 +9,8 @@
#include <stack>
#include <osg/ref_ptr>
#include "../mwbase/windowmanager.hpp"
#include <components/settings/settings.hpp>
@ -57,6 +59,11 @@ namespace Resource
class ResourceSystem;
}
namespace SceneUtil
{
class WorkQueue;
}
namespace SDLUtil
{
class SDLCursorManager;
@ -119,7 +126,7 @@ namespace MWGui
typedef std::pair<std::string, int> Faction;
typedef std::vector<Faction> FactionList;
WindowManager(osgViewer::Viewer* viewer, osg::Group* guiRoot, Resource::ResourceSystem* resourceSystem,
WindowManager(osgViewer::Viewer* viewer, osg::Group* guiRoot, Resource::ResourceSystem* resourceSystem, SceneUtil::WorkQueue* workQueue,
const std::string& logpath, const std::string& cacheDir, bool consoleOnlyScripts,
Translation::Storage& translationDataStorage, ToUTF8::FromType encoding, bool exportFonts, const std::map<std::string,std::string>& fallbackMap, const std::string& versionDescription);
virtual ~WindowManager();
@ -382,6 +389,7 @@ namespace MWGui
private:
const MWWorld::ESMStore* mStore;
Resource::ResourceSystem* mResourceSystem;
osg::ref_ptr<SceneUtil::WorkQueue> mWorkQueue;
osgMyGUI::Platform* mGuiPlatform;
osgViewer::Viewer* mViewer;

272
apps/openmw/mwrender/globalmap.cpp
View file

@ -15,6 +15,8 @@
#include <components/settings/settings.hpp>
#include <components/files/memorystream.hpp>
#include <components/sceneutil/workqueue.hpp>
#include <components/esm/globalmap.hpp>
#include "../mwbase/environment.hpp"
@ -95,8 +97,132 @@ namespace
namespace MWRender
{
GlobalMap::GlobalMap(osg::Group* root)
class CreateMapWorkItem : public SceneUtil::WorkItem
{
public:
CreateMapWorkItem(int width, int height, int minX, int minY, int maxX, int maxY, int cellSize, const MWWorld::Store<ESM::Land>& landStore)
: mWidth(width), mHeight(height), mMinX(minX), mMinY(minY), mMaxX(maxX), mMaxY(maxY), mCellSize(cellSize), mLandStore(landStore)
{
}
virtual void doWork()
{
osg::ref_ptr<osg::Image> image = new osg::Image;
image->allocateImage(mWidth, mHeight, 1, GL_RGB, GL_UNSIGNED_BYTE);
unsigned char* data = image->data();
osg::ref_ptr<osg::Image> alphaImage = new osg::Image;
alphaImage->allocateImage(mWidth, mHeight, 1, GL_ALPHA, GL_UNSIGNED_BYTE);
unsigned char* alphaData = alphaImage->data();
for (int x = mMinX; x <= mMaxX; ++x)
{
for (int y = mMinY; y <= mMaxY; ++y)
{
const ESM::Land* land = mLandStore.search (x,y);
for (int cellY=0; cellY<mCellSize; ++cellY)
{
for (int cellX=0; cellX<mCellSize; ++cellX)
{
int vertexX = static_cast<int>(float(cellX)/float(mCellSize) * 9);
int vertexY = static_cast<int>(float(cellY) / float(mCellSize) * 9);
int texelX = (x-mMinX) * mCellSize + cellX;
int texelY = (y-mMinY) * mCellSize + cellY;
unsigned char r,g,b;
float y2 = 0;
if (land && (land->mDataTypes & ESM::Land::DATA_WNAM))
y2 = (land->mWnam[vertexY * 9 + vertexX] << 4) / 2048.f;
else
y2 = (SCHAR_MIN << 4) / 2048.f;
if (y2 < 0)
{
r = static_cast<unsigned char>(14 * y2 + 38);
g = static_cast<unsigned char>(20 * y2 + 56);
b = static_cast<unsigned char>(18 * y2 + 51);
}
else if (y2 < 0.3f)
{
if (y2 < 0.1f)
y2 *= 8.f;
else
{
y2 -= 0.1f;
y2 += 0.8f;
}
r = static_cast<unsigned char>(66 - 32 * y2);
g = static_cast<unsigned char>(48 - 23 * y2);
b = static_cast<unsigned char>(33 - 16 * y2);
}
else
{
y2 -= 0.3f;
y2 *= 1.428f;
r = static_cast<unsigned char>(34 - 29 * y2);
g = static_cast<unsigned char>(25 - 20 * y2);
b = static_cast<unsigned char>(17 - 12 * y2);
}
data[texelY * mWidth * 3 + texelX * 3] = r;
data[texelY * mWidth * 3 + texelX * 3+1] = g;
data[texelY * mWidth * 3 + texelX * 3+2] = b;
alphaData[texelY * mWidth+ texelX] = (y2 < 0) ? static_cast<unsigned char>(0) : static_cast<unsigned char>(255);
}
}
}
}
mBaseTexture = new osg::Texture2D;
mBaseTexture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
mBaseTexture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
mBaseTexture->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR);
mBaseTexture->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
mBaseTexture->setImage(image);
mBaseTexture->setResizeNonPowerOfTwoHint(false);
mAlphaTexture = new osg::Texture2D;
mAlphaTexture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
mAlphaTexture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
mAlphaTexture->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR);
mAlphaTexture->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
mAlphaTexture->setImage(alphaImage);
mAlphaTexture->setResizeNonPowerOfTwoHint(false);
mOverlayImage = new osg::Image;
mOverlayImage->allocateImage(mWidth, mHeight, 1, GL_RGBA, GL_UNSIGNED_BYTE);
assert(mOverlayImage->isDataContiguous());
memset(mOverlayImage->data(), 0, mOverlayImage->getTotalSizeInBytes());
mOverlayTexture = new osg::Texture2D;
mOverlayTexture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
mOverlayTexture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
mOverlayTexture->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR);
mOverlayTexture->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
mOverlayTexture->setResizeNonPowerOfTwoHint(false);
mOverlayTexture->setInternalFormat(GL_RGBA);
mOverlayTexture->setTextureSize(mWidth, mHeight);
}
int mWidth, mHeight;
int mMinX, mMinY, mMaxX, mMaxY;
int mCellSize;
const MWWorld::Store<ESM::Land>& mLandStore;
osg::ref_ptr<osg::Texture2D> mBaseTexture;
osg::ref_ptr<osg::Texture2D> mAlphaTexture;
osg::ref_ptr<osg::Image> mOverlayImage;
osg::ref_ptr<osg::Texture2D> mOverlayTexture;
};
GlobalMap::GlobalMap(osg::Group* root, SceneUtil::WorkQueue* workQueue)
: mRoot(root)
, mWorkQueue(workQueue)
, mWidth(0)
, mHeight(0)
, mMinX(0), mMaxX(0)
@ -114,7 +240,7 @@ namespace MWRender
removeCamera(*it);
}
void GlobalMap::render (Loading::Listener* loadingListener)
void GlobalMap::render ()
{
const MWWorld::ESMStore &esmStore =
MWBase::Environment::get().getWorld()->getStore();
@ -136,100 +262,8 @@ namespace MWRender
mWidth = mCellSize*(mMaxX-mMinX+1);
mHeight = mCellSize*(mMaxY-mMinY+1);
loadingListener->loadingOn();
loadingListener->setLabel("Creating map");
loadingListener->setProgressRange((mMaxX-mMinX+1) * (mMaxY-mMinY+1));
loadingListener->setProgress(0);
osg::ref_ptr<osg::Image> image = new osg::Image;
image->allocateImage(mWidth, mHeight, 1, GL_RGB, GL_UNSIGNED_BYTE);
unsigned char* data = image->data();
osg::ref_ptr<osg::Image> alphaImage = new osg::Image;
alphaImage->allocateImage(mWidth, mHeight, 1, GL_ALPHA, GL_UNSIGNED_BYTE);
unsigned char* alphaData = alphaImage->data();
for (int x = mMinX; x <= mMaxX; ++x)
{
for (int y = mMinY; y <= mMaxY; ++y)
{
const ESM::Land* land = esmStore.get<ESM::Land>().search (x,y);
for (int cellY=0; cellY<mCellSize; ++cellY)
{
for (int cellX=0; cellX<mCellSize; ++cellX)
{
int vertexX = static_cast<int>(float(cellX)/float(mCellSize) * 9);
int vertexY = static_cast<int>(float(cellY) / float(mCellSize) * 9);
int texelX = (x-mMinX) * mCellSize + cellX;
int texelY = (y-mMinY) * mCellSize + cellY;
unsigned char r,g,b;
float y2 = 0;
if (land && (land->mDataTypes & ESM::Land::DATA_WNAM))
y2 = (land->mWnam[vertexY * 9 + vertexX] << 4) / 2048.f;
else
y2 = (SCHAR_MIN << 4) / 2048.f;
if (y2 < 0)
{
r = static_cast<unsigned char>(14 * y2 + 38);
g = static_cast<unsigned char>(20 * y2 + 56);
b = static_cast<unsigned char>(18 * y2 + 51);
}
else if (y2 < 0.3f)
{
if (y2 < 0.1f)
y2 *= 8.f;
else
{
y2 -= 0.1f;
y2 += 0.8f;
}
r = static_cast<unsigned char>(66 - 32 * y2);
g = static_cast<unsigned char>(48 - 23 * y2);
b = static_cast<unsigned char>(33 - 16 * y2);
}
else
{
y2 -= 0.3f;
y2 *= 1.428f;
r = static_cast<unsigned char>(34 - 29 * y2);
g = static_cast<unsigned char>(25 - 20 * y2);
b = static_cast<unsigned char>(17 - 12 * y2);
}
data[texelY * mWidth * 3 + texelX * 3] = r;
data[texelY * mWidth * 3 + texelX * 3+1] = g;
data[texelY * mWidth * 3 + texelX * 3+2] = b;
alphaData[texelY * mWidth+ texelX] = (y2 < 0) ? static_cast<unsigned char>(0) : static_cast<unsigned char>(255);
}
}
loadingListener->increaseProgress();
}
}
mBaseTexture = new osg::Texture2D;
mBaseTexture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
mBaseTexture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
mBaseTexture->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR);
mBaseTexture->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
mBaseTexture->setImage(image);
mBaseTexture->setResizeNonPowerOfTwoHint(false);
mAlphaTexture = new osg::Texture2D;
mAlphaTexture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
mAlphaTexture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
mAlphaTexture->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR);
mAlphaTexture->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
mAlphaTexture->setImage(alphaImage);
mAlphaTexture->setResizeNonPowerOfTwoHint(false);
clear();
loadingListener->loadingOff();
mWorkItem = new CreateMapWorkItem(mWidth, mHeight, mMinX, mMinY, mMaxX, mMaxY, mCellSize, esmStore.get<ESM::Land>());
mWorkQueue->addWorkItem(mWorkItem);
}
void GlobalMap::worldPosToImageSpace(float x, float z, float& imageX, float& imageY)
@ -334,6 +368,8 @@ namespace MWRender
void GlobalMap::exploreCell(int cellX, int cellY, osg::ref_ptr<osg::Texture2D> localMapTexture)
{
ensureLoaded();
if (!localMapTexture)
return;
@ -348,25 +384,9 @@ namespace MWRender
void GlobalMap::clear()
{
if (!mOverlayImage)
{
mOverlayImage = new osg::Image;
mOverlayImage->allocateImage(mWidth, mHeight, 1, GL_RGBA, GL_UNSIGNED_BYTE);
assert(mOverlayImage->isDataContiguous());
}
memset(mOverlayImage->data(), 0, mOverlayImage->getTotalSizeInBytes());
ensureLoaded();
if (!mOverlayTexture)
{
mOverlayTexture = new osg::Texture2D;
mOverlayTexture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
mOverlayTexture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
mOverlayTexture->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR);
mOverlayTexture->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
mOverlayTexture->setResizeNonPowerOfTwoHint(false);
mOverlayTexture->setInternalFormat(GL_RGBA);
mOverlayTexture->setTextureSize(mWidth, mHeight);
}
memset(mOverlayImage->data(), 0, mOverlayImage->getTotalSizeInBytes());
mPendingImageDest.clear();
@ -377,6 +397,8 @@ namespace MWRender
void GlobalMap::write(ESM::GlobalMap& map)
{
ensureLoaded();
map.mBounds.mMinX = mMinX;
map.mBounds.mMaxX = mMaxX;
map.mBounds.mMinY = mMinY;
@ -417,6 +439,8 @@ namespace MWRender
void GlobalMap::read(ESM::GlobalMap& map)
{
ensureLoaded();
const ESM::GlobalMap::Bounds& bounds = map.mBounds;
if (bounds.mMaxX-bounds.mMinX < 0)
@ -513,14 +537,33 @@ namespace MWRender
osg::ref_ptr<osg::Texture2D> GlobalMap::getBaseTexture()
{
ensureLoaded();
return mBaseTexture;
}
osg::ref_ptr<osg::Texture2D> GlobalMap::getOverlayTexture()
{
ensureLoaded();
return mOverlayTexture;
}
void GlobalMap::ensureLoaded()
{
if (mWorkItem)
{
mWorkItem->waitTillDone();
mOverlayImage = mWorkItem->mOverlayImage;
mBaseTexture = mWorkItem->mBaseTexture;
mAlphaTexture = mWorkItem->mAlphaTexture;
mOverlayTexture = mWorkItem->mOverlayTexture;
requestOverlayTextureUpdate(0, 0, mWidth, mHeight, osg::ref_ptr<osg::Texture2D>(), true, false);
mWorkItem = NULL;
}
}
void GlobalMap::markForRemoval(osg::Camera *camera)
{
CameraVector::iterator found = std::find(mActiveCameras.begin(), mActiveCameras.end(), camera);
@ -549,6 +592,7 @@ namespace MWRender
continue;
}
ensureLoaded();
mOverlayImage->copySubImage(imageDest.mX, imageDest.mY, 0, imageDest.mImage);
it = mPendingImageDest.erase(it);

21
apps/openmw/mwrender/globalmap.hpp
View file

@ -14,26 +14,28 @@ namespace osg
class Camera;
}
namespace Loading
{
class Listener;
}
namespace ESM
{
struct GlobalMap;
}
namespace SceneUtil
{
class WorkQueue;
}
namespace MWRender
{
class CreateMapWorkItem;
class GlobalMap
{
public:
GlobalMap(osg::Group* root);
GlobalMap(osg::Group* root, SceneUtil::WorkQueue* workQueue);
~GlobalMap();
void render(Loading::Listener* loadingListener);
void render();
int getWidth() const { return mWidth; }
int getHeight() const { return mHeight; }
@ -69,6 +71,8 @@ namespace MWRender
osg::ref_ptr<osg::Texture2D> getBaseTexture();
osg::ref_ptr<osg::Texture2D> getOverlayTexture();
void ensureLoaded();
private:
/**
* Request rendering a 2d quad onto mOverlayTexture.
@ -116,6 +120,9 @@ namespace MWRender
// CPU copy of overlay
osg::ref_ptr<osg::Image> mOverlayImage;
osg::ref_ptr<SceneUtil::WorkQueue> mWorkQueue;
osg::ref_ptr<CreateMapWorkItem> mWorkItem;
int mWidth;
int mHeight;