MapLayer Class Reference

#include <maplayer.h>

Inheritance diagram for MapLayer:

Public Member Functions
	MapLayer (const std::string &name, const int x, const int y, const int width, const int height, const bool isFringeLayer, const int mask, const int tileCondition)
	~MapLayer ()
void	setTile (const int x, const int y, Image *const img)
void	setTile (const int index, Image *const img)
void	draw (Graphics *const graphics, int startX, int startY, int endX, int endY, const int scrollX, const int scrollY) const
void	drawSDL (Graphics *const graphics) const
void	drawOGL (Graphics *const graphics) const
void	updateOGL (Graphics *const graphics, int startX, int startY, int endX, int endY, const int scrollX, const int scrollY)
void	updateSDL (const Graphics *const graphics, int startX, int startY, int endX, int endY, const int scrollX, const int scrollY)
void	drawFringe (Graphics *const graphics, int startX, int startY, int endX, int endY, const int scrollX, const int scrollY, const Actors &actors) const
bool	isFringeLayer () const
void	setSpecialLayer (const SpecialLayer *const val)
void	setTempLayer (const SpecialLayer *const val)
int	getWidth () const
int	getHeight () const
void	optionChanged (const std::string &value)
void	setDrawLayerFlags (const MapTypeT &n)
void	setActorsFix (const int y)
int	calcMemoryLocal () const
int	calcMemoryChilds (const int level) const
std::string	getCounterName () const
Public Member Functions inherited from MemoryCounter
	MemoryCounter ()
virtual	~MemoryCounter ()
int	calcMemory (const int level) const
Public Member Functions inherited from ConfigListener
	ConfigListener ()
virtual	~ConfigListener ()

Protected Member Functions
void	updateConditionTiles (const MetaTile *const metaTiles, const int width, const int height)
void	updateCache (const int width, const int height)
void	drawSpecialLayer (Graphics *const graphics, const int y, const int startX, const int endX, const int scrollX, const int scrollY) const

Static Protected Member Functions
static int	getTileDrawWidth (const TileInfo *img, const int endX, int &width, int &nextTile)
static int	getEmptyTileDrawWidth (const TileInfo *img, const int endX, int &nextTile)

Private Types
typedef std::vector< MapRowVertexes * >	MapRows

Private Attributes
const int	mX
const int	mY
const int	mPixelX
const int	mPixelY
const int	mWidth
const int	mHeight
TileInfo *const	mTiles
MapTypeT	mDrawLayerFlags
const SpecialLayer *	mSpecialLayer
const SpecialLayer *	mTempLayer
const std::string	mName
MapRows	mTempRows
int	mMask
int	mTileCondition
int	mActorsFix
const bool	mIsFringeLayer
bool	mHighlightAttackRange
bool	mSpecialFlag

Friends
class	Map

Detailed Description

A map layer. Stores a grid of tiles and their offset, and implements layer rendering.

Definition at line 49 of file maplayer.h.

Member Typedef Documentation

MapRows

typedef std::vector<MapRowVertexes*> MapLayer::MapRows

private

Definition at line 232 of file maplayer.h.

Constructor & Destructor Documentation

MapLayer()

MapLayer::MapLayer	(	const std::string &	name,
		const int	x,
		const int	y,
		const int	width,
		const int	height,
		const bool	isFringeLayer,
		const int	mask,
		const int	tileCondition
	)

Constructor, taking layer origin, size and whether this layer is the fringe layer. The fringe layer is the layer that draws the actors. There can be only one fringe layer per map.

Definition at line 50 of file maplayer.cpp.

                                            :
    mX(x),
    mY(y),
    mPixelX(mX * mapTileSize),
    mPixelY(mY * mapTileSize + mapTileSize),
    mWidth(width),
    mHeight(height),
    mTiles(new TileInfo[mWidth * mHeight]),
    mDrawLayerFlags(MapType::NORMAL),
    mSpecialLayer(nullptr),
    mTempLayer(nullptr),
    mName(name),
    mTempRows(),
    mMask(mask),
    mTileCondition(tileCondition),
    mActorsFix(0),
    mIsFringeLayer(fringeLayer),
    mHighlightAttackRange(config.getBoolValue("highlightAttackRange")),
    mSpecialFlag(true)
{
//    std::fill_n(mTiles, mWidth * mHeight, static_cast<Image*>(nullptr));
 
    config.addListener("highlightAttackRange", this);
}

References Configuration::addListener(), and config.

Referenced by calcMemoryLocal().

~MapLayer()

MapLayer::~MapLayer

