void ConfigManager::storeSafeParameters()
{
RenderType tmpOpengl;
isSafeMode = config.getBoolValue("safemode");
if (isSafeMode)
logger->log1("Run in safe mode");
tmpOpengl = intToRenderType(config.getIntValue("opengl"));
config.setValue("opengl", CAST_S32(RENDER_SOFTWARE));
config.write();
if (settings.options.safeMode)
{
isSafeMode = true;
return;
}
config.setValue("safemode", false);
config.setValue("opengl", CAST_S32(tmpOpengl));
}
void GraphicsManager::initGraphics(const bool noOpenGL)
{
RenderType useOpenGL = RENDER_SOFTWARE;
if (!noOpenGL)
useOpenGL = intToRenderType(config.getIntValue("opengl"));
// Setup image loading for the right image format
ImageHelper::setOpenGlMode(useOpenGL);
// Create the graphics context
switch (useOpenGL)
{
case RENDER_SOFTWARE:
#ifdef USE_SDL2
imageHelper = new SDL2SoftwareImageHelper;
surfaceImageHelper = new SurfaceImageHelper;
mainGraphics = new SDL2SoftwareGraphics;
#else
imageHelper = new SDLImageHelper;
surfaceImageHelper = imageHelper;
mainGraphics = new SDLGraphics;
#endif
mUseTextureSampler = false;
break;
case RENDER_NORMAL_OPENGL:
#ifndef USE_SDL2
case RENDER_SDL2_DEFAULT:
#endif
case RENDER_LAST:
case RENDER_NULL:
default:
#ifndef ANDROID
imageHelper = new OpenGLImageHelper;
surfaceImageHelper = new SurfaceImageHelper;
mainGraphics = new NormalOpenGLGraphics;
mUseTextureSampler = true;
break;
case RENDER_SAFE_OPENGL:
imageHelper = new OpenGLImageHelper;
surfaceImageHelper = new SurfaceImageHelper;
mainGraphics = new SafeOpenGLGraphics;
mUseTextureSampler = false;
break;
#endif
case RENDER_GLES_OPENGL:
imageHelper = new OpenGLImageHelper;
surfaceImageHelper = new SurfaceImageHelper;
mainGraphics = new MobileOpenGLGraphics;
mUseTextureSampler = false;
break;
#ifdef USE_SDL2
case RENDER_SDL2_DEFAULT:
imageHelper = new SDLImageHelper;
surfaceImageHelper = new SurfaceImageHelper;
mainGraphics = new SDLGraphics;
mainGraphics->setRendererFlags(SDL_RENDERER_ACCELERATED);
mUseTextureSampler = false;
break;
#endif
};
mUseAtlases = (useOpenGL == RENDER_NORMAL_OPENGL
|| useOpenGL == RENDER_SAFE_OPENGL || useOpenGL == RENDER_GLES_OPENGL)
&& config.getBoolValue("useAtlases");
#else // USE_OPENGL
void GraphicsManager::initGraphics(const bool noOpenGL A_UNUSED)
{
RenderType useOpenGL = RENDER_SOFTWARE;
if (!noOpenGL)
useOpenGL = intToRenderType(config.getIntValue("opengl"));
// Setup image loading for the right image format
ImageHelper::setOpenGlMode(useOpenGL);
// Create the graphics context
switch (useOpenGL)
{
case RENDER_SOFTWARE:
case RENDER_SAFE_OPENGL:
case RENDER_GLES_OPENGL:
case RENDER_NORMAL_OPENGL:
case RENDER_NULL:
case RENDER_LAST:
default:
#ifndef USE_SDL2
case RENDER_SDL2_DEFAULT:
#endif
#ifdef USE_SDL2
imageHelper = new SDL2SoftwareImageHelper;
surfaceImageHelper = new SurfaceImageHelper;
mainGraphics = new SDL2SoftwareGraphics;
#else
imageHelper = new SDLImageHelper;
surfaceImageHelper = imageHelper;
mainGraphics = new SDLGraphics;
#endif
break;
#ifdef USE_SDL2
case RENDER_SDL2_DEFAULT:
imageHelper = new SDLImageHelper;
surfaceImageHelper = new SurfaceImageHelper;
mainGraphics = new SDLGraphics;
mainGraphics->setRendererFlags(SDL_RENDERER_ACCELERATED);
break;
#endif
};
#endif // USE_OPENGL
}
void ConfigManager::storeSafeParameters()
{
bool tmpHwaccel;
RenderType tmpOpengl;
int tmpFpslimit;
int tmpAltFpslimit;
bool tmpSound;
int width;
int height;
std::string font;
std::string bFont;
std::string particleFont;
std::string helpFont;
std::string secureFont;
std::string npcFont;
std::string japanFont;
std::string chinaFont;
bool showBackground;
bool enableMumble;
bool enableMapReduce;
isSafeMode = config.getBoolValue("safemode");
if (isSafeMode)
logger->log1("Run in safe mode");
tmpOpengl = intToRenderType(config.getIntValue("opengl"));
width = config.getIntValue("screenwidth");
height = config.getIntValue("screenheight");
tmpHwaccel = config.getBoolValue("hwaccel");
tmpFpslimit = config.getIntValue("fpslimit");
tmpAltFpslimit = config.getIntValue("altfpslimit");
tmpSound = config.getBoolValue("sound");
font = config.getStringValue("font");
bFont = config.getStringValue("boldFont");
particleFont = config.getStringValue("particleFont");
helpFont = config.getStringValue("helpFont");
secureFont = config.getStringValue("secureFont");
npcFont = config.getStringValue("npcFont");
japanFont = config.getStringValue("japanFont");
chinaFont = config.getStringValue("chinaFont");
showBackground = config.getBoolValue("showBackground");
enableMumble = config.getBoolValue("enableMumble");
enableMapReduce = config.getBoolValue("enableMapReduce");
if (!settings.options.safeMode && !tmpOpengl)
{
// if video mode configured reset most settings to safe
config.setValue("hwaccel", false);
config.setValue("altfpslimit", 3);
config.setValue("sound", false);
config.setValue("safemode", true);
config.setValue("screenwidth", 640);
config.setValue("screenheight", 480);
config.setValue("font", "fonts/dejavusans.ttf");
config.setValue("boldFont", "fonts/dejavusans-bold.ttf");
config.setValue("particleFont", "fonts/dejavusans.ttf");
config.setValue("helpFont", "fonts/dejavusansmono.ttf");
config.setValue("secureFont", "fonts/dejavusansmono.ttf");
config.setValue("npcFont", "fonts/dejavusans.ttf");
config.setValue("japanFont", "fonts/mplus-1p-regular.ttf");
config.setValue("chinaFont", "fonts/wqy-microhei.ttf");
config.setValue("showBackground", false);
config.setValue("enableMumble", false);
config.setValue("enableMapReduce", false);
}
else
{
// if video mode not configured reset only video mode to safe
config.setValue("screenwidth", 640);
config.setValue("screenheight", 480);
}
#if defined(__APPLE__)
config.setValue("opengl", CAST_S32(RENDER_NORMAL_OPENGL));
#else
config.setValue("opengl", CAST_S32(RENDER_SOFTWARE));
#endif
config.write();
if (settings.options.safeMode)
{
isSafeMode = true;
return;
}
config.setValue("safemode", false);
if (!tmpOpengl)
{
config.setValue("hwaccel", tmpHwaccel);
config.setValue("opengl", CAST_S32(tmpOpengl));
config.setValue("fpslimit", tmpFpslimit);
config.setValue("altfpslimit", tmpAltFpslimit);
config.setValue("sound", tmpSound);
config.setValue("screenwidth", width);
config.setValue("screenheight", height);
config.setValue("font", font);
config.setValue("boldFont", bFont);
config.setValue("particleFont", particleFont);
config.setValue("helpFont", helpFont);
config.setValue("secureFont", secureFont);
config.setValue("npcFont", npcFont);
config.setValue("japanFont", japanFont);
config.setValue("chinaFont", chinaFont);
config.setValue("showBackground", showBackground);
config.setValue("enableMumble", enableMumble);
config.setValue("enableMapReduce", enableMapReduce);
}
else
{
config.setValue("opengl", CAST_S32(tmpOpengl));
config.setValue("screenwidth", width);
config.setValue("screenheight", height);
}
}
Setup_Video::Setup_Video(const Widget2 *const widget) :
SetupTab(widget),
KeyListener(),
mFullScreenEnabled(config.getBoolValue("screen")),
mOpenGLEnabled(intToRenderType(config.getIntValue("opengl"))),
mFps(config.getIntValue("fpslimit")),
mAltFps(config.getIntValue("altfpslimit")),
mModeListModel(new ModeListModel),
mOpenGLListModel(new OpenGLListModel),
mModeList(CREATEWIDGETR(ListBox, widget, mModeListModel, "")),
// TRANSLATORS: video settings checkbox
mFsCheckBox(new CheckBox(this, _("Full screen"), mFullScreenEnabled)),
mOpenGLDropDown(new DropDown(widget, mOpenGLListModel)),
// TRANSLATORS: video settings checkbox
mFpsCheckBox(new CheckBox(this, _("FPS limit:"))),
mFpsSlider(new Slider(this, 2.0, 160.0, 1.0)),
mFpsLabel(new Label(this)),
mAltFpsSlider(new Slider(this, 2.0, 160.0, 1.0)),
// TRANSLATORS: video settings label
mAltFpsLabel(new Label(this, _("Alt FPS limit: "))),
#if !defined(ANDROID) && !defined(__APPLE__) && !defined(__native_client__)
// TRANSLATORS: video settings button
mDetectButton(new Button(this, _("Detect best mode"), "detect", this)),
#endif // !defined(ANDROID) && !defined(__APPLE__) &&
// !defined(__native_client__)
mDialog(nullptr),
mCustomCursorEnabled(config.getBoolValue("customcursor")),
mEnableResize(config.getBoolValue("enableresize")),
mNoFrame(config.getBoolValue("noframe")),
mCustomCursorCheckBox(new CheckBox(this,
#ifdef ANDROID
// TRANSLATORS: video settings checkbox
_("Show cursor"),
#else // ANDROID
// TRANSLATORS: video settings checkbox
_("Custom cursor"),
#endif // ANDROID
mCustomCursorEnabled)),
// TRANSLATORS: video settings checkbox
mEnableResizeCheckBox(new CheckBox(this, _("Enable resize"),
mEnableResize)),
// TRANSLATORS: video settings checkbox
mNoFrameCheckBox(new CheckBox(this, _("No frame"), mNoFrame))
{
// TRANSLATORS: video settings tab name
setName(_("Video"));
ScrollArea *const scrollArea = new ScrollArea(this, mModeList,
Opaque_true, "setup_video_background.xml");
scrollArea->setWidth(150);
scrollArea->setHorizontalScrollPolicy(ScrollArea::SHOW_NEVER);
mOpenGLDropDown->setSelected(renderToIndex[mOpenGLEnabled]);
mModeList->setEnabled(true);
// TRANSLATORS: video settings label
mFpsLabel->setCaption(mFps > 0 ? toString(mFps) : _("None"));
mFpsLabel->setWidth(60);
// TRANSLATORS: video settings label
mAltFpsLabel->setCaption(_("Alt FPS limit: ") + (mAltFps > 0 ?
// TRANSLATORS: video settings label value
toString(mAltFps) : _("None")));
mAltFpsLabel->setWidth(150);
mFpsSlider->setEnabled(mFps > 0);
mFpsSlider->setValue(mFps);
mAltFpsSlider->setEnabled(mAltFps > 0);
mAltFpsSlider->setValue(mAltFps);
mFpsCheckBox->setSelected(mFps > 0);
// Pre-select the current video mode.
const std::string videoMode = toString(
mainGraphics->mActualWidth).append("x").append(
toString(mainGraphics->mActualHeight));
mModeList->setSelected(mModeListModel->getIndexOf(videoMode));
mModeList->setActionEventId("videomode");
mCustomCursorCheckBox->setActionEventId("customcursor");
mFpsCheckBox->setActionEventId("fpslimitcheckbox");
mFpsSlider->setActionEventId("fpslimitslider");
mAltFpsSlider->setActionEventId("altfpslimitslider");
mOpenGLDropDown->setActionEventId("opengl");
mEnableResizeCheckBox->setActionEventId("enableresize");
mNoFrameCheckBox->setActionEventId("noframe");
mModeList->addActionListener(this);
mCustomCursorCheckBox->addActionListener(this);
mFpsCheckBox->addActionListener(this);
mFpsSlider->addActionListener(this);
mAltFpsSlider->addActionListener(this);
mOpenGLDropDown->addActionListener(this);
mEnableResizeCheckBox->addActionListener(this);
mNoFrameCheckBox->addActionListener(this);
// Do the layout
LayoutHelper h(this);
ContainerPlacer place = h.getPlacer(0, 0);
place(0, 0, scrollArea, 1, 5).setPadding(2);
place(0, 5, mOpenGLDropDown, 1);
place(1, 0, mFsCheckBox, 2);
place(1, 1, mCustomCursorCheckBox, 3);
place(1, 2, mEnableResizeCheckBox, 2);
place(1, 3, mNoFrameCheckBox, 2);
place(0, 6, mFpsSlider);
place(1, 6, mFpsCheckBox).setPadding(3);
place(2, 6, mFpsLabel).setPadding(1);
place(0, 7, mAltFpsSlider);
place(1, 7, mAltFpsLabel).setPadding(3);
#if !defined(ANDROID) && !defined(__APPLE__) && !defined(__native_client__)
place(0, 8, mDetectButton);
#else // !defined(ANDROID) && !defined(__APPLE__) &&
// !defined(__native_client__)
mNoFrameCheckBox->setEnabled(false);
mEnableResizeCheckBox->setEnabled(false);
#ifndef __native_client__
mFsCheckBox->setEnabled(false);
#endif // __native_client__
#endif // !defined(ANDROID) && !defined(__APPLE__) &&
// !defined(__native_client__)
int width = 600;
if (config.getIntValue("screenwidth") >= 730)
width += 100;
setDimension(Rect(0, 0, width, 300));
}
void Setup_Video::action(const ActionEvent &event)
{
const std::string &id = event.getId();
if (id == "videomode")
{
std::string mode = mModeListModel->getElementAt(
mModeList->getSelected());
if (mode == "custom")
{
if (mDialog)
{
mode = mDialog->getText();
mDialog = nullptr;
}
else
{
CREATEWIDGETV(mDialog, TextDialog,
// TRANSLATORS: resolution question dialog
_("Custom resolution (example: 1024x768)"),
// TRANSLATORS: resolution question dialog
_("Enter new resolution: "));
mDialog->setActionEventId("videomode");
mDialog->addActionListener(this);
return;
}
}
const int width = atoi(mode.substr(0, mode.find("x")).c_str());
const int height = atoi(mode.substr(mode.find("x") + 1).c_str());
if (!width || !height)
return;
if (width != mainGraphics->mActualWidth
|| height != mainGraphics->mActualHeight)
{
#if defined(WIN32) || defined(__APPLE__) || defined(ANDROID)
if (intToRenderType(config.getIntValue("opengl"))
== RENDER_SOFTWARE)
{
WindowManager::doResizeVideo(width, height, false);
}
else
{
if (width < mainGraphics->mActualWidth
|| height < mainGraphics->mActualHeight)
{
CREATEWIDGET(OkDialog,
// TRANSLATORS: video settings warning
_("Screen Resolution Changed"),
// TRANSLATORS: video settings warning
_("Restart your client for the change to take effect.")
// TRANSLATORS: video settings warning
+ std::string("\n") + _("Some windows may be moved to "
"fit the lowered resolution."),
// TRANSLATORS: ok dialog button
_("OK"),
DialogType::OK,
Modal_true,
ShowCenter_true,
nullptr,
260);
}
else
{
CREATEWIDGET(OkDialog,
// TRANSLATORS: video settings warning
_("Screen Resolution Changed"),
// TRANSLATORS: video settings warning
_("Restart your client for the change"
" to take effect."),
// TRANSLATORS: ok dialog button
_("OK"),
DialogType::OK,
Modal_true,
ShowCenter_true,
nullptr,
260);
}
}
#else // defined(WIN32) || defined(__APPLE__) || defined(ANDROID)
mainGraphics->setWindowSize(width, height);
WindowManager::doResizeVideo(width, height, false);
#endif // defined(WIN32) || defined(__APPLE__) || defined(ANDROID)
}
config.setValue("oldscreen", config.getBoolValue("screen"));
config.setValue("oldscreenwidth", mainGraphics->mActualWidth);
config.setValue("oldscreenheight", mainGraphics->mActualHeight);
config.setValue("screenwidth", width);
config.setValue("screenheight", height);
}
if (id == "~videomode")
{
mDialog = nullptr;
}
else if (id == "customcursor")
{
config.setValue("customcursor", mCustomCursorCheckBox->isSelected());
}
else if (id == "fpslimitcheckbox" || id == "fpslimitslider")
{
int tempFps = CAST_S32(mFpsSlider->getValue());
if (id == "fpslimitcheckbox" && !mFpsSlider->isEnabled())
tempFps = 60;
else
tempFps = tempFps > 0 ? tempFps : 60;
mFps = mFpsCheckBox->isSelected() ? tempFps : 0;
// TRANSLATORS: video settings label
const std::string text = mFps > 0 ? toString(mFps) : _("None");
mFpsLabel->setCaption(text);
mFpsSlider->setEnabled(mFps > 0);
mFpsSlider->setValue(mFps);
}
else if (id == "altfpslimitslider")
{
int tempFps = CAST_S32(mAltFpsSlider->getValue());
tempFps = tempFps > 0 ? tempFps : CAST_S32(
mAltFpsSlider->getScaleStart());
mAltFps = tempFps;
// TRANSLATORS: video settings label
const std::string text = mAltFps > 0 ? toString(mAltFps) : _("None");
// TRANSLATORS: video settings label
mAltFpsLabel->setCaption(_("Alt FPS limit: ") + text);
mAltFpsSlider->setEnabled(mAltFps > 0);
mAltFpsSlider->setValue(mAltFps);
}
else if (id == "enableresize")
{
config.setValue("enableresize", mEnableResizeCheckBox->isSelected());
}
else if (id == "noframe")
{
config.setValue("noframe", mNoFrameCheckBox->isSelected());
}
#if defined(USE_OPENGL) && !defined(ANDROID) && !defined(__APPLE__)
else if (id == "detect")
{
TestMain *test = graphicsManager.startDetection();
if (test)
{
Configuration &conf = test->getConfig();
const int val = conf.getValueInt("opengl", -1);
if (val >= 0 && CAST_U32(val)
< sizeof(renderToIndex) / sizeof(int))
{
mOpenGLDropDown->setSelected(renderToIndex[val]);
}
config.setValue("textureSize",
conf.getValue("textureSize", "1024,1024,1024,1024,1024,1024"));
config.setValue("testInfo", conf.getValue("testInfo", ""));
delete test;
}
}
#endif // defined(USE_OPENGL) && !defined(ANDROID) && !defined(__APPLE__)
}
void Setup_Video::apply()
{
// Full screen changes
bool fullscreen = mFsCheckBox->isSelected();
if (fullscreen != config.getBoolValue("screen"))
{
/* The OpenGL test is only necessary on Windows, since switching
* to/from full screen works fine on Linux. On Windows we'd have to
* reinitialize the OpenGL state and reload all textures.
*
* See http://libsdl.org/cgi/docwiki.cgi/SDL_SetVideoMode
*/
#if defined(WIN32) || defined(__APPLE__) || defined(ANDROID)
// checks for opengl usage
if (intToRenderType(config.getIntValue("opengl")) == RENDER_SOFTWARE)
{
#endif // defined(WIN32) || defined(__APPLE__) || defined(ANDROID)
if (!WindowManager::setFullScreen(fullscreen))
{
fullscreen = !fullscreen;
if (!WindowManager::setFullScreen(fullscreen))
{
std::stringstream errorMsg;
if (fullscreen)
{
// TRANSLATORS: video error message
errorMsg << _("Failed to switch to windowed mode "
"and restoration of old mode also "
"failed!") << std::endl;
}
else
{
// TRANSLATORS: video error message
errorMsg << _("Failed to switch to fullscreen mode"
" and restoration of old mode also "
"failed!") << std::endl;
}
logger->safeError(errorMsg.str());
}
}
#if defined(WIN32) || defined(__APPLE__) || defined(ANDROID)
}
else
{
CREATEWIDGET(OkDialog,
// TRANSLATORS: video settings warning
_("Switching to Full Screen"),
// TRANSLATORS: video settings warning
_("Restart needed for changes to take effect."),
// TRANSLATORS: ok dialog button
_("OK"),
DialogType::OK,
Modal_true,
ShowCenter_true,
nullptr,
260);
}
#endif // defined(WIN32) || defined(__APPLE__) || defined(ANDROID)
config.setValue("screen", fullscreen);
}
const int sel = mOpenGLDropDown->getSelected();
RenderType mode = RENDER_SOFTWARE;
if (sel >= 0 && CAST_U32(sel) < sizeof(indexToRender))
mode = indexToRender[mOpenGLDropDown->getSelected()];
// OpenGL change
if (mode != mOpenGLEnabled)
{
config.setValue("opengl", CAST_S32(mode));
// OpenGL can currently only be changed by restarting, notify user.
CREATEWIDGET(OkDialog,
// TRANSLATORS: video settings warning
_("Changing to OpenGL"),
// TRANSLATORS: video settings warning
_("Applying change to OpenGL requires restart."),
// TRANSLATORS: ok dialog button
_("OK"),
DialogType::OK,
Modal_true,
ShowCenter_true,
nullptr,
260);
}
mFps = mFpsCheckBox->isSelected() ?
CAST_S32(mFpsSlider->getValue()) : 0;
mAltFps = CAST_S32(mAltFpsSlider->getValue());
mFpsSlider->setEnabled(mFps > 0);
mAltFpsSlider->setEnabled(mAltFps > 0);
// FPS change
config.setValue("fpslimit", mFps);
config.setValue("altfpslimit", mAltFps);
// We sync old and new values at apply time
mFullScreenEnabled = config.getBoolValue("screen");
mCustomCursorEnabled = config.getBoolValue("customcursor");
mOpenGLEnabled = intToRenderType(config.getIntValue("opengl"));
mEnableResize = config.getBoolValue("enableresize");
mNoFrame = config.getBoolValue("noframe");
}
Map::Map(const int width, const int height,
const int tileWidth, const int tileHeight) :
Properties(),
mWidth(width), mHeight(height),
mTileWidth(tileWidth), mTileHeight(tileHeight),
mMaxTileHeight(height),
mMetaTiles(new MetaTile[mWidth * mHeight]),
mWalkLayer(nullptr),
mLayers(),
mTilesets(),
mActors(),
mHasWarps(false),
mDrawLayersFlags(MapType::NORMAL),
mOnClosedList(1),
mOnOpenList(2),
mBackgrounds(),
mForegrounds(),
mLastAScrollX(0.0F),
mLastAScrollY(0.0F),
mParticleEffects(),
mMapPortals(),
mTileAnimations(),
mOverlayDetail(config.getIntValue("OverlayDetail")),
mOpacity(config.getFloatValue("guialpha")),
#ifdef USE_OPENGL
mOpenGL(intToRenderType(config.getIntValue("opengl"))),
#else
mOpenGL(RENDER_SOFTWARE),
#endif
mPvp(0),
mTilesetsIndexed(false),
mIndexedTilesets(nullptr),
mIndexedTilesetsSize(0),
mActorFixX(0),
mActorFixY(0),
mVersion(0),
mSpecialLayer(new SpecialLayer(width, height)),
mTempLayer(new SpecialLayer(width, height)),
mObjects(new ObjectsLayer(width, height)),
mFringeLayer(nullptr),
mLastX(-1),
mLastY(-1),
mLastScrollX(-1),
mLastScrollY(-1),
mDrawX(-1),
mDrawY(-1),
mDrawScrollX(-1),
mDrawScrollY(-1),
mMask(1),
mAtlas(nullptr),
mHeights(nullptr),
mRedrawMap(true),
mBeingOpacity(false),
mCustom(false)
{
const int size = mWidth * mHeight;
for (int i = 0; i < BlockType::NB_BLOCKTYPES; i++)
{
mOccupation[i] = new unsigned[static_cast<size_t>(size)];
memset(mOccupation[i], 0, static_cast<size_t>(size)
* sizeof(unsigned));
}
config.addListener("OverlayDetail", this);
config.addListener("guialpha", this);
config.addListener("beingopacity", this);
if (mOpacity != 1.0F)
mBeingOpacity = config.getBoolValue("beingopacity");
else
mBeingOpacity = false;
}
Map::Map(const int width, const int height,
const int tileWidth, const int tileHeight) :
Properties(),
mWidth(width), mHeight(height),
mTileWidth(tileWidth), mTileHeight(tileHeight),
mMaxTileHeight(height),
mMetaTiles(new MetaTile[mWidth * mHeight]),
mWalkLayer(nullptr),
mLayers(),
mDrawUnderLayers(),
mDrawOverLayers(),
mTilesets(),
mActors(),
mHasWarps(false),
mDrawLayersFlags(MapType::NORMAL),
mOnClosedList(1),
mOnOpenList(2),
mBackgrounds(),
mForegrounds(),
mLastAScrollX(0.0F),
mLastAScrollY(0.0F),
mParticleEffects(),
mMapPortals(),
mTileAnimations(),
mOverlayDetail(config.getIntValue("OverlayDetail")),
mOpacity(config.getFloatValue("guialpha")),
#ifdef USE_OPENGL
mOpenGL(intToRenderType(config.getIntValue("opengl"))),
#else
mOpenGL(RENDER_SOFTWARE),
#endif
mPvp(0),
mTilesetsIndexed(false),
mIndexedTilesets(nullptr),
mIndexedTilesetsSize(0),
mActorFixX(0),
mActorFixY(0),
mVersion(0),
mSpecialLayer(new SpecialLayer(width, height)),
mTempLayer(new SpecialLayer(width, height)),
mObjects(new ObjectsLayer(width, height)),
mFringeLayer(nullptr),
mLastX(-1),
mLastY(-1),
mLastScrollX(-1),
mLastScrollY(-1),
mDrawX(-1),
mDrawY(-1),
mDrawScrollX(-1),
mDrawScrollY(-1),
mMask(1),
mAtlas(nullptr),
mHeights(nullptr),
mRedrawMap(true),
mBeingOpacity(false),
#ifdef USE_OPENGL
mCachedDraw(mOpenGL == RENDER_NORMAL_OPENGL
|| mOpenGL == RENDER_GLES_OPENGL
|| mOpenGL == RENDER_MODERN_OPENGL),
#else
mCachedDraw(false),
#endif
mCustom(false),
mDrawOnlyFringe(false)
{
config.addListener("OverlayDetail", this);
config.addListener("guialpha", this);
config.addListener("beingopacity", this);
if (mOpacity != 1.0F)
mBeingOpacity = config.getBoolValue("beingopacity");
else
mBeingOpacity = false;
}