(

)

Destructor.

Definition at line 82 of file maplayer.cpp.

{
    config.removeListener("highlightAttackRange", this);
    CHECKLISTENERS
    delete []mTiles;
    delete_all(mTempRows);
    mTempRows.clear();
}

References CHECKLISTENERS, config, delete_all(), mTempRows, mTiles, and Configuration::removeListener().

Member Function Documentation

calcMemoryChilds()

int MapLayer::calcMemoryChilds ( const int  level ) const

virtual

Reimplemented from MemoryCounter.

Definition at line 831 of file maplayer.cpp.

{
    int sz = 0;
    if (mSpecialLayer != nullptr)
        sz += mSpecialLayer->calcMemory(level + 1);
    if (mTempLayer != nullptr)
        sz += mTempLayer->calcMemory(level + 1);
    return sz;
}

References MemoryCounter::calcMemory(), mSpecialLayer, and mTempLayer.

calcMemoryLocal()

int MapLayer::calcMemoryLocal ( ) const

virtual

Reimplemented from MemoryCounter.

Definition at line 824 of file maplayer.cpp.

{
    return static_cast<int>(sizeof(MapLayer) +
        sizeof(TileInfo) * mWidth * mHeight +
        sizeof(MapRowVertexes) * mTempRows.capacity());
}

References MapLayer(), mHeight, mTempRows, and mWidth.

draw()

void MapLayer::draw	(	Graphics *const	graphics,
		int	startX,
		int	startY,
		int	endX,
		int	endY,
		const int	scrollX,
		const int	scrollY
	)		const

Draws this layer to the given graphics context. The coordinates are expected to be in map range and will be translated to local layer coordinates and clipped to the layer's dimensions.

The given actors are only drawn when this layer is the fringe layer.

Definition at line 100 of file maplayer.cpp.

{
    BLOCK_START("MapLayer::draw")
    startX -= mX;
    startY -= mY;
    endX -= mX;
    endY -= mY;
 
    if (startX < 0)
        startX = 0;
    if (startY < 0)
        startY = 0;
    if (endX > mWidth)
        endX = mWidth;
    if (endY > mHeight)
        endY = mHeight;
 
    const int dx = mPixelX - scrollX;
    const int dy = mPixelY - scrollY;
    for (int y = startY; y < endY; y++)
    {
        const int y32 = y * mapTileSize;
        const int yWidth = y * mWidth;
 
        const int py0 = y32 + dy;
 
        int x0 = startX;
        TileInfo *tilePtr = &mTiles[CAST_SIZE(x0 + yWidth)];
        if (tilePtr->isEnabled == false)
        {
            if (x0 + tilePtr->nextTile + 1 >= endX)
            {
                continue;
            }
            x0 += tilePtr->nextTile + 1;
            tilePtr = &mTiles[CAST_SIZE(x0 + yWidth)];
            if (mTiles[x0 + yWidth].isEnabled == false)
            {
                continue;
            }
        }
        for (int x = x0; x < endX; x++, tilePtr++)
        {
            const int x32 = x * mapTileSize;
 
            const Image *const img = tilePtr->image;
            const int px = x32 + dx;
            const int py = py0 - img->mBounds.h;
            if (mSpecialFlag ||
                img->mBounds.h <= mapTileSize)
            {
                if (tilePtr->count == 0)
                {
                    graphics->drawImage(img, px, py);
                }
                else
                {
                    graphics->drawPattern(img,
                        px,
                        py,
                        tilePtr->width,
                        img->mBounds.h);
                }
            }
 
            const int nextTile = tilePtr->nextTile;
            x += nextTile;
            tilePtr += nextTile;
        }
    }
    BLOCK_END("MapLayer::draw")
}

References BLOCK_END, BLOCK_START, CAST_SIZE, TileInfo::count, TileInfo::image, TileInfo::isEnabled, mapTileSize, TileInfo::nextTile, TileInfo::width, x, and y.

drawFringe()

void MapLayer::drawFringe	(	Graphics *const	graphics,
		int	startX,
		int	startY,
		int	endX,
		int	endY,
		const int	scrollX,
		const int	scrollY,
		const Actors &	actors
	)		const

Definition at line 425 of file maplayer.cpp.

{
    BLOCK_START("MapLayer::drawFringe")
    if ((localPlayer == nullptr) ||
        (mSpecialLayer == nullptr) ||
        (mTempLayer == nullptr))
    {
        BLOCK_END("MapLayer::drawFringe")
        return;
    }
 
    startX -= mX;
    startY -= mY;
    endX -= mX;
    endY -= mY;
 
    if (startX < 0)
        startX = 0;
    if (startY < 0)
        startY = 0;
    if (endX > mWidth)
        endX = mWidth;
    if (endY > mHeight)
        endY = mHeight;
 
    ActorsCIter ai = actors.begin();
    const ActorsCIter ai_end = actors.end();
 
    const int dx = mPixelX - scrollX;
    const int dy = mPixelY - scrollY;
 
    const int specialHeight = mSpecialLayer->mHeight;
 
    const bool flag = mDrawLayerFlags == MapType::SPECIAL3 ||
        mDrawLayerFlags == MapType::SPECIAL4 ||
        mDrawLayerFlags == MapType::BLACKWHITE;
 
    const int minEndY = std::min(specialHeight, endY);
 
    if (flag)
    {   // flag
        for (int y = startY; y < minEndY; y ++)
        {
            const int y32s = (y + mActorsFix) * mapTileSize;
 
            BLOCK_START("MapLayer::drawFringe drawmobs")
            // If drawing the fringe layer, make sure all actors above this
            // row of tiles have been drawn
            while (ai != ai_end && (*ai)->getSortPixelY() <= y32s)
            {
                (*ai)->draw(graphics, -scrollX, -scrollY);
                ++ ai;
            }
            BLOCK_END("MapLayer::drawFringe drawmobs")
 
            // remove this condition, because it always true
            if (y < specialHeight)
            {
                drawSpecialLayer(graphics,
                    y,
                    startX,
                    endX,
                    scrollX,
                    scrollY);
            }
        }
 
        for (int y = minEndY; y < endY; y++)
        {
            const int y32s = (y + mActorsFix) * mapTileSize;
 
            BLOCK_START("MapLayer::drawFringe drawmobs")
            // If drawing the fringe layer, make sure all actors above this
            // row of tiles have been drawn
            while (ai != ai_end && (*ai)->getSortPixelY() <= y32s)
            {
                (*ai)->draw(graphics, -scrollX, -scrollY);
                ++ ai;
            }
            BLOCK_END("MapLayer::drawFringe drawmobs")
        }
    }
    else
    {   // !flag
        for (int y = startY; y < minEndY; y ++)
        {
            const int y32 = y * mapTileSize;
            const int y32s = (y + mActorsFix) * mapTileSize;
            const int yWidth = y * mWidth;
 
            BLOCK_START("MapLayer::drawFringe drawmobs")
            // If drawing the fringe layer, make sure all actors above this
            // row of tiles have been drawn
            while (ai != ai_end &&
                   (*ai)->getSortPixelY() <= y32s)
            {
                (*ai)->draw(graphics, -scrollX, -scrollY);
                ++ ai;
            }
            BLOCK_END("MapLayer::drawFringe drawmobs")
 
            const int py0 = y32 + dy;
 
            int x0 = startX;
            TileInfo *tilePtr = &mTiles[CAST_SIZE(x0 + yWidth)];
            if (tilePtr->isEnabled == false)
            {
                drawSpecialLayer(graphics,
                    y,
                    0,
                    std::min(x0 + tilePtr->nextTile + 1, endX),
                    scrollX,
                    scrollY);
                if (x0 + tilePtr->nextTile + 1 >= endX)
                {
                    continue;
                }
                x0 += tilePtr->nextTile + 1;
                tilePtr = &mTiles[CAST_SIZE(x0 + yWidth)];
                if (mTiles[x0 + yWidth].isEnabled == false)
                    continue;
            }
            for (int x = x0; x < endX; x++, tilePtr++)
            {
                const int x32 = x * mapTileSize;
                const Image *const img = tilePtr->image;
                if (mSpecialFlag ||
                    img->mBounds.h <= mapTileSize)
                {
                    const int px = x32 + dx;
                    const int py = py0 - img->mBounds.h;
 
                    if (tilePtr->count == 0)
                    {
                        graphics->drawImage(img, px, py);
                    }
                    else
                    {
                        graphics->drawPattern(img,
                            px,
                            py,
                            tilePtr->width,
                            img->mBounds.h);
                    }
                }
 
                const int nextTile = tilePtr->nextTile;
                // remove this condition, because it always true
                if (y < specialHeight)
                {
                    drawSpecialLayer(graphics,
                        y,
                        x,
                        std::min(x + nextTile + 1, endX),
                        scrollX,
                        scrollY);
                }
                x += nextTile;
                tilePtr += nextTile;
            }
        }
 
        for (int y = minEndY; y < endY; y++)
        {
            const int y32 = y * mapTileSize;
            const int y32s = (y + mActorsFix) * mapTileSize;
            const int yWidth = y * mWidth;
 
            BLOCK_START("MapLayer::drawFringe drawmobs")
            // If drawing the fringe layer, make sure all actors above this
            // row of tiles have been drawn
            while (ai != ai_end && (*ai)->getSortPixelY() <= y32s)
            {
                (*ai)->draw(graphics, -scrollX, -scrollY);
                ++ ai;
            }
            BLOCK_END("MapLayer::drawFringe drawmobs")
 
            const int py0 = y32 + dy;
 
            int x0 = startX;
            TileInfo *tilePtr = &mTiles[CAST_SIZE(x0 + yWidth)];
            if (tilePtr->isEnabled == false)
            {
                if (x0 + tilePtr->nextTile + 1 >= endX)
                    continue;
                x0 += tilePtr->nextTile + 1;
                tilePtr = &mTiles[CAST_SIZE(x0 + yWidth)];
                if (mTiles[x0 + yWidth].isEnabled == false)
                    continue;
            }
            for (int x = x0; x < endX; x++, tilePtr++)
            {
                const int x32 = x * mapTileSize;
                const Image *const img = tilePtr->image;
                const int px = x32 + dx;
                const int py = py0 - img->mBounds.h;
                if (mSpecialFlag ||
                    img->mBounds.h <= mapTileSize)
                {
                    const int c = tilePtr->count;
 
                    if (c == 0)
                    {
                        graphics->drawImage(img, px, py);
                    }
                    else
                    {
                        graphics->drawPattern(img,
                            px,
                            py,
                            tilePtr->width,
                            img->mBounds.h);
                    }
                }
                const int nextTile = tilePtr->nextTile;
                x += nextTile;
                tilePtr += nextTile;
            }
        }
    }  // !flag
 
    // Draw any remaining actors
    if (mDrawLayerFlags != MapType::SPECIAL3 &&
        mDrawLayerFlags != MapType::SPECIAL4)
    {
        BLOCK_START("MapLayer::drawFringe drawmobs")
        while (ai != ai_end)
        {
            (*ai)->draw(graphics, -scrollX, -scrollY);
            ++ai;
        }
        BLOCK_END("MapLayer::drawFringe drawmobs")
        if (mHighlightAttackRange)
        {
            const int px = localPlayer->getPixelX()
                - scrollX - mapTileSize / 2;
            const int py = localPlayer->getPixelY() - scrollY - mapTileSize;
            const int attackRange = localPlayer->getAttackRange()
                * mapTileSize;
 
            int x = px - attackRange;
            int y = py - attackRange;
            int w = 2 * attackRange + mapTileSize;
            int h = w;
            if (attackRange <= mapTileSize)
            {
                x -= mapTileSize / 2;
                y -= mapTileSize / 2;
                w += mapTileSize;
                h += mapTileSize;
            }
 
            if (userPalette != nullptr)
            {
                graphics->setColor(userPalette->getColorWithAlpha(
                    UserColorId::ATTACK_RANGE));
                graphics->fillRectangle(Rect(x, y, w, h));
                graphics->setColor(userPalette->getColorWithAlpha(
                    UserColorId::ATTACK_RANGE_BORDER));
                graphics->drawRectangle(Rect(x, y, w, h));
            }
        }
    }
    BLOCK_END("MapLayer::drawFringe")
}

References UserColorId::ATTACK_RANGE, UserColorId::ATTACK_RANGE_BORDER, MapType::BLACKWHITE, BLOCK_END, BLOCK_START, CAST_SIZE, TileInfo::count, LocalPlayer::getAttackRange(), UserPalette::getColorWithAlpha(), Actor::getPixelX(), Actor::getPixelY(), TileInfo::image, TileInfo::isEnabled, localPlayer, mapTileSize, TileInfo::nextTile, MapType::SPECIAL3, MapType::SPECIAL4, userPalette, TileInfo::width, x, and y.

drawOGL()

void MapLayer::drawOGL

(

Graphics *const

graphics

)

const

Definition at line 349 of file maplayer.cpp.

{
    BLOCK_START("MapLayer::drawOGL")
    MapRows::const_iterator rit = mTempRows.begin();
    const MapRows::const_iterator rit_end = mTempRows.end();
    while (rit != rit_end)
    {
        const MapRowImages *const images = &(*rit)->images;
        MapRowImages::const_iterator iit = images->begin();
        const MapRowImages::const_iterator iit_end = images->end();
        while (iit != iit_end)
        {
            graphics->drawTileVertexes(*iit);
            ++ iit;
        }
        ++ rit;
    }
    BLOCK_END("MapLayer::drawOGL")
}

References BLOCK_END, and BLOCK_START.

drawSDL()

void MapLayer::drawSDL

(

Graphics *const

graphics

)

const

Definition at line 179 of file maplayer.cpp.

{
    BLOCK_START("MapLayer::drawSDL")
    MapRows::const_iterator rit = mTempRows.begin();
    const MapRows::const_iterator rit_end = mTempRows.end();
    while (rit != rit_end)
    {
        MapRowImages *const images = &(*rit)->images;
        MapRowImages::const_iterator iit = images->begin();
        const MapRowImages::const_iterator iit_end = images->end();
        while (iit != iit_end)
        {
            graphics->drawTileVertexes(*iit);
            ++ iit;
        }
        ++ rit;
    }
    BLOCK_END("MapLayer::drawSDL")
}

References BLOCK_END, and BLOCK_START.

drawSpecialLayer()

void MapLayer::drawSpecialLayer ( Graphics *const  graphics, const int  y, const int  startX, const int  endX, const int  scrollX, const int  scrollY  ) const

protected

Definition at line 370 of file maplayer.cpp.

{
    const int y32 = y * mapTileSize;
    const int py1 = y32 - scrollY;
    int endX1 = endX;
    int specialWidth = mSpecialLayer->mWidth;
    int ptr = y * specialWidth;
    if (endX1 > specialWidth)
        endX1 = specialWidth;
    if (endX1 < 0)
        endX1 = 0;
    int x0 = startX;
    const MapItem *item0 = mSpecialLayer->mTiles[ptr + startX];
    if ((item0 == nullptr) || item0->mType == MapItemType::EMPTY)
    {
        x0 += mSpecialLayer->mCache[ptr + startX] + 1;
    }
    for (int x = x0; x < endX1; x++)
    {
        const int px1 = x * mapTileSize - scrollX;
        const MapItem *const item = mSpecialLayer->mTiles[ptr + x];
        if (item != nullptr)
        {
            item->draw(graphics, px1, py1,
                mapTileSize, mapTileSize);
        }
        x += mSpecialLayer->mCache[ptr + x];
    }
 
    x0 = startX;
    specialWidth = mTempLayer->mWidth;
    ptr = y * specialWidth;
    endX1 = endX;
    if (endX1 > specialWidth)
        endX1 = specialWidth;
    item0 = mTempLayer->mTiles[ptr + startX];
    if ((item0 == nullptr) || item0->mType == MapItemType::EMPTY)
    {
        x0 += mTempLayer->mCache[ptr + startX] + 1;
    }
    for (int x = x0; x < endX1; x++)
    {
        const int px1 = x * mapTileSize - scrollX;
        const MapItem *const item = mTempLayer->mTiles[ptr + x];
        item->draw(graphics, px1, py1,
            mapTileSize, mapTileSize);
        x += mTempLayer->mCache[ptr + x];
    }
}

References MapItem::draw(), MapItemType::EMPTY, mapTileSize, MapItem::mType, x, and y.

getCounterName()

std::string MapLayer::getCounterName ( ) const

inlinevirtual

Reimplemented from MemoryCounter.

Definition at line 177 of file maplayer.h.

        { return mName; }

References mName.

getEmptyTileDrawWidth()

int MapLayer::getEmptyTileDrawWidth ( const TileInfo *  img, const int  endX, int &  nextTile  )

staticprotected

Definition at line 742 of file maplayer.cpp.

{
    BLOCK_START("MapLayer::getEmptyTileDrawWidth")
    int c = 0;
    for (int x = 1; x < endX; x++)
    {
        tilePtr ++;
        const Image *const img = tilePtr->image;
        if (img != nullptr && tilePtr->isEnabled == true)
            break;
        c ++;
    }
    BLOCK_END("MapLayer::getEmptyTileDrawWidth")
 
    nextTile = c;
    return c;
}

References BLOCK_END, BLOCK_START, and x.

getHeight()

int MapLayer::getHeight ( ) const

inline

Definition at line 155 of file maplayer.h.

        { return mHeight; }

References mHeight.

getTileDrawWidth()

int MapLayer::getTileDrawWidth ( const TileInfo *  img, const int  endX, int &  width, int &  nextTile  )

staticprotected

Definition at line 699 of file maplayer.cpp.

{
    BLOCK_START("MapLayer::getTileDrawWidth")
    const Image *const img1 = tilePtr->image;
    int c = 0;
    width = img1->mBounds.w;
    for (int x = 1; x < endX; x++)
    {
        tilePtr ++;
        const Image *const img = tilePtr->image;
        if (img == nullptr ||
            tilePtr->isEnabled == false)
        {
            break;
        }
        if (img != img1)
        {
            nextTile = c;
            BLOCK_END("MapLayer::getTileDrawWidth")
            return c;
        }
        c ++;
        width += img->mBounds.w;
    }
    int c2 = c;
    for (int x2 = c2 + 1; x2 < endX; x2++)
    {
        if (tilePtr->image != nullptr &&
            tilePtr->isEnabled == true)
        {
            break;
        }
        c2 ++;
        tilePtr ++;
    }
    nextTile = c2;
    BLOCK_END("MapLayer::getTileDrawWidth")
    return c;
}

References BLOCK_END, BLOCK_START, and x.

getWidth()

int MapLayer::getWidth ( ) const

inline

Definition at line 152 of file maplayer.h.

        { return mWidth; }

References mWidth.

isFringeLayer()

bool MapLayer::isFringeLayer ( ) const

inline

Definition at line 141 of file maplayer.h.

        { return mIsFringeLayer; }

References mIsFringeLayer.

Referenced by Map::updateDrawLayersList().

optionChanged()

void MapLayer::optionChanged ( const std::string &  name )

virtual

Called when an option changed. The config listener will have to be registered to the option name first.

Implements ConfigListener.

Definition at line 91 of file maplayer.cpp.

{
    if (value == "highlightAttackRange")
    {
        mHighlightAttackRange =
            config.getBoolValue("highlightAttackRange");
    }
}

References config, and Configuration::getBoolValue().

setActorsFix()

void MapLayer::setActorsFix ( const int  y )

inline

Definition at line 170 of file maplayer.h.

        { mActorsFix = y; }

References mActorsFix, and y.

setDrawLayerFlags()

void MapLayer::setDrawLayerFlags ( const MapTypeT &  n )

inline

Definition at line 161 of file maplayer.h.

        {
            mDrawLayerFlags = n;
            mSpecialFlag = (mDrawLayerFlags != MapType::SPECIAL &&
                mDrawLayerFlags != MapType::SPECIAL2 &&
                mDrawLayerFlags != MapType::SPECIAL4);
        }

References mDrawLayerFlags, mSpecialFlag, MapType::SPECIAL, MapType::SPECIAL2, and MapType::SPECIAL4.

setSpecialLayer()

void MapLayer::setSpecialLayer ( const SpecialLayer *const  val )

inline

Definition at line 144 of file maplayer.h.

        { mSpecialLayer = val; }

References mSpecialLayer.

setTempLayer()

void MapLayer::setTempLayer ( const SpecialLayer *const  val )

inline

Definition at line 148 of file maplayer.h.

        { mTempLayer = val; }

References mTempLayer.

setTile() [1/2]

void MapLayer::setTile ( const int  index, Image *const  img  )

inline

Set tile image with x + y * width already known.

Definition at line 88 of file maplayer.h.

        { mTiles[index].image = img; }

References TileInfo::image, and mTiles.

setTile() [2/2]

void MapLayer::setTile ( const int  x, const int  y, Image *const  img  )

inline

Set tile image, with x and y in layer coordinates.

Definition at line 78 of file maplayer.h.

        {
            mTiles[x + y * mWidth].image = img;
        }

References TileInfo::image, mTiles, mWidth, x, and y.

Referenced by setTile().

updateCache()

void MapLayer::updateCache ( const int  width, const int  height  )

protected

Definition at line 790 of file maplayer.cpp.

{
    const int width1 = width < mWidth ? width : mWidth;
    const int height1 = height < mHeight ? height : mHeight;
 
    for (int y = mY; y < height1; y ++)
    {
        for (int x = mX; x < width1; x ++)
        {
            TileInfo *tilePtr = mTiles + y * mWidth + x;
            int nextTile = 0;
            if (tilePtr->image == nullptr || tilePtr->isEnabled == false)
            {
                tilePtr->isEnabled = false;
                tilePtr->count = getEmptyTileDrawWidth(tilePtr,
                    width1 - x,
                    nextTile);
                tilePtr->width = 0;
            }
            else
            {
                int tileWidth = 0;
                tilePtr->count = getTileDrawWidth(tilePtr,
                    width1 - x,
                    tileWidth,
                    nextTile);
                tilePtr->width = tileWidth;
            }
            tilePtr->nextTile = nextTile;
        }
    }
}

References TileInfo::count, TileInfo::image, TileInfo::isEnabled, TileInfo::nextTile, TileInfo::width, x, and y.

updateConditionTiles()

void MapLayer::updateConditionTiles ( const MetaTile *const  metaTiles, const int  width, const int  height  )

protected

Definition at line 762 of file maplayer.cpp.

{
    const int width1 = width < mWidth ? width : mWidth;
    const int height1 = height < mHeight ? height : mHeight;
 
    for (int y = mY; y < height1; y ++)
    {
        const MetaTile *metaPtr = metaTiles + (y - mY) * width;
        TileInfo *tilePtr = mTiles + y * mWidth;
        for (int x = mX; x < width1; x ++, metaPtr ++, tilePtr ++)
        {
            if (tilePtr->image != nullptr &&
                (((metaPtr->blockmask & mTileCondition) != 0) ||
                (metaPtr->blockmask == 0 &&
                mTileCondition == BlockMask::GROUND)))
            {
                tilePtr->isEnabled = true;
            }
            else
            {
                tilePtr->isEnabled = false;
            }
        }
    }
}

References MetaTile::blockmask, BlockMask::GROUND, x, and y.

updateOGL()

void MapLayer::updateOGL	(	Graphics *const	graphics,
		int	startX,
		int	startY,
		int	endX,
		int	endY,
		const int	scrollX,
		const int	scrollY
	)

Definition at line 265 of file maplayer.cpp.

{
    BLOCK_START("MapLayer::updateOGL")
    delete_all(mTempRows);
    mTempRows.clear();
 
    startX -= mX;
    startY -= mY;
    endX -= mX;
    endY -= mY;
 
    if (startX < 0)
        startX = 0;
    if (startY < 0)
        startY = 0;
    if (endX > mWidth)
        endX = mWidth;
    if (endY > mHeight)
        endY = mHeight;
 
    const int dx = mPixelX - scrollX;
    const int dy = mPixelY - scrollY;
 
    MapRowVertexes *const row = new MapRowVertexes;
    mTempRows.push_back(row);
    Image *lastImage = nullptr;
    ImageVertexes *imgVert = nullptr;
    typedef std::map<int, ImageVertexes*> ImageVertexesMap;
    ImageVertexesMap imgSet;
 
    for (int y = startY; y < endY; y++)
    {
        const int yWidth = y * mWidth;
        const int py0 = y * mapTileSize + dy;
        TileInfo *tilePtr = &mTiles[CAST_SIZE(startX + yWidth)];
        for (int x = startX; x < endX; x++, tilePtr++)
        {
            if (!tilePtr->isEnabled)
                continue;
            Image *const img = (*tilePtr).image;
            const int px = x * mapTileSize + dx;
            const int py = py0 - img->mBounds.h;
            const GLuint imgGlImage = img->mGLImage;
            if (mSpecialFlag ||
                img->mBounds.h <= mapTileSize)
            {
                if ((lastImage == nullptr) ||
                    lastImage->mGLImage != imgGlImage)
                {
                    if (img->mBounds.w > mapTileSize)
                        imgSet.clear();
 
                    if (imgSet.find(imgGlImage) != imgSet.end())
                    {
                        imgVert = imgSet[imgGlImage];
                    }
                    else
                    {
                        if (lastImage != nullptr)
                            imgSet[lastImage->mGLImage] = imgVert;
                        imgVert = new ImageVertexes;
                        imgVert->ogl.init();
                        imgVert->image = img;
                        row->images.push_back(imgVert);
                    }
                }
                lastImage = img;
                graphics->calcTileVertexes(imgVert, lastImage, px, py);
            }
        }
    }
    FOR_EACH (MapRowImages::iterator, it, row->images)
    {
        graphics->finalize(*it);
    }
    BLOCK_END("MapLayer::updateOGL")
}

References BLOCK_END, BLOCK_START, CAST_SIZE, delete_all(), FOR_EACH, ImageVertexes::image, MapRowVertexes::images, TileInfo::isEnabled, mapTileSize, ImageVertexes::ogl, x, and y.

updateSDL()

void MapLayer::updateSDL	(	const Graphics *const	graphics,
		int	startX,
		int	startY,
		int	endX,
		int	endY,
		const int	scrollX,
		const int	scrollY
	)

Definition at line 200 of file maplayer.cpp.

{
    BLOCK_START("MapLayer::updateSDL")
    delete_all(mTempRows);
    mTempRows.clear();
 
    startX -= mX;
    startY -= mY;
    endX -= mX;
    endY -= mY;
 
    if (startX < 0)
        startX = 0;
    if (startY < 0)
        startY = 0;
    if (endX > mWidth)
        endX = mWidth;
    if (endY > mHeight)
        endY = mHeight;
 
    const int dx = mPixelX - scrollX;
    const int dy = mPixelY - scrollY;
 
    for (int y = startY; y < endY; y++)
    {
        MapRowVertexes *const row = new MapRowVertexes;
        mTempRows.push_back(row);
 
        const Image *lastImage = nullptr;
        ImageVertexes *imgVert = nullptr;
 
        const int yWidth = y * mWidth;
        const int py0 = y * mapTileSize + dy;
        TileInfo *tilePtr = &mTiles[CAST_SIZE(startX + yWidth)];
 
        for (int x = startX; x < endX; x++, tilePtr++)
        {
            if (!tilePtr->isEnabled)
                continue;
            Image *const img = (*tilePtr).image;
            const int px = x * mapTileSize + dx;
            const int py = py0 - img->mBounds.h;
            if (mSpecialFlag ||
                img->mBounds.h <= mapTileSize)
            {
                if (lastImage != img)
                {
                    imgVert = new ImageVertexes;
                    imgVert->image = img;
                    row->images.push_back(imgVert);
                    lastImage = img;
                }
                graphics->calcTileSDL(imgVert, px, py);
            }
        }
    }
    BLOCK_END("MapLayer::updateSDL")
}

References BLOCK_END, BLOCK_START, CAST_SIZE, delete_all(), ImageVertexes::image, MapRowVertexes::images, TileInfo::isEnabled, mapTileSize, x, and y.

Friends And Related Function Documentation

Map

friend class Map

friend

Definition at line 52 of file maplayer.h.

Field Documentation

mActorsFix

int MapLayer::mActorsFix

private

Definition at line 236 of file maplayer.h.

Referenced by setActorsFix().

mDrawLayerFlags

MapTypeT MapLayer::mDrawLayerFlags

private

Definition at line 228 of file maplayer.h.

Referenced by setDrawLayerFlags().

mHeight

const int MapLayer::mHeight

private

Definition at line 226 of file maplayer.h.

Referenced by calcMemoryLocal(), and getHeight().

mHighlightAttackRange

bool MapLayer::mHighlightAttackRange

private

Definition at line 238 of file maplayer.h.

mIsFringeLayer

const bool MapLayer::mIsFringeLayer

private

Whether the actors are drawn.

Definition at line 237 of file maplayer.h.

Referenced by isFringeLayer().

mMask

int MapLayer::mMask

private

Definition at line 234 of file maplayer.h.

Referenced by Map::updateDrawLayersList().

mName

const std::string MapLayer::mName

private

Definition at line 231 of file maplayer.h.

Referenced by getCounterName().

mPixelX

const int MapLayer::mPixelX

private

Definition at line 223 of file maplayer.h.

mPixelY

const int MapLayer::mPixelY

private

Definition at line 224 of file maplayer.h.

mSpecialFlag

bool MapLayer::mSpecialFlag

private

Definition at line 239 of file maplayer.h.

Referenced by setDrawLayerFlags().

mSpecialLayer

const SpecialLayer* MapLayer::mSpecialLayer

private

Definition at line 229 of file maplayer.h.

Referenced by calcMemoryChilds(), and setSpecialLayer().

mTempLayer

const SpecialLayer* MapLayer::mTempLayer

private

Definition at line 230 of file maplayer.h.

Referenced by calcMemoryChilds(), and setTempLayer().

mTempRows

MapRows MapLayer::mTempRows

private

Definition at line 233 of file maplayer.h.

Referenced by calcMemoryLocal(), and ~MapLayer().

mTileCondition

int MapLayer::mTileCondition

private

Definition at line 235 of file maplayer.h.

mTiles

TileInfo* const MapLayer::mTiles

private

Definition at line 227 of file maplayer.h.

Referenced by setTile(), and ~MapLayer().

mWidth

const int MapLayer::mWidth

private

Definition at line 225 of file maplayer.h.

Referenced by calcMemoryLocal(), getWidth(), and setTile().

mX

const int MapLayer::mX

private

Definition at line 221 of file maplayer.h.

mY

const int MapLayer::mY

private

Definition at line 222 of file maplayer.h.

---

The documentation for this class was generated from the following files:

• src/resources/map/maplayer.h (986a3bf)
• src/resources/map/maplayer.cpp (986a3bf)