C4Landscape Class Reference

#include <C4Landscape.h>

Classes
struct	P

Public Member Functions
	C4Landscape ()
	~C4Landscape ()
void	Default ()
void	Clear (bool fClearMapCreator=true, bool fClearSky=true, bool fClearRenderer=true)
void	Execute ()
void	Synchronize ()
void	Draw (C4TargetFacet &cgo, class C4FoWRegion *pLight=nullptr)
void	ScenarioInit ()
void	DrawMaterialRect (int32_t mat, int32_t tx, int32_t ty, int32_t wdt, int32_t hgt)
void	RaiseTerrain (int32_t tx, int32_t ty, int32_t wdt)
void	FindMatTop (int32_t mat, int32_t &x, int32_t &y, bool distant_first) const
BYTE	GetMapIndex (int32_t iX, int32_t iY) const
BYTE	GetBackMapIndex (int32_t iX, int32_t iY) const
bool	Load (C4Group &hGroup, bool fLoadSky, bool fSavegame)
bool	Save (C4Group &hGroup) const
bool	SaveDiff (C4Group &hGroup, bool fSyncSave) const
bool	SaveMap (C4Group &hGroup) const
bool	SaveInitial ()
bool	SaveTextures (C4Group &hGroup) const
bool	Init (C4Group &hGroup, bool fOverloadCurrent, bool fLoadSky, bool &rfLoaded, bool fSavegame)
bool	HasMap () const
bool	MapToLandscape ()
bool	ApplyDiff (C4Group &hGroup)
void	SetMode (LandscapeMode iMode)
LandscapeMode	GetMode () const
bool	SetPix2 (int32_t x, int32_t y, BYTE fgPix, BYTE bgPix)
bool	_SetPix2 (int32_t x, int32_t y, BYTE fgPix, BYTE bgPix)
void	_SetPix2Tmp (int32_t x, int32_t y, BYTE fgPix, BYTE bgPix)
bool	InsertMaterialOutsideLandscape (int32_t tx, int32_t ty, int32_t mdens)
bool	InsertMaterial (int32_t mat, int32_t *tx, int32_t *ty, int32_t vx=0, int32_t vy=0, bool query_only=false)
bool	InsertDeadMaterial (int32_t mat, int32_t tx, int32_t ty)
bool	FindMatPath (int32_t &fx, int32_t &fy, int32_t ydir, int32_t mdens, int32_t mslide) const
bool	FindMatSlide (int32_t &fx, int32_t &fy, int32_t ydir, int32_t mdens, int32_t mslide) const
bool	FindMatPathPush (int32_t &fx, int32_t &fy, int32_t mdens, int32_t mslide, bool liquid) const
bool	Incinerate (int32_t x, int32_t y, int32_t cause_player)
bool	DrawBrush (int32_t iX, int32_t iY, int32_t iGrade, const char *szMaterial, const char *szTexture, const char *szBackMaterial, const char *szBackTexture)
bool	DrawLine (int32_t iX1, int32_t iY1, int32_t iX2, int32_t iY2, int32_t iGrade, const char *szMaterial, const char *szTexture, const char *szBackMaterial, const char *szBackTexture)
bool	DrawBox (int32_t iX1, int32_t iY1, int32_t iX2, int32_t iY2, int32_t iGrade, const char *szMaterial, const char *szTexture, const char *szBackMaterial, const char *szBackTexture)
bool	DrawChunks (int32_t tx, int32_t ty, int32_t wdt, int32_t hgt, int32_t icntx, int32_t icnty, const char *szMaterial, const char *szTexture, bool bIFT)
bool	DrawQuad (int32_t iX1, int32_t iY1, int32_t iX2, int32_t iY2, int32_t iX3, int32_t iY3, int32_t iX4, int32_t iY4, const char *szMaterial, const char *szBackMaterial, bool fDrawBridge)
bool	DrawPolygon (int *vtcs, int length, const char *szMaterial, const char *szBackMaterial, bool fDrawBridge)
CStdPalette *	GetPal () const
int32_t	GetWidth () const
int32_t	GetHeight () const
int32_t	GetMapZoom () const
C4Real	GetGravity () const
void	SetGravity (C4Real g)
BYTE	_GetPix (int32_t x, int32_t y) const
BYTE	GetPix (int32_t x, int32_t y) const
int32_t	_GetMat (int32_t x, int32_t y) const
int32_t	_GetDensity (int32_t x, int32_t y) const
int32_t	_GetPlacement (int32_t x, int32_t y) const
int32_t	GetMat (int32_t x, int32_t y) const
int32_t	GetDensity (int32_t x, int32_t y) const
int32_t	GetPlacement (int32_t x, int32_t y) const
BYTE	_GetBackPix (int32_t x, int32_t y) const
BYTE	GetBackPix (int32_t x, int32_t y) const
int32_t	_GetBackMat (int32_t x, int32_t y) const
int32_t	_GetBackDensity (int32_t x, int32_t y) const
int32_t	_GetBackPlacement (int32_t x, int32_t y) const
int32_t	GetBackMat (int32_t x, int32_t y) const
int32_t	GetBackDensity (int32_t x, int32_t y) const
int32_t	GetBackPlacement (int32_t x, int32_t y) const
bool	GetLight (int32_t x, int32_t y)
bool	_GetLight (int32_t x, int32_t y)
bool	_FastSolidCheck (int32_t x, int32_t y) const
int32_t	GetPixMat (BYTE byPix) const
int32_t	GetPixDensity (BYTE byPix) const
bool	_PathFree (int32_t x, int32_t y, int32_t x2, int32_t y2) const
int32_t	GetMatHeight (int32_t x, int32_t y, int32_t iYDir, int32_t iMat, int32_t iMax) const
int32_t	AreaSolidCount (int32_t x, int32_t y, int32_t wdt, int32_t hgt) const
int32_t	ExtractMaterial (int32_t fx, int32_t fy, bool distant_first)
bool	DrawMap (int32_t iX, int32_t iY, int32_t iWdt, int32_t iHgt, const char *szMapDef, bool ignoreSky=false)
bool	ClipRect (int32_t &rX, int32_t &rY, int32_t &rWdt, int32_t &rHgt) const
bool	DrawDefMap (int32_t iX, int32_t iY, int32_t iWdt, int32_t iHgt, const char *szMapDef, bool ignoreSky=false)
bool	SetModulation (DWORD dwWithClr)
DWORD	GetModulation () const
bool	PostInitMap ()
bool	ReplaceMapColor (BYTE iOldIndex, BYTE iNewIndex)
bool	SetTextureIndex (const char *szMatTex, BYTE iNewIndex, bool fInsert)
void	SetMapChanged ()
void	HandleTexMapUpdate ()
void	UpdatePixMaps ()
bool	DoRelights ()
void	RemoveUnusedTexMapEntries ()
class C4Sky &	GetSky ()
bool	HasFoW () const
class C4FoW *	GetFoW ()
int32_t	GetMatCount (int material) const
int32_t	GetEffectiveMatCount (int material) const
int32_t	DigFreeShape (int *vtcs, int length, C4Object *by_object=nullptr, bool no_dig2objects=false, bool no_instability_check=false)
void	BlastFreeShape (int *vtcs, int length, C4Object *by_object=nullptr, int32_t by_player=NO_OWNER, int32_t iMaxDensity=C4M_Vehicle)
void	ClearFreeRect (int32_t tx, int32_t ty, int32_t wdt, int32_t hgt)
int32_t	DigFreeRect (int32_t tx, int32_t ty, int32_t wdt, int32_t hgt, C4Object *by_object=nullptr, bool no_dig2objects=false, bool no_instability_check=false)
int32_t	DigFree (int32_t tx, int32_t ty, int32_t rad, C4Object *by_object=nullptr, bool no_dig2objects=false, bool no_instability_check=false)
void	ShakeFree (int32_t tx, int32_t ty, int32_t rad)
void	BlastFree (int32_t tx, int32_t ty, int32_t rad, int32_t caused_by=NO_OWNER, C4Object *by_object=nullptr, int32_t iMaxDensity=C4M_Vehicle)
void	CheckInstabilityRange (int32_t tx, int32_t ty)
bool	CheckInstability (int32_t tx, int32_t ty, int32_t recursion_count=0)
bool	ClearPix (int32_t tx, int32_t ty)
void	ClearPointers (C4Object *pObj)
void	CompileFunc (StdCompiler *pComp)

Static Public Member Functions
static int32_t	FastSolidCheckNextX (int32_t x)

Static Public Attributes
static const uint8_t	Transparent = C4M_MaxTexIndex

Detailed Description

Definition at line 37 of file C4Landscape.h.

Constructor & Destructor Documentation

C4Landscape()

C4Landscape::C4Landscape

(

)

Definition at line 189 of file C4Landscape.cpp.

    : p(new P)
{
    Default();
}

References Default().

Here is the call graph for this function:

~C4Landscape()

C4Landscape::~C4Landscape

(

)

Definition at line 195 of file C4Landscape.cpp.

{
    Clear();
}

References Clear().

Here is the call graph for this function:

Member Function Documentation

_FastSolidCheck()

bool C4Landscape::_FastSolidCheck	(	int32_t	x,
		int32_t	y
	)		const

Definition at line 3823 of file C4Landscape.cpp.

{
    return p->PixCnt[(x / 17) * p->PixCntPitch + (y / 15)] > 0;
}

References CPolyEdge::x, and CPolyEdge::y.

Referenced by C4FoWLightSection::Update().

Here is the caller graph for this function:

_GetBackDensity()

int32_t C4Landscape::_GetBackDensity	(	int32_t	x,
		int32_t	y
	)		const

Definition at line 3788 of file C4Landscape.cpp.

{
    return p->Pix2Dens[_GetBackPix(x, y)];
}

References _GetBackPix(), CPolyEdge::x, and CPolyEdge::y.

Here is the call graph for this function:

_GetBackMat()

int32_t C4Landscape::_GetBackMat	(	int32_t	x,
		int32_t	y
	)		const

Definition at line 3783 of file C4Landscape.cpp.

{
    return p->Pix2Mat[_GetBackPix(x, y)];
}

References _GetBackPix(), CPolyEdge::x, and CPolyEdge::y.

Here is the call graph for this function:

_GetBackPix()

BYTE C4Landscape::_GetBackPix	(	int32_t	x,
		int32_t	y
	)		const

Definition at line 3752 of file C4Landscape.cpp.

{
#ifdef _DEBUG
    if (x < 0 || y < 0 || x >= p->Width || y >= p->Height) { BREAKPOINT_HERE; }
#endif
    return p->Surface8Bkg->_GetPix(x, y);
}

References BREAKPOINT_HERE, CPolyEdge::x, and CPolyEdge::y.

Referenced by _GetBackDensity(), _GetBackMat(), _GetBackPlacement(), and _GetLight().

Here is the caller graph for this function:

_GetBackPlacement()

int32_t C4Landscape::_GetBackPlacement	(	int32_t	x,
		int32_t	y
	)		const

Definition at line 3793 of file C4Landscape.cpp.

{
    return p->Pix2Place[_GetBackPix(x, y)];
}

References _GetBackPix(), CPolyEdge::x, and CPolyEdge::y.

Here is the call graph for this function:

_GetDensity()

int32_t C4Landscape::_GetDensity	(	int32_t	x,
		int32_t	y
	)		const

Definition at line 3727 of file C4Landscape.cpp.

{
    return p->Pix2Dens[_GetPix(x, y)];
}

References _GetPix(), CPolyEdge::x, and CPolyEdge::y.

Referenced by C4Landscape::P::UpdatePixCnt().

Here is the call graph for this function:

Here is the caller graph for this function:

_GetLight()

bool C4Landscape::_GetLight	(	int32_t	x,
		int32_t	y
	)

Definition at line 3818 of file C4Landscape.cpp.

{
    return _GetBackPix(x, y) == 0 || p->Pix2Light[_GetPix(x, y)];
}

References _GetBackPix(), _GetPix(), CPolyEdge::x, and CPolyEdge::y.

Here is the call graph for this function:

_GetMat()

int32_t C4Landscape::_GetMat	(	int32_t	x,
		int32_t	y
	)		const

Definition at line 3722 of file C4Landscape.cpp.

{
    return p->Pix2Mat[_GetPix(x, y)];
}

References _GetPix(), CPolyEdge::x, and CPolyEdge::y.

Referenced by C4Landscape::P::DoScan(), C4Landscape::P::ExecuteScan(), GetMatHeight(), InsertDeadMaterial(), and C4Landscape::P::UpdateMatCnt().

Here is the call graph for this function:

Here is the caller graph for this function:

_GetPix()

BYTE C4Landscape::_GetPix	(	int32_t	x,
		int32_t	y
	)		const

Definition at line 3691 of file C4Landscape.cpp.

{
#ifdef _DEBUG
    if (x < 0 || y < 0 || x >= p->Width || y >= p->Height) { BREAKPOINT_HERE; }
#endif
    return p->Surface8->_GetPix(x, y);
}

References BREAKPOINT_HERE, CPolyEdge::x, and CPolyEdge::y.

Referenced by _GetDensity(), _GetLight(), _GetMat(), _GetPlacement(), _SetPix2(), C4Landscape::P::DoScan(), InsertDeadMaterial(), C4SolidMask::Put(), C4SolidMask::Remove(), SetPix2(), and C4LandscapeRenderGL::Update().

Here is the caller graph for this function:

_GetPlacement()

int32_t C4Landscape::_GetPlacement	(	int32_t	x,
		int32_t	y
	)		const

Definition at line 3732 of file C4Landscape.cpp.

{
    return p->Pix2Place[_GetPix(x, y)];
}

References _GetPix(), CPolyEdge::x, and CPolyEdge::y.

Referenced by C4LandscapeRenderGL::Update().

Here is the call graph for this function:

Here is the caller graph for this function:

_PathFree()

bool C4Landscape::_PathFree	(	int32_t	x,
		int32_t	y,
		int32_t	x2,
		int32_t	y2
	)		const

Definition at line 3837 of file C4Landscape.cpp.

{
    x /= 17; y /= 15; x2 /= 17; y2 /= 15;
    while (x != x2 && y != y2)
    {
        if (p->PixCnt[x * p->PixCntPitch + y])
            return false;
        if (x > x2) x--; else x++;
        if (y > y2) y--; else y++;
    }
    if (x != x2)
        do
        {
            if (p->PixCnt[x * p->PixCntPitch + y])
                return false;
            if (x > x2) x--; else x++;
        } while (x != x2);
    else
        while (y != y2)
        {
            if (p->PixCnt[x * p->PixCntPitch + y])
                return false;
            if (y > y2) y--; else y++;
        }
    return !p->PixCnt[x * p->PixCntPitch + y];
}

References CPolyEdge::x, and CPolyEdge::y.

_SetPix2()

bool C4Landscape::_SetPix2	(	int32_t	x,
		int32_t	y,
		BYTE	fgPix,
		BYTE	bgPix
	)

Definition at line 798 of file C4Landscape.cpp.

{
    if (Config.General.DebugRec)
    {
        C4RCSetPix rc;
        rc.x = x; rc.y = y; rc.clr = fgPix; rc.bgClr = fgPix;
        AddDbgRec(RCT_SetPix, &rc, sizeof(rc));
    }
    assert(x >= 0 && y >= 0 && x < GetWidth() && y < GetHeight());
    // get pixel and resolve transparency to already existing pixel
    BYTE opix = _GetPix(x, y);
    if (fgPix == Transparent) fgPix = opix;
    if (bgPix == Transparent) bgPix = p->Surface8Bkg->_GetPix(x, y);
    // check pixel
    if (fgPix == opix && bgPix == p->Surface8Bkg->_GetPix(x, y)) return true;
    // count pixels
    if (p->Pix2Dens[fgPix])
    {
        if (!p->Pix2Dens[opix]) p->PixCnt[(y / 15) + (x / 17) * p->PixCntPitch]++;
    }
    else
    {
        if (p->Pix2Dens[opix]) p->PixCnt[(y / 15) + (x / 17) * p->PixCntPitch]--;
    }
    // count material
    assert(!fgPix || MatValid(p->Pix2Mat[fgPix]));
    int32_t omat = p->Pix2Mat[opix], nmat = p->Pix2Mat[fgPix];
    if (opix) p->MatCount[omat]--;
    if (fgPix) p->MatCount[nmat]++;
    // count effective material
    if (omat != nmat)
    {
        if (fgPix && ::MaterialMap.Map[nmat].MinHeightCount)
        {
            // Check for material above & below
            int iMinHeight = ::MaterialMap.Map[nmat].MinHeightCount,
                iBelow = GetMatHeight(x, y + 1, +1, nmat, iMinHeight),
                iAbove = GetMatHeight(x, y - 1, -1, nmat, iMinHeight);
            // Will be above treshold?
            if (iBelow + iAbove + 1 >= iMinHeight)
            {
                int iChange = 1;
                // Check for heights below threshold
                if (iBelow < iMinHeight) iChange += iBelow;
                if (iAbove < iMinHeight) iChange += iAbove;
                // Change
                p->EffectiveMatCount[nmat] += iChange;
            }
        }
        if (opix && ::MaterialMap.Map[omat].MinHeightCount)
        {
            // Check for material above & below
            int iMinHeight = ::MaterialMap.Map[omat].MinHeightCount,
                iBelow = GetMatHeight(x, y + 1, +1, omat, iMinHeight),
                iAbove = GetMatHeight(x, y - 1, -1, omat, iMinHeight);
            // Not already below threshold?
            if (iBelow + iAbove + 1 >= iMinHeight)
            {
                int iChange = 1;
                // Check for heights that will get below threshold
                if (iBelow < iMinHeight) iChange += iBelow;
                if (iAbove < iMinHeight) iChange += iAbove;
                // Change
                p->EffectiveMatCount[omat] -= iChange;
            }
        }
    }
    // set 8bpp-surface only!
    p->Surface8->SetPix(x, y, fgPix);
    p->Surface8Bkg->SetPix(x, y, bgPix);
    // note for relight
    if (p->pLandscapeRender)
    {
        C4Rect CheckRect = p->pLandscapeRender->GetAffectedRect(C4Rect(x, y, 1, 1));
        for (int32_t i = 0; i < C4LS_MaxRelights; i++)
            if (!p->Relights[i].Wdt || p->Relights[i].Overlap(CheckRect) || i + 1 >= C4LS_MaxRelights)
            {
                p->Relights[i].Add(CheckRect);
                break;
            }
        // Invalidate FoW
        if (p->pFoW)
            p->pFoW->Invalidate(CheckRect);
    }
    // success
    return true;
}

References _GetPix(), AddDbgRec(), C4RCSetPix::bgClr, C4LS_MaxRelights, C4RCSetPix::clr, Config, C4ConfigGeneral::DebugRec, C4Config::General, GetHeight(), GetMatHeight(), GetWidth(), C4MaterialMap::Map, MaterialMap, MatValid(), C4MaterialCore::MinHeightCount, RCT_SetPix, Transparent, C4RCSetPix::x, and C4RCSetPix::y.

Referenced by C4TextureShape::Draw(), C4SolidMask::Remove(), and SetPix2().

Here is the call graph for this function:

Here is the caller graph for this function:

_SetPix2Tmp()

void C4Landscape::_SetPix2Tmp	(	int32_t	x,
		int32_t	y,
		BYTE	fgPix,
		BYTE	bgPix
	)

Definition at line 886 of file C4Landscape.cpp.

{
    // set 8bpp-surface only!
    assert(x >= 0 && y >= 0 && x < GetWidth() && y < GetHeight());
    if (fgPix != Transparent) p->Surface8->SetPix(x, y, fgPix);
    if (bgPix != Transparent) p->Surface8Bkg->SetPix(x, y, bgPix);
}

References GetHeight(), GetWidth(), and Transparent.

Referenced by C4SolidMask::PutTemporary(), and C4SolidMask::RemoveTemporary().

Here is the call graph for this function:

Here is the caller graph for this function:

ApplyDiff()

bool C4Landscape::ApplyDiff

(

C4Group &

hGroup

)

Definition at line 1901 of file C4Landscape.cpp.

{
    std::unique_ptr<CSurface8> pDiff, pDiffBkg;
    // Load diff landscape from group
    pDiff = GroupReadSurface8(hGroup, C4CFN_DiffLandscape);
    pDiffBkg = GroupReadSurface8(hGroup, C4CFN_DiffLandscapeBkg);
    if (pDiff == nullptr && pDiffBkg == nullptr) return false;
 
    // convert all pixels: keep if same material; re-set if different material
    BYTE byPix;
    for (int32_t y = 0; y < GetHeight(); ++y) for (int32_t x = 0; x < GetWidth(); ++x)
    {
        if (pDiff && pDiff->GetPix(x, y) != C4M_MaxTexIndex)
            if (p->Surface8->_GetPix(x, y) != (byPix = pDiff->_GetPix(x, y)))
                // material has changed here: readjust with new texture
                p->Surface8->SetPix(x, y, byPix);
        if (pDiffBkg && pDiffBkg->GetPix(x, y) != C4M_MaxTexIndex)
            if (p->Surface8Bkg->_GetPix(x, y) != (byPix = pDiffBkg->_GetPix(x, y)))
                p->Surface8Bkg->_SetPix(x, y, byPix);
    }
 
    // done
    return true;
}

AreaSolidCount()

int32_t C4Landscape::AreaSolidCount	(	int32_t	x,
		int32_t	y,
		int32_t	wdt,
		int32_t	hgt
	)		const

Definition at line 3328 of file C4Landscape.cpp.

{
    int32_t cx, cy, ascnt = 0;
    for (cy = y; cy < y + hgt; cy++)
        for (cx = x; cx < x + wdt; cx++)
            if (GBackSolid(cx, cy))
                ascnt++;
    return ascnt;
}

References GBackSolid(), CPolyEdge::x, and CPolyEdge::y.

Referenced by ConstructionCheck().

Here is the call graph for this function:

Here is the caller graph for this function:

BlastFree()

void C4Landscape::BlastFree	(	int32_t	tx,
		int32_t	ty,
		int32_t	rad,
		int32_t	caused_by = NO_OWNER,
		C4Object *	by_object = nullptr,
		int32_t	iMaxDensity = C4M_Vehicle
	)

Definition at line 507 of file C4Landscape.cpp.

{
    std::vector<int32_t> vertices(GetRoundPolygon(tx, ty, rad, 30));
    BlastFreeShape(&vertices[0], vertices.size(), by_object, caused_by, iMaxDensity);
}

BlastFreeShape()

void C4Landscape::BlastFreeShape	(	int *	vtcs,
		int	length,
		C4Object *	by_object = nullptr,
		int32_t	by_player = NO_OWNER,
		int32_t	iMaxDensity = C4M_Vehicle
	)

Definition at line 597 of file C4Landscape.cpp.

{
    C4MaterialList *MaterialContents = nullptr;
 
    C4Rect BoundingBox = getBoundingBox(vtcs, length);
 
    // Remember any collectible objects in area
    std::unique_ptr<C4ValueArray> dig_objects(p->PrepareFreeShape(BoundingBox, by_object));
 
    uint8_t *pblast_tbl = nullptr, blast_tbl[C4M_MaxTexIndex];
    if (iMaxDensity < C4M_Vehicle)
    {
        for (int32_t i = 0; i < C4M_MaxTexIndex; ++i) blast_tbl[i] = (GetPixDensity(i) <= iMaxDensity);
        pblast_tbl = blast_tbl;
    }
 
    if (by_object)
    {
        if (!by_object->MaterialContents)
            by_object->MaterialContents = new C4MaterialList;
        p->ForPolygon(this, vtcs, length / 2, [this](int32_t x, int32_t y) { return p->BlastFreePix(this, x, y); }, by_object->MaterialContents, 0, 0, pblast_tbl);
    }
    else
    {
        MaterialContents = new C4MaterialList;
        p->ForPolygon(this, vtcs, length / 2, [this](int32_t x, int32_t y) { return p->BlastFreePix(this, x, y); }, MaterialContents, iMaxDensity);
    }
 
    // create objects from the material
    C4MaterialList *mat_list = nullptr;
    if (by_object)
        mat_list = by_object->MaterialContents;
    else
        mat_list = MaterialContents;
 
    int32_t tx = BoundingBox.GetMiddleX(), ty = BoundingBox.GetMiddleY();
    p->BlastMaterial2Objects(tx, ty, mat_list, by_player, (BoundingBox.Wdt + BoundingBox.Hgt) / 4, dig_objects.get());
 
    if (MaterialContents) delete MaterialContents;
 
    // Do callbacks to digger for objects that are now dug free
    p->PostFreeShape(dig_objects.get(), by_object);
}

CheckInstability()

bool C4Landscape::CheckInstability	(	int32_t	tx,
		int32_t	ty,
		int32_t	recursion_count = 0
	)

Definition at line 894 of file C4Landscape.cpp.

{
    int32_t mat = GetMat(tx, ty);
    if (MatValid(mat)) {
        const C4Material &material = MaterialMap.Map[mat];
        if (material.Instable)
            return ::MassMover.Create(tx, ty);
        // Get rid of single pixels
        else if (DensitySolid(material.Density) && !material.KeepSinglePixels && recursion_count < 10)
            if ((!::GBackSolid(tx, ty + 1)) + (!::GBackSolid(tx, ty - 1)) + (!::GBackSolid(tx + 1, ty)) + (!::GBackSolid(tx - 1, ty)) >= 3)
            {
                if (!ClearPix(tx, ty)) return false;
                // Diggable material drops; other material just gets removed
                if (material.DigFree) ::PXS.Create(mat, itofix(tx), itofix(ty));
                // check other pixels around this
                // Note this cannot lead to an endless recursion (unless you do funny stuff like e.g. set DigFree=1 in material Tunnel).
                // Check recursion anyway, because very large strips of single pixel width might cause sufficient recursion to crash
                CheckInstability(tx + 1, ty, ++recursion_count);
                CheckInstability(tx - 1, ty, recursion_count);
                CheckInstability(tx, ty - 1, recursion_count);
                CheckInstability(tx, ty + 1, recursion_count);
                return true;
            }
    }
    return false;
}

References ClearPix(), C4PXSSystem::Create(), C4MassMoverSet::Create(), C4MaterialCore::Density, DensitySolid(), C4MaterialCore::DigFree, GBackSolid(), GetMat(), C4MaterialCore::Instable, itofix(), C4MaterialCore::KeepSinglePixels, C4MaterialMap::Map, MassMover, MaterialMap, MatValid(), and PXS.

Referenced by CheckInstabilityRange().

Here is the call graph for this function:

Here is the caller graph for this function:

CheckInstabilityRange()

void C4Landscape::CheckInstabilityRange	(	int32_t	tx,
		int32_t	ty
	)

Definition at line 921 of file C4Landscape.cpp.

{
    if (!CheckInstability(tx, ty))
    {
        CheckInstability(tx, ty - 1);
        CheckInstability(tx, ty - 2);
        CheckInstability(tx - 1, ty);
        CheckInstability(tx + 1, ty);
    }
}

References CheckInstability().

Referenced by C4Landscape::P::BlastFreePix(), C4Landscape::P::DigFreePix(), C4Landscape::P::DoScan(), ExtractMaterial(), C4SolidMask::Remove(), and C4Landscape::P::ShakeFreePix().

Here is the call graph for this function:

Here is the caller graph for this function:

Clear()

void C4Landscape::Clear	(	bool	fClearMapCreator = true,
		bool	fClearSky = true,
		bool	fClearRenderer = true
	)

Definition at line 1357 of file C4Landscape.cpp.

{
    if (fClearMapCreator) { p->pMapCreator.reset(); }
    // clear sky
    if (fClearSky) p->Sky.Clear();
    // clear surfaces, if assigned
    if (fClearRenderer) { p->pLandscapeRender.reset(); }
    p->TopRowPix.clear();
    p->BottomRowPix.clear();
    p->LeftColPix.clear();
    p->RightColPix.clear();
    p->Surface8.reset();
    p->Surface8Bkg.reset();
    p->Map.reset();
    p->MapBkg.reset();
    // clear initial landscape
    p->pInitial.reset();
    p->pInitialBkg.reset();
    p->pFoW.reset();
    // clear relight array
    for (auto &relight : p->Relights)
        relight.Default();
    // clear scan
    p->ScanX = 0;
    p->mode = LandscapeMode::Undefined;
    // clear pixel count
    p->PixCnt.clear();
    p->PixCntPitch = 0;
    // clear bridge material conversion temp buffers
    for (auto &conv : p->BridgeMatConversion)
        conv.reset();
}

References Undefined.

Referenced by C4Game::Clear(), and ~C4Landscape().

Here is the caller graph for this function:

ClearFreeRect()

void C4Landscape::ClearFreeRect	(	int32_t	tx,
		int32_t	ty,
		int32_t	wdt,
		int32_t	hgt
	)

Definition at line 486 of file C4Landscape.cpp.

{
    std::vector<int32_t> vertices(GetRectangle(tx, ty, wdt, hgt));
    C4Rect r(tx, ty, wdt, hgt);
    p->PrepareChange(this, r, false);
    p->ForPolygon(this, &vertices[0], vertices.size() / 2, [this](int32_t x, int32_t y) { return ClearPix(x, y); });
    p->FinishChange(this, r, false);
}

ClearPix()

bool C4Landscape::ClearPix	(	int32_t	tx,
		int32_t	ty
	)

Definition at line 774 of file C4Landscape.cpp.

{
    // Replace pixel with background pixel
    BYTE bkgPix = p->Surface8Bkg->GetPix(tx, ty);
    return SetPix2(tx, ty, bkgPix, bkgPix);
}

References SetPix2().

Referenced by C4Landscape::P::BlastFreePix(), CheckInstability(), C4Landscape::P::DigFreePix(), C4Landscape::P::DigFreePixNoInstability(), ExtractMaterial(), C4MaterialMap::mrfCorrode(), and C4Landscape::P::ShakeFreePix().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearPointers()

void C4Landscape::ClearPointers

(

C4Object *

pObj

)

Definition at line 781 of file C4Landscape.cpp.

{
    if (p->pFoW) p->pFoW->Remove(pObj);
}

Referenced by C4Game::ClearPointers().

Here is the caller graph for this function:

ClipRect()

bool C4Landscape::ClipRect	(	int32_t &	rX,
		int32_t &	rY,
		int32_t &	rWdt,
		int32_t &	rHgt
	)		const

Definition at line 4027 of file C4Landscape.cpp.

{
    // clip by bounds
    if (rX < 0) { rWdt += rX; rX = 0; }
    if (rY < 0) { rHgt += rY; rY = 0; }
    int32_t iOver;
 
    iOver = rX + rWdt - GetWidth();
    if (iOver > 0)
        rWdt -= iOver;
 
    iOver = rY + rHgt - GetHeight();
    if (iOver > 0)
        rHgt -= iOver;
 
    // anything left inside the bounds?
    return rWdt > 0 && rHgt > 0;
}

References GetHeight(), and GetWidth().

Referenced by DrawDefMap(), and DrawMap().

Here is the call graph for this function:

Here is the caller graph for this function:

CompileFunc()

void C4Landscape::CompileFunc

(

StdCompiler *

pComp

)

Definition at line 1390 of file C4Landscape.cpp.

{
    pComp->Value(mkNamingAdapt(p->MapSeed, "MapSeed", 0));
    pComp->Value(mkNamingAdapt(mkCastIntAdapt(p->Gravity), "Gravity", DefaultGravAccel));
    pComp->Value(mkNamingAdapt(p->Modulation, "MatModulation", 0U));
    pComp->Value(mkNamingAdapt(mkCastIntAdapt(p->mode), "Mode", LandscapeMode::Undefined));
 
    if (pComp->isDeserializer())
    {
        int32_t ambient_brightness;
        pComp->Value(mkNamingAdapt(ambient_brightness, "AmbientBrightness", 255));
        if (p->pFoW) p->pFoW->Ambient.SetBrightness(ambient_brightness / static_cast<double>(255));
    }
    else
    {
        if (p->pFoW)
        {
            int32_t ambient_brightness = static_cast<int32_t>(p->pFoW->Ambient.GetBrightness() * 255 + 0.5);
            pComp->Value(mkNamingAdapt(ambient_brightness, "AmbientBrightness", 255));
        }
    }
}

References DefaultGravAccel, StdCompiler::isDeserializer(), mkCastIntAdapt(), mkNamingAdapt(), Undefined, and StdCompiler::Value().

Here is the call graph for this function:

Default()

void C4Landscape::Default

(

)

Definition at line 1926 of file C4Landscape.cpp.

{
    p = std::make_unique<P>();
}

Referenced by C4Landscape(), and C4Game::Default().

Here is the caller graph for this function:

DigFree()

int32_t C4Landscape::DigFree	(	int32_t	tx,
		int32_t	ty,
		int32_t	rad,
		C4Object *	by_object = nullptr,
		bool	no_dig2objects = false,
		bool	no_instability_check = false
	)

Definition at line 501 of file C4Landscape.cpp.

{
    std::vector<int32_t> vertices(GetRoundPolygon(tx, ty, rad, 80));
    return DigFreeShape(&vertices[0], vertices.size(), by_object, no_dig2objects, no_instability_check);
}

DigFreeRect()

int32_t C4Landscape::DigFreeRect	(	int32_t	tx,
		int32_t	ty,
		int32_t	wdt,
		int32_t	hgt,
		C4Object *	by_object = nullptr,
		bool	no_dig2objects = false,
		bool	no_instability_check = false
	)

Definition at line 495 of file C4Landscape.cpp.

{
    std::vector<int32_t> vertices(GetRectangle(tx, ty, wdt, hgt));
    return DigFreeShape(&vertices[0], vertices.size(), by_object, no_dig2objects, no_instability_check);
}

Referenced by C4Game::CreateObjectConstruction().

Here is the caller graph for this function:

DigFreeShape()

int32_t C4Landscape::DigFreeShape	(	int *	vtcs,
		int	length,
		C4Object *	by_object = nullptr,
		bool	no_dig2objects = false,
		bool	no_instability_check = false
	)

Definition at line 554 of file C4Landscape.cpp.

{
    using namespace std::placeholders;
 
    C4Rect BoundingBox = getBoundingBox(vtcs, length);
    int32_t amount;
 
    // Remember any collectible objects in area
    std::unique_ptr<C4ValueArray> dig_objects(p->PrepareFreeShape(BoundingBox, by_object));
 
    std::function<bool(int32_t, int32_t)> callback;
    if (no_instability_check)
        callback = [this](int32_t x, int32_t y) { return p->DigFreePixNoInstability(this, x, y); };
    else
        callback = [this](int32_t x, int32_t y) { return p->DigFreePix(this, x, y); };
 
    if (by_object)
    {
        if (!by_object->MaterialContents)
            by_object->MaterialContents = new C4MaterialList;
        amount = p->ForPolygon(this, vtcs, length / 2, callback, by_object->MaterialContents);
    }
    else
        amount = p->ForPolygon(this, vtcs, length / 2, callback, nullptr);
 
    // create objects from the material
    if (!::Game.iTick5)
    {
        if (!no_dig2objects)
            if (by_object)
                if (by_object->MaterialContents)
                {
                    int32_t tx = BoundingBox.GetMiddleX(), ty = BoundingBox.GetBottom();
                    p->DigMaterial2Objects(tx, ty, by_object->MaterialContents, by_object);
                }
    }
 
    // Do callbacks to digger for objects that are now dug free
    p->PostFreeShape(dig_objects.get(), by_object);
 
    return amount;
}

DoRelights()

bool C4Landscape::DoRelights

(

)

Definition at line 390 of file C4Landscape.cpp.

{
    if (!p->pLandscapeRender) return true;
    for (int32_t i = 0; i < C4LS_MaxRelights; i++)
    {
        if (!p->Relights[i].Wdt)
            break;
        // Remove all solid masks in the (twice!) extended region around the change
        C4Rect SolidMaskRect = p->pLandscapeRender->GetAffectedRect(p->Relights[i]);
        C4SolidMask * pSolid;
        for (pSolid = C4SolidMask::Last; pSolid; pSolid = pSolid->Prev)
            pSolid->RemoveTemporary(SolidMaskRect);
        // Perform the update
        p->pLandscapeRender->Update(p->Relights[i], this);
        if (p->pFoW) p->pFoW->Ambient.UpdateFromLandscape(*this, p->Relights[i]);
        // Restore Solidmasks
        for (pSolid = C4SolidMask::First; pSolid; pSolid = pSolid->Next)
            pSolid->PutTemporary(SolidMaskRect);
        C4SolidMask::CheckConsistency();
        // Clear slot
        p->Relights[i].Default();
    }
    return true;
}

References C4LS_MaxRelights, C4SolidMask::CheckConsistency(), C4SolidMask::First, C4SolidMask::Last, C4SolidMask::Next, C4SolidMask::Prev, C4SolidMask::PutTemporary(), and C4SolidMask::RemoveTemporary().

Referenced by Draw(), C4Game::Execute(), and Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Draw()

void C4Landscape::Draw	(	C4TargetFacet &	cgo,
		class C4FoWRegion *	pLight = nullptr
	)

Definition at line 369 of file C4Landscape.cpp.

{
    uint32_t clrMod = 0xffffffff;
    if (p->Modulation)
    {
        pDraw->ActivateBlitModulation(p->Modulation);
        clrMod = p->Modulation;
    }
    // blit landscape
    if (::GraphicsSystem.Show8BitSurface == 1)
        pDraw->Blit8Fast(p->Surface8.get(), cgo.TargetX, cgo.TargetY, cgo.Surface, cgo.X, cgo.Y, cgo.Wdt, cgo.Hgt);
    else if (::GraphicsSystem.Show8BitSurface == 2)
        pDraw->Blit8Fast(p->Surface8Bkg.get(), cgo.TargetX, cgo.TargetY, cgo.Surface, cgo.X, cgo.Y, cgo.Wdt, cgo.Hgt);
    else if (p->pLandscapeRender)
    {
        DoRelights();
        p->pLandscapeRender->Draw(cgo, pLight, clrMod);
    }
    if (p->Modulation) pDraw->DeactivateBlitModulation();
}

References C4Draw::ActivateBlitModulation(), C4Draw::Blit8Fast(), C4Draw::DeactivateBlitModulation(), DoRelights(), GraphicsSystem, C4Facet::Hgt, pDraw, C4GraphicsSystem::Show8BitSurface, C4Facet::Surface, C4TargetFacet::TargetX, C4TargetFacet::TargetY, C4Facet::Wdt, C4Facet::X, and C4Facet::Y.

Referenced by C4Viewport::Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

DrawBox()

bool C4Landscape::DrawBox	(	int32_t	iX1,
		int32_t	iY1,
		int32_t	iX2,
		int32_t	iY2,
		int32_t	iGrade,
		const char *	szMaterial,
		const char *	szTexture,
		const char *	szBackMaterial,
		const char *	szBackTexture
	)

Definition at line 3545 of file C4Landscape.cpp.

{
    // get upper-left/lower-right - corners
    int32_t iX0 = std::min(iX1, iX2); int32_t iY0 = std::min(iY1, iY2);
    iX2 = std::max(iX1, iX2); iY2 = std::max(iY1, iY2); iX1 = iX0; iY1 = iY0;
    BYTE byCol, byColBkg;
    // Get map color index by material-texture
    if (!p->GetMapColorIndex(szMaterial, szTexture, byCol)) return false;
    if (!p->GetMapColorIndex(szBackMaterial, szBackTexture, byColBkg)) return false;
    // Get material shape size
    C4Texture *texture = ::TextureMap.GetTexture(szTexture);
    int32_t shape_wdt = 0, shape_hgt = 0;
    if (texture && texture->GetMaterialShape())
    {
        shape_wdt = texture->GetMaterialShape()->GetMaxPolyWidth() / p->MapZoom;
        shape_hgt = texture->GetMaterialShape()->GetMaxPolyHeight() / p->MapZoom;
    }
    // Draw
    switch (p->mode)
    {
        // Dynamic: ignore
    case LandscapeMode::Dynamic:
        break;
        // Static: draw to map by material-texture-index, chunk-o-zoom to landscape
    case LandscapeMode::Static:
        // Draw to map
        iX1 /= p->MapZoom; iY1 /= p->MapZoom; iX2 /= p->MapZoom; iY2 /= p->MapZoom;
        p->Map->Box(iX1, iY1, iX2, iY2, byCol);
        p->MapBkg->Box(iX1, iY1, iX2, iY2, byColBkg);
        // Update landscape
        p->MapToLandscape(this, *p->Map, *p->MapBkg, iX1 - 1 - shape_wdt, iY1 - 1 - shape_hgt, iX2 - iX1 + 3 + shape_wdt * 2, iY2 - iY1 + 3 + shape_hgt * 2);
        SetMapChanged();
        break;
        // Exact: draw directly to landscape by color & pattern
    case LandscapeMode::Exact:
    {
        C4Rect BoundingBox(iX1, iY1, iX2 - iX1 + 1, iY2 - iY1 + 1);
        // Draw to landscape
        p->PrepareChange(this, BoundingBox);
        p->Surface8->Box(iX1, iY1, iX2, iY2, byCol);
        p->Surface8Bkg->Box(iX1, iY1, iX2, iY2, byColBkg);
        p->FinishChange(this, BoundingBox);
        break;
    }
    case LandscapeMode::Undefined: assert(false); break;
    }
    return true;
}

References Dynamic, Exact, C4Texture::GetMaterialShape(), C4TextureShape::GetMaxPolyHeight(), C4TextureShape::GetMaxPolyWidth(), C4TextureMap::GetTexture(), SetMapChanged(), Static, TextureMap, and Undefined.

Here is the call graph for this function:

DrawBrush()

bool C4Landscape::DrawBrush	(	int32_t	iX,
		int32_t	iY,
		int32_t	iGrade,
		const char *	szMaterial,
		const char *	szTexture,
		const char *	szBackMaterial,
		const char *	szBackTexture
	)

Definition at line 3415 of file C4Landscape.cpp.

{
    BYTE byCol, byColBkg;
    // Get map color index by material-texture
    if (!p->GetMapColorIndex(szMaterial, szTexture, byCol)) return false;
    if (!p->GetMapColorIndex(szBackMaterial, szBackTexture, byColBkg)) return false;
    // Get material shape size
    C4Texture *texture = ::TextureMap.GetTexture(szTexture);
    int32_t shape_wdt = 0, shape_hgt = 0;
    if (texture && texture->GetMaterialShape())
    {
        shape_wdt = texture->GetMaterialShape()->GetMaxPolyWidth() / p->MapZoom;
        shape_hgt = texture->GetMaterialShape()->GetMaxPolyHeight() / p->MapZoom;
    }
    // Draw
    switch (p->mode)
    {
        // Dynamic: ignore
    case LandscapeMode::Dynamic:
        break;
        // Static: draw to map by material-texture-index, chunk-o-zoom to landscape
    case LandscapeMode::Static:
        {
            // Draw to map
            int32_t iRadius = std::max<int32_t>(2 * iGrade / p->MapZoom, 1);
            if (iRadius == 1)
            {
                p->Map->SetPix(iX / p->MapZoom, iY / p->MapZoom, byCol);
                p->MapBkg->SetPix(iX / p->MapZoom, iY / p->MapZoom, byColBkg);
            }
            else
            {
                p->Map->Circle(iX / p->MapZoom, iY / p->MapZoom, iRadius, byCol);
                p->MapBkg->Circle(iX / p->MapZoom, iY / p->MapZoom, iRadius, byColBkg);
            }
            // Update landscape
            p->MapToLandscape(this, *p->Map, *p->MapBkg, iX / p->MapZoom - iRadius - 1 - shape_wdt, iY / p->MapZoom - iRadius - 1 - shape_hgt, 2 * iRadius + 2 + shape_wdt * 2, 2 * iRadius + 2 + shape_hgt * 2);
            SetMapChanged();
        }
        break;
        // Exact: draw directly to landscape by color & pattern
    case LandscapeMode::Exact:
    {
        C4Rect BoundingBox(iX - iGrade - 1, iY - iGrade - 1, iGrade * 2 + 2, iGrade * 2 + 2);
        // Draw to landscape
        p->PrepareChange(this, BoundingBox);
        p->Surface8->Circle(iX, iY, iGrade, byCol);
        p->Surface8Bkg->Circle(iX, iY, iGrade, byColBkg);
        p->FinishChange(this, BoundingBox);
        break;
    }
    case LandscapeMode::Undefined: assert(false); break;
    }
    return true;
}

References Dynamic, Exact, C4Texture::GetMaterialShape(), C4TextureShape::GetMaxPolyHeight(), C4TextureShape::GetMaxPolyWidth(), C4TextureMap::GetTexture(), SetMapChanged(), Static, TextureMap, and Undefined.

Here is the call graph for this function:

DrawChunks()

bool C4Landscape::DrawChunks	(	int32_t	tx,
		int32_t	ty,
		int32_t	wdt,
		int32_t	hgt,
		int32_t	icntx,
		int32_t	icnty,
		const char *	szMaterial,
		const char *	szTexture,
		bool	bIFT
	)

Definition at line 3594 of file C4Landscape.cpp.

{
    BYTE byColor;
    if (!p->GetMapColorIndex(szMaterial, szTexture, byColor)) return false;
 
    int32_t iMaterial = ::MaterialMap.Get(szMaterial);
    if (!MatValid(iMaterial))
        return false;
 
    C4MaterialCoreShape shape = ::Game.C4S.Landscape.FlatChunkShapes ? C4M_Flat : ::MaterialMap.Map[iMaterial].MapChunkType;
 
    C4Rect BoundingBox(tx - 5, ty - 5, wdt + 10, hgt + 10);
    p->PrepareChange(this, BoundingBox);
 
    // assign clipper
    p->Surface8->Clip(BoundingBox.x, BoundingBox.y, BoundingBox.x + BoundingBox.Wdt, BoundingBox.y + BoundingBox.Hgt);
    p->Surface8Bkg->Clip(BoundingBox.x, BoundingBox.y, BoundingBox.x + BoundingBox.Wdt, BoundingBox.y + BoundingBox.Hgt);
    pDraw->NoPrimaryClipper();
 
    // draw all chunks
    int32_t x, y;
    for (x = 0; x < icntx; x++)
        for (y = 0; y < icnty; y++)
            p->DrawChunk(this, tx + wdt*x / icntx, ty + hgt*y / icnty, wdt / icntx, hgt / icnty, byColor, bIFT ? p->DefaultBkgMat(byColor) : 0, shape, Random(1000));
 
    // remove clipper
    p->Surface8->NoClip();
    p->Surface8Bkg->NoClip();
 
    p->FinishChange(this, BoundingBox);
 
    // success
    return true;
}

References C4M_Flat, C4Game::C4S, C4SLandscape::FlatChunkShapes, Game, C4MaterialMap::Get(), C4Rect::Hgt, C4Scenario::Landscape, C4MaterialMap::Map, C4MaterialCore::MapChunkType, MaterialMap, MatValid(), C4Draw::NoPrimaryClipper(), pDraw, Random(), C4Rect::Wdt, CPolyEdge::x, C4Rect::x, CPolyEdge::y, and C4Rect::y.

Here is the call graph for this function:

DrawDefMap()

bool C4Landscape::DrawDefMap	(	int32_t	iX,
		int32_t	iY,
		int32_t	iWdt,
		int32_t	iHgt,
		const char *	szMapDef,
		bool	ignoreSky = false
	)

Definition at line 3989 of file C4Landscape.cpp.

{
    // safety
    if (!szMapDef || !p->pMapCreator) return false;
    // clip to landscape size
    if (!ClipRect(iX, iY, iWdt, iHgt)) return false;
    // get needed map size
    int32_t iMapWdt = (iWdt - 1) / p->MapZoom + 1;
    int32_t iMapHgt = (iHgt - 1) / p->MapZoom + 1;
    bool fSuccess = false;
    // render map
    C4MCMap *pMap = p->pMapCreator->GetMap(szMapDef);
    if (!pMap) return false;
    pMap->SetSize(iMapWdt, iMapHgt);
    CSurface8* sfcMap = nullptr;
    CSurface8* sfcMapBkg = nullptr;
    if (p->pMapCreator->Render(szMapDef, sfcMap, sfcMapBkg))
    {
        // map to landscape
        fSuccess = p->MapToLandscape(this, *sfcMap, *sfcMapBkg, 0, 0, iMapWdt, iMapHgt, iX, iY, ignoreSky);
        // cleanup
        delete sfcMap;
        delete sfcMapBkg;
    }
    // done
    return fSuccess;
}

References ClipRect(), and C4MCMap::SetSize().

Here is the call graph for this function:

DrawLine()

bool C4Landscape::DrawLine	(	int32_t	iX1,
		int32_t	iY1,
		int32_t	iX2,
		int32_t	iY2,
		int32_t	iGrade,
		const char *	szMaterial,
		const char *	szTexture,
		const char *	szBackMaterial,
		const char *	szBackTexture
	)

Definition at line 3492 of file C4Landscape.cpp.

{
    // Get map color index by material-texture
    uint8_t line_color, line_color_bkg;
    if (!p->GetMapColorIndex(szMaterial, szTexture, line_color)) return false;
    if (!p->GetMapColorIndex(szBackMaterial, szBackTexture, line_color_bkg)) return false;
    // Get material shape size
    C4Texture *texture = ::TextureMap.GetTexture(szTexture);
    int32_t shape_wdt = 0, shape_hgt = 0;
    if (texture && texture->GetMaterialShape())
    {
        shape_wdt = texture->GetMaterialShape()->GetMaxPolyWidth() / p->MapZoom;
        shape_hgt = texture->GetMaterialShape()->GetMaxPolyHeight() / p->MapZoom;
    }
    // Draw
    switch (p->mode)
    {
        // Dynamic: ignore
    case LandscapeMode::Dynamic:
        break;
        // Static: draw to map by material-texture-index, chunk-o-zoom to landscape
    case LandscapeMode::Static:
        {
            // Draw to map
            int32_t iRadius = std::max<int32_t>(2 * iGrade / p->MapZoom, 1);
            iX1 /= p->MapZoom; iY1 /= p->MapZoom; iX2 /= p->MapZoom; iY2 /= p->MapZoom;
            ForLine(iX1, iY1, iX2, iY2, [this, line_color, line_color_bkg, iRadius](int32_t x, int32_t y) { return p->DrawLineMap(x, y, iRadius, line_color, line_color_bkg); });
            // Update landscape
            int iUpX = std::min(iX1, iX2) - iRadius - 1;
            int iUpY = std::min(iY1, iY2) - iRadius - 1;
            int iUpWdt = Abs(iX2 - iX1) + 2 * iRadius + 2;
            int iUpHgt = Abs(iY2 - iY1) + 2 * iRadius + 2;
            p->MapToLandscape(this, *p->Map, *p->MapBkg, iUpX - shape_wdt, iUpY - shape_hgt, iUpWdt + shape_wdt * 2, iUpHgt + shape_hgt * 2);
            SetMapChanged();
        }
        break;
        // Exact: draw directly to landscape by color & pattern
    case LandscapeMode::Exact:
    {
        // Set texture pattern & get material color
        C4Rect BoundingBox(iX1 - iGrade, iY1 - iGrade, iGrade * 2 + 1, iGrade * 2 + 1);
        BoundingBox.Add(C4Rect(iX2 - iGrade, iY2 - iGrade, iGrade * 2 + 1, iGrade * 2 + 1));
        // Draw to landscape
        p->PrepareChange(this, BoundingBox);
        ForLine(iX1, iY1, iX2, iY2, [this, line_color, line_color_bkg, iGrade](int32_t x, int32_t y) { return p->DrawLineLandscape(x, y, iGrade, line_color, line_color_bkg); });
        p->FinishChange(this, BoundingBox);
        break;
    }
    case LandscapeMode::Undefined: assert(false); break;
    }
    return true;
}

References Abs(), C4Rect::Add(), Dynamic, Exact, C4Texture::GetMaterialShape(), C4TextureShape::GetMaxPolyHeight(), C4TextureShape::GetMaxPolyWidth(), C4TextureMap::GetTexture(), SetMapChanged(), Static, TextureMap, Undefined, CPolyEdge::x, and CPolyEdge::y.

Here is the call graph for this function:

DrawMap()

bool C4Landscape::DrawMap	(	int32_t	iX,
		int32_t	iY,
		int32_t	iWdt,
		int32_t	iHgt,
		const char *	szMapDef,
		bool	ignoreSky = false
	)

Definition at line 3959 of file C4Landscape.cpp.

{
    // safety
    if (!szMapDef) return false;
    // clip to landscape size
    if (!ClipRect(iX, iY, iWdt, iHgt)) return false;
    // get needed map size
    int32_t iMapWdt = (iWdt - 1) / p->MapZoom + 1;
    int32_t iMapHgt = (iHgt - 1) / p->MapZoom + 1;
    C4SLandscape FakeLS = Game.C4S.Landscape;
    FakeLS.MapWdt.Set(iMapWdt, 0, iMapWdt, iMapWdt);
    FakeLS.MapHgt.Set(iMapHgt, 0, iMapHgt, iMapHgt);
    // create map creator
    C4MapCreatorS2 MapCreator(&FakeLS, &::TextureMap, &::MaterialMap, Game.StartupPlayerCount);
    // read file
    MapCreator.ReadScript(szMapDef);
    // render map
    CSurface8* sfcMap = nullptr;
    CSurface8* sfcMapBkg = nullptr;
    if (!MapCreator.Render(nullptr, sfcMap, sfcMapBkg))
        return false;
    // map it to the landscape
    bool fSuccess = p->MapToLandscape(this, *sfcMap, *sfcMapBkg, 0, 0, iMapWdt, iMapHgt, iX, iY, ignoreSky);
    // cleanup
    delete sfcMap;
    delete sfcMapBkg;
    // return whether successful
    return fSuccess;
}

References C4Game::C4S, ClipRect(), Game, C4Scenario::Landscape, C4SLandscape::MapHgt, C4SLandscape::MapWdt, MaterialMap, C4MapCreatorS2::ReadScript(), C4MapCreatorS2::Render(), C4SVal::Set(), C4Game::StartupPlayerCount, and TextureMap.

Here is the call graph for this function:

DrawMaterialRect()

void C4Landscape::DrawMaterialRect	(	int32_t	mat,
		int32_t	tx,
		int32_t	ty,
		int32_t	wdt,
		int32_t	hgt
	)

Definition at line 931 of file C4Landscape.cpp.

{
    int32_t cx, cy;
    for (cy = ty; cy < ty + hgt; cy++)
        for (cx = tx; cx < tx + wdt; cx++)
            if ((MatDensity(mat) >= GetDensity(cx, cy)))
                SetPix2(cx, cy, Mat2PixColDefault(mat), p->Surface8Bkg->GetPix(cx, cy));
}

References GetDensity(), Mat2PixColDefault(), MatDensity(), and SetPix2().

Here is the call graph for this function:

DrawPolygon()

bool C4Landscape::DrawPolygon	(	int *	vtcs,
		int	length,
		const char *	szMaterial,
		const char *	szBackMaterial,
		bool	fDrawBridge
	)

Definition at line 3629 of file C4Landscape.cpp.

{
    if (length < 6) return false;
    if (length % 2 == 1) return false;
    // get texture
    int32_t iMatTex = ::TextureMap.GetIndexMatTex(szMaterial);
    if (!iMatTex) return false;
    uint8_t mcol = MatTex2PixCol(iMatTex);
    // get background texture
    uint8_t mcolBkg = 0;
    if (szBackMaterial != nullptr)
    {
        const int32_t iBackMatTex = ::TextureMap.GetIndexMatTex(szBackMaterial);
        if (!iBackMatTex) return false;
        mcolBkg = MatTex2PixCol(iBackMatTex);
    }
    // do bridging?
    uint8_t *conversion_map = nullptr;
    if (fDrawBridge)
    {
        conversion_map = p->GetBridgeMatConversion(this, MatTex2PixCol(iMatTex));
        mcolBkg = Transparent;
    }
    // prepare pixel count update
    C4Rect BoundingBox = getBoundingBox(vtcs, length);
    // draw polygon
    p->PrepareChange(this, BoundingBox);
    p->ForPolygon(this, vtcs, length / 2, nullptr, nullptr, mcol, mcolBkg, conversion_map);
    p->FinishChange(this, BoundingBox);
    return true;
}

References C4TextureMap::GetIndexMatTex(), MatTex2PixCol(), TextureMap, and Transparent.

Referenced by DrawQuad().

Here is the call graph for this function:

Here is the caller graph for this function:

DrawQuad()

bool C4Landscape::DrawQuad	(	int32_t	iX1,
		int32_t	iY1,
		int32_t	iX2,
		int32_t	iY2,
		int32_t	iX3,
		int32_t	iY3,
		int32_t	iX4,
		int32_t	iY4,
		const char *	szMaterial,
		const char *	szBackMaterial,
		bool	fDrawBridge
	)

Definition at line 3891 of file C4Landscape.cpp.

{
    // set vertices
    int32_t vtcs[8];
    vtcs[0] = iX1; vtcs[1] = iY1;
    vtcs[2] = iX2; vtcs[3] = iY2;
    vtcs[4] = iX3; vtcs[5] = iY3;
    vtcs[6] = iX4; vtcs[7] = iY4;
    return DrawPolygon(vtcs, 8, szMaterial, szBackMaterial, fDrawBridge);
}

References DrawPolygon().

Here is the call graph for this function:

Execute()

void C4Landscape::Execute

(

)

Definition at line 204 of file C4Landscape.cpp.

{
    // Landscape scan
    if (!p->NoScan)
        p->ExecuteScan(this);
    // move sky
    p->Sky.Execute();
 
    // Queued Relights -- note that normally we process them before drawing every frame;
    // this just makes sure relights don't accumulate over a long period of time if no
    // viewport is open (developer mode).
    if (!::Game.iTick35)
        DoRelights();
}

References DoRelights(), Game, and C4Game::iTick35.

Referenced by C4Game::Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

ExtractMaterial()

int32_t C4Landscape::ExtractMaterial	(	int32_t	fx,
		int32_t	fy,
		bool	distant_first
	)

Definition at line 957 of file C4Landscape.cpp.

{
    int32_t mat = GetMat(fx, fy);
    if (mat == MNone) return MNone;
    FindMatTop(mat, fx, fy, distant_first);
    ClearPix(fx, fy);
    CheckInstabilityRange(fx, fy);
    return mat;
}

References CheckInstabilityRange(), ClearPix(), FindMatTop(), GetMat(), and MNone.

Referenced by C4MassMover::Execute(), and C4MaterialMap::mrfPoof().

Here is the call graph for this function:

Here is the caller graph for this function:

FastSolidCheckNextX()

int32_t C4Landscape::FastSolidCheckNextX ( int32_t  x )

static

Definition at line 3828 of file C4Landscape.cpp.

{
    return (x / 17) * 17 + 17;
}

References CPolyEdge::x.

Referenced by C4FoWLightSection::Update().

Here is the caller graph for this function:

FindMatPath()

bool C4Landscape::FindMatPath	(	int32_t &	fx,
		int32_t &	fy,
		int32_t	ydir,
		int32_t	mdens,
		int32_t	mslide
	)		const

Definition at line 3109 of file C4Landscape.cpp.

{
    assert(mdens <= C4M_Solid); // mdens normalized in InsertMaterial
 
    int32_t cslide;
    bool fLeft = true, fRight = true;
 
    // One downwards
    if (GetDensity(fx, fy + ydir) < mdens) { fy += ydir; return true; }
 
    // Find downwards slide path
    for (cslide = 1; (cslide <= mslide) && (fLeft || fRight); cslide++)
    {
        // Check left
        if (fLeft)
        {
            if (GetDensity(fx - cslide, fy) >= mdens) // Left clogged
                fLeft = false;
            else if (GetDensity(fx - cslide, fy + ydir) < mdens) // Left slide okay
            {
                fx--; return true;
            }
        }
        // Check right
        if (fRight)
        {
            if (GetDensity(fx + cslide, fy) >= mdens) // Right clogged
                fRight = false;
            else if (GetDensity(fx + cslide, fy + ydir) < mdens) // Right slide okay
            {
                fx++; return true;
            }
        }
    }
 
    return false;
}

References C4M_Solid, and GetDensity().

Referenced by C4MassMover::Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

FindMatPathPush()

bool C4Landscape::FindMatPathPush	(	int32_t &	fx,
		int32_t &	fy,
		int32_t	mdens,
		int32_t	mslide,
		bool	liquid
	)		const

Definition at line 3188 of file C4Landscape.cpp.

{
    // Startpoint must be inside landscape
    fx = Clamp<int32_t>(fx, 0, GetWidth() - 1);
    fy = Clamp<int32_t>(fy, 0, GetHeight() - 1);
    // Range to search, calculate bounds
    const int32_t iPushRange = 500;
    int32_t left = std::max<int32_t>(0, fx - iPushRange), right = std::min<int32_t>(GetWidth() - 1, fx + iPushRange),
        top = std::max<int32_t>(0, fy - iPushRange), bottom = std::min<int32_t>(GetHeight() - 1, fy + iPushRange);
    // Direction constants
    const int8_t R = 0, D = 1, L = 2, U = 3;
    int8_t dir = 0;
    int32_t x = fx, y = fy;
    // Get startpoint density
    int32_t dens = GetDensity(fx, fy);
    // Smaller density? We're done.
    if (dens < mdens)
        return true;
    // Right density?
    else if (dens == mdens)
    {
        // Find start point for border search
        for (int32_t i = 0; ; i++)
            if (x - i - 1 < left || GetDensity(x - i - 1, y) != mdens)
            {
                x -= i; dir = L; break;
            }
            else if (y - i - 1 < top || GetDensity(x, y - i - 1) != mdens)
            {
                y -= i; dir = U; break;
            }
            else if (x + i + 1 > right || GetDensity(x + i + 1, y) != mdens)
            {
                x += i; dir = R; break;
            }
            else if (y + i + 1 > bottom || GetDensity(x, y + i + 1) != mdens)
            {
                y += i; dir = D; break;
            }
    }
    // Greater density
    else
    {
        // Try to find a way out
        int i = 1;
        for (; i < iPushRange; i++)
        {
            if (GetDensity(x - i, y) <= mdens)
            {
                x -= i; dir = R; break;
            }
            else if (GetDensity(x, y - i) <= mdens)
            {
                y -= i; dir = D; break;
            }
            else if (GetDensity(x + i, y) <= mdens)
            {
                x += i; dir = L; break;
            }
            else if (GetDensity(x, y + i) <= mdens)
            {
                y += i; dir = U; break;
            }
        }
        // Not found?
        if (i >= iPushRange) return false;
        // Done?
        if (GetDensity(x, y) < mdens)
        {
            fx = x; fy = y;
            return true;
        }
    }
    // Save startpoint of search
    int32_t sx = x, sy = y, sdir = dir;
    // Best point so far
    bool fGotBest = false; int32_t bx = 0, by = 0, bdist = 0;
    // Start searching
    do
    {
        // We should always be in a material of same density
        assert(x >= left && y >= top && x <= right && y <= bottom && GetDensity(x, y) == mdens);
        // Calc new position
        int nx = x, ny = y;
        switch (dir)
        {
        case R: nx++; break;
        case D: ny++; break;
        case L: nx--; break;
        case U: ny--; break;
        default: assert(false);
        }
        // In bounds?
        bool fInBounds = (nx >= left && ny >= top && nx <= right && ny <= bottom);
        // Get density. Not this performs an SideOpen-check if outside landscape bounds.
        int32_t dens = GetDensity(nx, ny);
        // Flow possible?
        if (dens < mdens)
        {
            // Calculate "distance".
            int32_t dist = Abs(nx - fx) + mslide * (liquid ? fy - ny : Abs(fy - ny));
            // New best point?
            if (!fGotBest || dist < bdist)
            {
                // Save it
                bx = nx; by = ny; bdist = dist; fGotBest = true;
                // Adjust borders: We can obviously safely ignore anything at greater distance
                top = std::max<int32_t>(top, fy - dist / mslide - 1);
                if (!liquid)
                {
                    bottom = std::min<int32_t>(bottom, fy + dist / mslide + 1);
                    left = std::max<int32_t>(left, fx - dist - 1);
                    right = std::min<int32_t>(right, fx + dist + 1);
                }
                // Set new startpoint
                sx = x; sy = y; sdir = dir;
            }
        }
        // Step?
        if (fInBounds && dens == mdens)
        {
            // New point
            x = nx; y = ny;
            // Turn left
            (dir += 3) %= 4;
        }
        // Otherwise: Turn right
        else
        {
            ++dir;
            dir %= 4;
        }
    } while (x != sx || y != sy || dir != sdir);
    // Nothing found?
    if (!fGotBest) return false;
    // Return it
    fx = bx; fy = by;
    return true;
}

References Abs(), C4ScriptGuiWindowPropertyName::bottom, GetDensity(), GetHeight(), GetWidth(), C4ScriptGuiWindowPropertyName::left, C4ScriptGuiWindowPropertyName::right, C4ScriptGuiWindowPropertyName::top, CPolyEdge::x, and CPolyEdge::y.

Referenced by InsertMaterial().

Here is the call graph for this function:

Here is the caller graph for this function:

FindMatSlide()

bool C4Landscape::FindMatSlide	(	int32_t &	fx,
		int32_t &	fy,
		int32_t	ydir,
		int32_t	mdens,
		int32_t	mslide
	)		const

Definition at line 3148 of file C4Landscape.cpp.

{
    assert(mdens <= C4M_Solid); // mdens normalized in InsertMaterial and mrfInsertCheck
    int32_t cslide;
    bool fLeft = true, fRight = true;
 
    // One downwards
    if (GetDensity(fx, fy + ydir) < mdens) { fy += ydir; return true; }
 
    // Find downwards slide path
    for (cslide = 1; (cslide <= mslide) && (fLeft || fRight); cslide++)
    {
        // Check left
        if (fLeft)
        {
            if (GetDensity(fx - cslide, fy) >= mdens && GetDensity(fx - cslide, fy + ydir) >= mdens) // Left clogged
                fLeft = false;
            else if (GetDensity(fx - cslide, fy + ydir) < mdens) // Left slide okay
            {
                fx -= cslide; fy += ydir; return true;
            }
        }
        // Check right
        if (fRight)
        {
            if (GetDensity(fx + cslide, fy) >= mdens && GetDensity(fx + cslide, fy + ydir) >= mdens) // Right clogged
                fRight = false;
            else if (GetDensity(fx + cslide, fy + ydir) < mdens) // Right slide okay
            {
                fx += cslide; fy += ydir; return true;
            }
        }
    }
 
    return false;
}

References C4M_Solid, and GetDensity().

Referenced by InsertMaterial().

Here is the call graph for this function:

Here is the caller graph for this function:

FindMatTop()

void C4Landscape::FindMatTop	(	int32_t	mat,
		int32_t &	x,
		int32_t &	y,
		bool	distant_first
	)		const

Definition at line 3338 of file C4Landscape.cpp.

{
    int32_t mslide, cslide, tslide, distant_x = 0;
    bool fLeft, fRight;
 
    if (!MatValid(mat)) return;
    mslide = ::MaterialMap.Map[mat].MaxSlide;
 
    do
    {
        // Catch most common case: Walk upwards until material changes
        while (GetMat(x, y - 1) == mat) --y;
 
        // Find upwards slide
        fLeft = true; fRight = true; tslide = 0; distant_x = x;
        for (cslide = 1; (cslide <= mslide) && (fLeft || fRight); cslide++)
        {
            // Left
            if (fLeft)
            {
                if (GetMat(x - cslide, y) != mat) fLeft = false;
                else
                {
                    distant_x = x - cslide;
                    if (GetMat(distant_x, y - 1) == mat) { tslide = -cslide; break; }
                }
            }
            // Right
            if (fRight)
            {
                if (GetMat(x + cslide, y) != mat) fRight = false;
                else
                {
                    distant_x = x + cslide;
                    if (GetMat(distant_x, y - 1) == mat) { tslide = +cslide; break; }
                }
            }
        }
 
        // Slide
        if (tslide) { x += tslide; y--; }
 
    } while (tslide);
 
    // return top pixel max slide away from center if desired
    if (distant_first) x = distant_x;
 
}

References GetMat(), C4MaterialMap::Map, MaterialMap, MatValid(), C4MaterialCore::MaxSlide, CPolyEdge::x, and CPolyEdge::y.

Referenced by ExtractMaterial().

Here is the call graph for this function:

Here is the caller graph for this function:

GetBackDensity()

int32_t C4Landscape::GetBackDensity	(	int32_t	x,
		int32_t	y
	)		const

Definition at line 3803 of file C4Landscape.cpp.

{
    return p->Pix2Dens[GetBackPix(x, y)];
}

References GetBackPix(), CPolyEdge::x, and CPolyEdge::y.

Here is the call graph for this function:

GetBackMapIndex()

BYTE C4Landscape::GetBackMapIndex	(	int32_t	iX,
		int32_t	iY
	)		const

Definition at line 3908 of file C4Landscape.cpp.

{
    if (!p->MapBkg) return 0;
    return p->MapBkg->GetPix(iX, iY);
}

Referenced by C4EditCursor::ApplyToolPicker().

Here is the caller graph for this function:

GetBackMat()

int32_t C4Landscape::GetBackMat	(	int32_t	x,
		int32_t	y
	)		const

Definition at line 3798 of file C4Landscape.cpp.

{
    return p->Pix2Mat[GetBackPix(x, y)];
}

References GetBackPix(), CPolyEdge::x, and CPolyEdge::y.

Referenced by C4EditCursor::UpdateStatusBar().

Here is the call graph for this function:

Here is the caller graph for this function:

GetBackPix()

BYTE C4Landscape::GetBackPix	(	int32_t	x,
		int32_t	y
	)		const

Definition at line 3760 of file C4Landscape.cpp.

{
    // Border checks
    if (x < 0)
    {
        return p->DefaultBkgMat(p->LeftColPix[Clamp(y, 0, GetHeight()-1)]);
    }
    if (static_cast<uint32_t>(x) >= static_cast<uint32_t>(GetWidth()))
    {
        return p->DefaultBkgMat(p->RightColPix[Clamp(y, 0, GetHeight()-1)]);
    }
    if (y < 0)
    {
        return p->DefaultBkgMat(p->TopRowPix[x]);
    }
    if (static_cast<uint32_t>(y) >= static_cast<uint32_t>(GetHeight()))
    {
        return p->DefaultBkgMat(p->BottomRowPix[x]);
    }
 
    return p->Surface8Bkg->_GetPix(x, y);
}

References Clamp(), GetHeight(), GetWidth(), CPolyEdge::x, and CPolyEdge::y.

Referenced by C4EditCursor::ApplyToolPicker(), FindTunnelHeight(), GetBackDensity(), GetBackMat(), GetBackPlacement(), GetLight(), C4Weather::GetWind(), and RaiseTerrain().

Here is the call graph for this function:

Here is the caller graph for this function:

GetBackPlacement()

int32_t C4Landscape::GetBackPlacement	(	int32_t	x,
		int32_t	y
	)		const

Definition at line 3808 of file C4Landscape.cpp.

{
    return p->Pix2Place[GetBackPix(x, y)];
}

References GetBackPix(), CPolyEdge::x, and CPolyEdge::y.

Here is the call graph for this function:

GetDensity()

int32_t C4Landscape::GetDensity	(	int32_t	x,
		int32_t	y
	)		const

Definition at line 3742 of file C4Landscape.cpp.

{
    return p->Pix2Dens[GetPix(x, y)];
}

References GetPix(), CPolyEdge::x, and CPolyEdge::y.

Referenced by DrawMaterialRect(), FindMatPath(), FindMatPathPush(), FindMatSlide(), GBackDensity(), InsertMaterial(), InsertMaterialOutsideLandscape(), and mrfInsertCheck().

Here is the call graph for this function:

Here is the caller graph for this function:

GetEffectiveMatCount()

int32_t C4Landscape::GetEffectiveMatCount

(

int

material

)

const

Definition at line 4208 of file C4Landscape.cpp.

{
    assert(material >= 0 && (unsigned) material < p->EffectiveMatCount.size());
    return p->EffectiveMatCount[material];
}

GetFoW()

C4FoW * C4Landscape::GetFoW

(

)

Definition at line 4197 of file C4Landscape.cpp.

{
    return p->pFoW.get();
}

Referenced by C4Viewport::EnableFoW(), C4Object::StatusDeactivate(), and C4Object::UpdateLight().

Here is the caller graph for this function:

GetGravity()

C4Real C4Landscape::GetGravity

(

)

const

Definition at line 3681 of file C4Landscape.cpp.

{
    return p->Gravity;
}

GetHeight()

int32_t C4Landscape::GetHeight

(

)

const

Definition at line 3671 of file C4Landscape.cpp.

{
    return p->Height;
}

Referenced by _SetPix2(), _SetPix2Tmp(), AboveSemiSolid(), AboveSolid(), AdjustMoveToTarget(), C4Viewport::AdjustPosition(), C4Viewport::CalculateZoom(), C4Viewport::CenterPosition(), C4SolidMask::CheckConsistency(), ClipRect(), C4FoWAmbient::CreateFromLandscape(), C4GraphicsSystem::DoSaveScreenshot(), C4Landscape::P::DoScan(), C4TextureShape::Draw(), C4Object::ExecMovement(), C4PXS::Execute(), FindLiquidHeight(), FindMatPathPush(), FindTunnelHeight(), GetBackPix(), GetMatHeight(), GetPix(), C4Sky::GetSkyFadeClr(), C4Player::Init(), C4MassMover::Init(), C4Game::InitInEarth(), C4Game::InitVegetation(), InsertDeadMaterial(), InsertMaterial(), LandscapeFree(), C4Game::PlaceAnimal(), C4Game::PlaceInEarth(), C4SolidMask::Put(), C4SolidMask::PutSolidMasks(), RaiseTerrain(), C4SolidMask::RemoveSolidMasks(), RemoveUnusedTexMapEntries(), SaveInitial(), C4Player::ScenarioInit(), C4Player::ScrollView(), SemiAboveSolid(), SetPix2(), C4Viewport::SetViewY(), SimFlight(), TrajectoryDistance(), C4FoWLightSection::Update(), C4MouseControl::UpdateFogOfWar(), C4FoWAmbient::UpdateFromLandscape(), and C4Object::VerticalBounds().

Here is the caller graph for this function:

GetLight()

bool C4Landscape::GetLight	(	int32_t	x,
		int32_t	y
	)

Definition at line 3813 of file C4Landscape.cpp.

{
    return GetBackPix(x, y) == 0 || p->Pix2Light[GetPix(x, y)];
}

References GetBackPix(), GetPix(), CPolyEdge::x, and CPolyEdge::y.

Here is the call graph for this function:

GetMapIndex()

BYTE C4Landscape::GetMapIndex	(	int32_t	iX,
		int32_t	iY
	)		const

Definition at line 3902 of file C4Landscape.cpp.

{
    if (!p->Map) return 0;
    return p->Map->GetPix(iX, iY);
}

Referenced by C4EditCursor::ApplyToolPicker().

Here is the caller graph for this function:

GetMapZoom()

int32_t C4Landscape::GetMapZoom

(

)

const

Definition at line 3676 of file C4Landscape.cpp.

{
    return p->MapZoom;
}

Referenced by C4EditCursor::ApplyToolPicker(), and C4Player::Execute().

Here is the caller graph for this function:

GetMat()

int32_t C4Landscape::GetMat	(	int32_t	x,
		int32_t	y
	)		const

Definition at line 3737 of file C4Landscape.cpp.

{
    return p->Pix2Mat[GetPix(x, y)];
}

References GetPix(), CPolyEdge::x, and CPolyEdge::y.

Referenced by C4Landscape::P::BlastFreePix(), CheckInstability(), C4Landscape::P::DigFreePix(), C4Landscape::P::DigFreePixNoInstability(), ExtractMaterial(), FindMatTop(), GBackMat(), Incinerate(), InsertDeadMaterial(), InsertMaterial(), C4Landscape::P::ShakeFreePix(), and C4EditCursor::UpdateStatusBar().

Here is the call graph for this function:

Here is the caller graph for this function:

GetMatCount()

int32_t C4Landscape::GetMatCount

(

int

material

)

const

Definition at line 4202 of file C4Landscape.cpp.

{
    assert(material >= 0 && (unsigned) material < p->MatCount.size());
    return p->MatCount[material];
}

Referenced by C4SolidMask::CheckConsistency().

Here is the caller graph for this function:

GetMatHeight()

int32_t C4Landscape::GetMatHeight	(	int32_t	x,
		int32_t	y,
		int32_t	iYDir,
		int32_t	iMat,
		int32_t	iMax
	)		const

Definition at line 2461 of file C4Landscape.cpp.

{
    if (iYDir > 0)
    {
        iMax = std::min<int32_t>(iMax, GetHeight() - y);
        for (int32_t i = 0; i < iMax; i++)
            if (_GetMat(x, y + i) != iMat)
                return i;
    }
    else
    {
        iMax = std::min<int32_t>(iMax, y + 1);
        for (int32_t i = 0; i < iMax; i++)
            if (_GetMat(x, y - i) != iMat)
                return i;
    }
    return iMax;
}

References _GetMat(), GetHeight(), CPolyEdge::x, and CPolyEdge::y.

Referenced by _SetPix2(), and C4Landscape::P::UpdateMatCnt().

Here is the call graph for this function:

Here is the caller graph for this function:

GetMode()

LandscapeMode C4Landscape::GetMode

(

)

const

Definition at line 3395 of file C4Landscape.cpp.

{
    return p->mode;
}

Referenced by C4EditCursor::ApplyToolBrush(), C4EditCursor::ApplyToolFill(), C4EditCursor::ApplyToolLine(), C4EditCursor::ApplyToolPicker(), C4EditCursor::ApplyToolRect(), C4ToolsDlg::AssertValidBackTexture(), C4ToolsDlg::AssertValidTexture(), C4Console::SaveScenario(), C4ToolsDlg::SetBackMaterial(), C4ToolsDlg::SetLandscapeMode(), and C4ToolsDlg::SetMaterial().

Here is the caller graph for this function:

GetModulation()

DWORD C4Landscape::GetModulation

(

)

const

Definition at line 4025 of file C4Landscape.cpp.

{ return p->Modulation; }

GetPal()

CStdPalette * C4Landscape::GetPal

(

)

const

Definition at line 3661 of file C4Landscape.cpp.

{
    return p->Surface8 ? p->Surface8->pPal : nullptr;
}

Referenced by C4PXSSystem::Draw().

Here is the caller graph for this function:

GetPix()

BYTE C4Landscape::GetPix	(	int32_t	x,
		int32_t	y
	)		const

Definition at line 3699 of file C4Landscape.cpp.

{
    extern BYTE MCVehic;
    // Border checks
    if (x < 0)
    {
        return p->LeftColPix[Clamp(y, 0, GetHeight()-1)];
    }
    if (static_cast<uint32_t>(x) >= static_cast<uint32_t>(p->Width))
    {
        return p->RightColPix[Clamp(y, 0, GetHeight()-1)];
    }
    if (y < 0)
    {
        return p->TopRowPix[x];
    }
    if (static_cast<uint32_t>(y) >= static_cast<uint32_t>(p->Height))
    {
        return p->BottomRowPix[x];
    }
    return p->Surface8->_GetPix(x, y);
}

References Clamp(), GetHeight(), MCVehic, CPolyEdge::x, and CPolyEdge::y.

Referenced by GetDensity(), GetLight(), GetMat(), GetPlacement(), PathFreeIgnoreVehiclePix(), C4SolidMask::Put(), C4SolidMask::PutTemporary(), RaiseTerrain(), C4SolidMask::RemoveTemporary(), and C4SolidMask::Repair().

Here is the call graph for this function:

Here is the caller graph for this function:

GetPixDensity()

int32_t C4Landscape::GetPixDensity

(

BYTE

byPix

)

const

Definition at line 3835 of file C4Landscape.cpp.

{ return p->Pix2Dens[byPix]; }

Referenced by C4Landscape::P::GetBridgeMatConversion().

Here is the caller graph for this function:

GetPixMat()

int32_t C4Landscape::GetPixMat

(

BYTE

byPix

)

const

Definition at line 3833 of file C4Landscape.cpp.

{ return p->Pix2Mat[byPix]; }

Referenced by C4Landscape::P::GetBridgeMatConversion(), and PathFreeIgnoreVehiclePix().

Here is the caller graph for this function:

GetPlacement()

int32_t C4Landscape::GetPlacement	(	int32_t	x,
		int32_t	y
	)		const

Definition at line 3747 of file C4Landscape.cpp.

{
    return p->Pix2Place[GetPix(x, y)];
}

References GetPix(), CPolyEdge::x, and CPolyEdge::y.

Here is the call graph for this function:

GetSky()

C4Sky & C4Landscape::GetSky

(

)

Definition at line 4187 of file C4Landscape.cpp.

{
    return p->Sky;
}

Referenced by C4Game::CompileFunc(), C4GraphicsSystem::DoSaveScreenshot(), and C4Viewport::Draw().

Here is the caller graph for this function:

GetWidth()

int32_t C4Landscape::GetWidth

(

)

const

Definition at line 3666 of file C4Landscape.cpp.

{
    return p->Width;
}

Referenced by _SetPix2(), _SetPix2Tmp(), C4Viewport::AdjustPosition(), C4Viewport::CalculateZoom(), C4Viewport::CenterPosition(), C4SolidMask::CheckConsistency(), ClipRect(), C4Shape::ContactCheck(), C4FoWAmbient::CreateFromLandscape(), C4GraphicsSystem::DoSaveScreenshot(), C4Landscape::P::DoScan(), C4TextureShape::Draw(), C4Object::ExecMovement(), C4PXS::Execute(), FindConSiteSpot(), FindLevelGround(), FindLiquid(), FindMatPathPush(), FindSolidGround(), FindSurfaceLiquid(), FindTunnel(), GetBackPix(), C4Player::Init(), C4MassMover::Init(), C4Game::InitInEarth(), C4Game::InitVegetation(), C4Viewport::InitZoom(), InsertDeadMaterial(), InsertMaterial(), LandscapeFree(), C4Game::PlaceAnimal(), C4Game::PlaceInEarth(), C4SolidMask::Put(), C4SolidMask::PutSolidMasks(), C4SolidMask::RemoveSolidMasks(), RemoveUnusedTexMapEntries(), SaveInitial(), C4Player::ScenarioInit(), C4Player::ScrollView(), SetPix2(), C4Viewport::SetViewX(), C4Object::SideBounds(), SimFlight(), TrajectoryDistance(), C4FoWLightSection::Update(), C4MouseControl::UpdateFogOfWar(), and C4FoWAmbient::UpdateFromLandscape().

Here is the caller graph for this function:

HandleTexMapUpdate()

void C4Landscape::HandleTexMapUpdate

(

)

Definition at line 4218 of file C4Landscape.cpp.

{
    // Pixel maps must be update
    UpdatePixMaps();
    // Update landscape palette
    p->Mat2Pal();
}

References UpdatePixMaps().

Referenced by C4TextureMap::AddEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

HasFoW()

bool C4Landscape::HasFoW

(

)

const

Definition at line 4192 of file C4Landscape.cpp.

{
    return p->pFoW != nullptr;
}

Referenced by C4Viewport::EnableFoW(), C4Object::StatusDeactivate(), and C4Object::UpdateLight().

Here is the caller graph for this function:

HasMap()

bool C4Landscape::HasMap

(

)

const

Definition at line 1688 of file C4Landscape.cpp.

{
    return p->Map != nullptr && p->MapBkg != nullptr;
}

Incinerate()

bool C4Landscape::Incinerate	(	int32_t	x,
		int32_t	y,
		int32_t	cause_player
	)

Definition at line 1084 of file C4Landscape.cpp.

{
    int32_t mat = GetMat(x, y);
    if (MatValid(mat))
        if (::MaterialMap.Map[mat].Inflammable)
        {
            C4AulParSet pars(C4VInt(x), C4VInt(y), C4VInt(cause_player));
            ::ScriptEngine.GetPropList()->Call(P_InflameLandscape, &pars);
        }
    return false;
}

References C4VInt(), C4PropList::Call(), GetMat(), C4AulScriptEngine::GetPropList(), C4MaterialCore::Inflammable, C4MaterialMap::Map, MaterialMap, MatValid(), P_InflameLandscape, and ScriptEngine.

Referenced by C4MaterialMap::mrfIncinerate().

Here is the call graph for this function:

Here is the caller graph for this function:

Init()

bool C4Landscape::Init	(	C4Group &	hGroup,
		bool	fOverloadCurrent,
		bool	fLoadSky,
		bool &	rfLoaded,
		bool	fSavegame
	)

Definition at line 1426 of file C4Landscape.cpp.

{
    // set map seed, if not pre-assigned
    if (!p->MapSeed) p->MapSeed = Random(3133700);
 
    // increase max map size, since developers might set a greater one here
    Game.C4S.Landscape.MapWdt.Max = 10000;
    Game.C4S.Landscape.MapHgt.Max = 10000;
 
    // map and landscape must be initialized with fixed random, so runtime joining clients may recreate it
    // with same seed
    // after map/landscape creation, the seed must be fixed again, so there's no difference between clients creating
    // and not creating the map
    // this, however, would cause syncloss to DebugRecs
    C4DebugRecOff DBGRECOFF(!!Game.C4S.Landscape.ExactLandscape);
 
    Game.FixRandom(Game.RandomSeed);
 
    // map is like it's loaded for regular gamestart
    // but it's changed and would have to be saved if a new section is loaded
    p->fMapChanged = fOverloadCurrent;
 
    // don't change landscape mode in runtime joins
    bool fLandscapeModeSet = (p->mode != LandscapeMode::Undefined);
 
    // Make pixel maps
    // Pixel maps only depend on loaded materials and textures
    // They might be accessed in map scripts, so they should be ready before map creation
    UpdatePixMaps();
 
    Game.SetInitProgress(60);
    // create map if necessary
    if (!Game.C4S.Landscape.ExactLandscape)
    {
        std::unique_ptr<CSurface8> sfcMap, sfcMapBkg;
 
        // Static map from scenario: Old-style Map.bmp with highest bit IFT
        if ((sfcMap = GroupReadSurface8(hGroup, C4CFN_Map)))
        {
            if (!fLandscapeModeSet) p->mode = LandscapeMode::Static;
            sfcMapBkg = p->CreateDefaultBkgSurface(*sfcMap, true);
            if (!sfcMapBkg) return false;
        }
 
        // Static map from scenario: New-style MapFg.bmp and MapBg.bmp with
        // full 255 mat-tex combinations. Background map is optional, if not
        // given default will be created with tunnel background for all
        // semisolid pixels.
        if (!sfcMap)
        {
            if ((sfcMap = GroupReadSurface8(hGroup, C4CFN_MapFg)))
            {
                if (!fLandscapeModeSet) p->mode = LandscapeMode::Static;
                sfcMapBkg = GroupReadSurface8(hGroup, C4CFN_MapBg);
                if (!sfcMapBkg) sfcMapBkg = p->CreateDefaultBkgSurface(*sfcMap, false);
                if (!sfcMapBkg) return false;
            }
        }
 
        // dynamic map from Landscape.txt
        CSurface8 *rendered_map = nullptr, *rendered_bkg = nullptr;
        if (!sfcMap)
        {
            if (p->CreateMapS2(hGroup, rendered_map, rendered_bkg))
            {
                sfcMap.reset(rendered_map);
                sfcMapBkg.reset(rendered_bkg);
                if (!fLandscapeModeSet) p->mode = LandscapeMode::Dynamic;
            }
        }
 
        // script may create or edit map
        if (MapScript.InitializeMap(&Game.C4S.Landscape, &::TextureMap, &::MaterialMap, Game.StartupPlayerCount, &sfcMap, &sfcMapBkg))
        {
            if (!fLandscapeModeSet) p->mode = LandscapeMode::Dynamic;
        }
 
        // Dynamic map by scenario
        if (!sfcMap && !fOverloadCurrent)
        {
            if (p->CreateMap(rendered_map, rendered_bkg))
            {
                sfcMap.reset(rendered_map);
                sfcMapBkg.reset(rendered_bkg);
                // Although this is a dynamic map, it's probably just the empty default map.
                // Set the mode to static so people can start drawing directly in the editor.
                if (!fLandscapeModeSet) p->mode = LandscapeMode::Static;
            }
        }
 
        // No map failure
        if (!sfcMap)
        {
            // no problem if only overloading
            if (!fOverloadCurrent) return false;
            if (fLoadSky) if (!p->Sky.Init(fSavegame)) return false;
            return true;
        }
 
        assert(sfcMapBkg != nullptr);
 
        if (Config.General.DebugRec)
        {
            AddDbgRec(RCT_Block, "|---MAP---|", 12);
            AddDbgRec(RCT_Map, sfcMap->Bits, sfcMap->Pitch*sfcMap->Hgt);
        }
 
        // Store map size and calculate map zoom
        int iWdt, iHgt;
        sfcMap->GetSurfaceSize(iWdt, iHgt);
        p->MapWidth = iWdt; p->MapHeight = iHgt;
        p->MapZoom = Game.C4S.Landscape.MapZoom.Evaluate();
 
        // Calculate landscape size
        p->Width = p->MapZoom * p->MapWidth;
        p->Height = p->MapZoom * p->MapHeight;
        p->Width = std::max<int32_t>(p->Width, 100);
        p->Height = std::max<int32_t>(p->Height, 100);
 
        // if overloading, clear current landscape (and sections, etc.)
        // must clear, of course, before new sky is eventually read
        if (fOverloadCurrent) Clear(!Game.C4S.Landscape.KeepMapCreator, fLoadSky, false);
 
        // assign new map
        assert(p->Map == nullptr);
        assert(p->MapBkg == nullptr);
        p->Map = std::move(sfcMap);
        p->MapBkg = std::move(sfcMapBkg);
 
        // Sky (might need to know landscape height)
        if (fLoadSky)
        {
            Game.SetInitProgress(70);
            if (!p->Sky.Init(fSavegame)) return false;
        }
    }
 
    // Exact landscape from scenario (no map or exact recreation)
    else /* if (Game.C4S.Landscape.ExactLandscape) */
    {
        C4DebugRecOff DBGRECOFF;
        // if overloading, clear current
        if (fOverloadCurrent) Clear(!Game.C4S.Landscape.KeepMapCreator, fLoadSky, false);
        // load it
        if (!fLandscapeModeSet) p->mode = LandscapeMode::Exact;
        rfLoaded = true;
        if (!Load(hGroup, fLoadSky, fSavegame)) return false;
    }
 
    // progress
    Game.SetInitProgress(75);
 
    // copy noscan-var
    p->NoScan = Game.C4S.Landscape.NoScan != 0;
 
    // Scan settings
    p->ScanSpeed = Clamp(GetWidth() / 500, 2, 15);
 
    // Create pixel count array before any SetPix operations may take place
    // Proper pixel counts will be done later, but needs to have the arrays redy to avoid dead pointer access.
    // We will use 15x17 blocks so the pixel count can't get over 255.
    int32_t PixCntWidth = (GetWidth() + 16) / 17;
    p->PixCntPitch = (GetHeight() + 14) / 15;
    p->PixCnt.resize(PixCntWidth * p->PixCntPitch);
 
    // map to big surface and sectionize it
    // (not for shaders though - they require continous textures)
    if (!Game.C4S.Landscape.ExactLandscape)
    {
        assert(p->Surface8 == nullptr);
        assert(p->Surface8Bkg == nullptr);
 
        // Create landscape surfaces
        {
            auto sf8 = std::make_unique<CSurface8>();
            auto sfb8 = std::make_unique<CSurface8>();
            if (!sf8->Create(GetWidth(), GetHeight()) || !sfb8->Create(GetWidth(), GetHeight()))
                return false;
            p->Surface8 = std::move(sf8);
            p->Surface8Bkg = std::move(sfb8);
            if (!p->Mat2Pal())
                return false;
        }
 
        // Map to landscape
        // Landscape render disabled during initial landscape zoom (will be updated later)
        std::unique_ptr<C4LandscapeRender> lsrender_backup;
        lsrender_backup.swap(p->pLandscapeRender);
        bool map2landscape_success = MapToLandscape();
        lsrender_backup.swap(p->pLandscapeRender);
        if (!map2landscape_success) return false;
    }
 
    // Init out-of-landscape pixels for bottom
    p->InitBorderPix();
 
    Game.SetInitProgress(80);
 
    if (Config.General.DebugRec)
    {
        AddDbgRec(RCT_Block, "|---LANDSCAPE---|", 18);
        AddDbgRec(RCT_Map, p->Surface8->Bits, p->Surface8->Pitch * p->Surface8->Hgt);
 
        AddDbgRec(RCT_Block, "|---LANDSCAPE BKG---|", 22);
        AddDbgRec(RCT_Map, p->Surface8Bkg->Bits, p->Surface8Bkg->Pitch * p->Surface8Bkg->Hgt);
    }
 
    // Create FoW
    assert(p->pFoW == nullptr);
    if (Game.C4S.Game.FoWEnabled)
        p->pFoW = std::make_unique<C4FoW>();
 
    // Create renderer
#ifndef USE_CONSOLE
    if (!p->pLandscapeRender)
        p->pLandscapeRender = std::make_unique<C4LandscapeRenderGL>();
#endif
 
    if (p->pLandscapeRender)
    {
        // Initialize renderer
        if (fOverloadCurrent)
        {
            if (!p->pLandscapeRender->ReInit(GetWidth(), GetHeight()))
                return false;
        }
        else
        {
            if (!p->pLandscapeRender->Init(GetWidth(), GetHeight(), &::TextureMap, &::GraphicsResource.Files))
                return false;
        }
    }
 
    // Save initial landscape
    if (!SaveInitial())
        return false;
 
    // Load diff, if existant
    ApplyDiff(hGroup);
 
    // Pixel count tracking from landscape zoom is incomplete, so recalculate it.
    p->UpdatePixCnt(this, C4Rect(0, 0, GetWidth(), GetHeight()));
    p->ClearMatCount();
    p->UpdateMatCnt(this, C4Rect(0, 0, GetWidth(), GetHeight()), true);
 
    // Create initial landscape render data (after applying diff so landscape is complete)
    if (p->pLandscapeRender) p->pLandscapeRender->Update(C4Rect(0, 0, GetWidth(), GetHeight()), this);
    Game.SetInitProgress(87);
 
    // after map/landscape creation, the seed must be fixed again, so there's no difference between clients creating
    // and not creating the map
    Game.FixRandom(Game.RandomSeed);
 
    // Create ambient light map after landscape creation
    if (p->pFoW) p->pFoW->Ambient.CreateFromLandscape(*this, 10., 50., 0.25);
    Game.SetInitProgress(84);
 
    // Success
    rfLoaded = true;
    return true;
}

References C4Game::C4S, C4SLandscape::ExactLandscape, C4Game::FixRandom(), Game, C4Scenario::Landscape, C4SLandscape::MapHgt, C4SLandscape::MapWdt, C4SVal::Max, Random(), C4Game::RandomSeed, C4Game::SetInitProgress(), Undefined, and UpdatePixMaps().

Here is the call graph for this function:

InsertDeadMaterial()

bool C4Landscape::InsertDeadMaterial	(	int32_t	mat,
		int32_t	tx,
		int32_t	ty
	)

Definition at line 1047 of file C4Landscape.cpp.

{
    // Check bounds
    if (tx < 0 || ty < 0 || tx >= GetWidth() || ty >= GetHeight())
        return InsertMaterialOutsideLandscape(tx, ty, std::min(MatDensity(mat), C4M_Solid));
 
    // Save back original material so we can insert it later
    int omat = 0;
    if (Game.C4S.Game.Realism.LandscapeInsertThrust)
        omat = GetMat(tx, ty);
 
    // Check surroundings for inspiration for texture to use
    int n = 0; int pix = -1;
    if (tx > 0 && _GetMat(tx - 1, ty) == mat)
        if (!Random(++n)) pix = _GetPix(tx - 1, ty);
    if (ty > 0 && _GetMat(tx, ty - 1) == mat)
        if (!Random(++n)) pix = _GetPix(tx, ty - 1);
    if (tx + 1 < GetWidth() && _GetMat(tx + 1, ty) == mat)
        if (!Random(++n)) pix = _GetPix(tx + 1, ty);
    if (ty + 1 < GetHeight() && _GetMat(tx, ty + 1) == mat)
        if (!Random(++n)) pix = _GetPix(tx, ty + 1);
    if (pix < 0)
        pix = Mat2PixColDefault(mat);
 
    // Insert dead material
    SetPix2(tx, ty, pix, Transparent);
 
    // Search a position for the old material pixel
    if (Game.C4S.Game.Realism.LandscapeInsertThrust && MatValid(omat))
    {
        int32_t tyo = ty - 1;
        InsertMaterial(omat, &tx, &tyo);
    }
 
    return true;
}

References _GetMat(), _GetPix(), C4M_Solid, C4Game::C4S, Game, C4Scenario::Game, GetHeight(), GetMat(), GetWidth(), InsertMaterial(), InsertMaterialOutsideLandscape(), C4SRealism::LandscapeInsertThrust, Mat2PixColDefault(), MatDensity(), MatValid(), Random(), C4SGame::Realism, SetPix2(), and Transparent.

Referenced by C4MassMover::Execute(), and InsertMaterial().

Here is the call graph for this function:

Here is the caller graph for this function:

InsertMaterial()

bool C4Landscape::InsertMaterial	(	int32_t	mat,
		int32_t *	tx,
		int32_t *	ty,
		int32_t	vx = 0,
		int32_t	vy = 0,
		bool	query_only = false
	)

Definition at line 975 of file C4Landscape.cpp.

{
    assert(tx); assert(ty);
    int32_t mdens;
    if (!MatValid(mat)) return false;
    mdens = std::min(MatDensity(mat), C4M_Solid);
    if (!mdens) return true;
 
    // Bounds
    if (!Inside<int32_t>(*tx, 0, GetWidth() - 1) || !Inside<int32_t>(*ty, 0, GetHeight())) return InsertMaterialOutsideLandscape(*tx, *ty, mdens);
 
    if (Game.C4S.Game.Realism.LandscapePushPull)
    {
        // Same or higher density?
        if (GetDensity(*tx, *ty) >= mdens)
            // Push
            if (!FindMatPathPush(*tx, *ty, mdens, ::MaterialMap.Map[mat].MaxSlide, !!::MaterialMap.Map[mat].Instable))
                // Or die
                return false;
    }
    else
    {
        // Move up above same density
        while (mdens == std::min(GetDensity(*tx, *ty), C4M_Solid))
        {
            (*ty)--; if (*ty < 0) return false;
            // Primitive slide (1)
            if (GetDensity(*tx - 1, *ty) < mdens) (*tx)--;
            if (GetDensity(*tx + 1, *ty) < mdens) (*tx)++;
        }
        // Stuck in higher density
        if (GetDensity(*tx, *ty) > mdens) return false;
    }
 
    // Try slide
    while (FindMatSlide(*tx, *ty, +1, mdens, ::MaterialMap.Map[mat].MaxSlide))
        if (GetDensity(*tx, *ty + 1) < mdens)
        {
            if (!query_only)
                return ::PXS.Create(mat, itofix(*tx), itofix(*ty), C4REAL10(vx), C4REAL10(vy));
            return true;
        }
 
    if (query_only)
    {
        // since tx and ty changed, we need to re-check the bounds here
        // if we really inserted it, the check is made again in InsertDeadMaterial
        if (!Inside<int32_t>(*tx, 0, GetWidth() - 1) || !Inside<int32_t>(*ty, 0, GetHeight())) return InsertMaterialOutsideLandscape(*tx, *ty, mdens);
        return true;
    }
 
    // Try reaction with material below and at insertion position
    C4MaterialReaction *pReact; int32_t tmat;
    int32_t check_dir = 0;
    for (int32_t i = 0; i < 2; ++i)
    {
        if ((pReact = ::MaterialMap.GetReactionUnsafe(mat, tmat = GetMat(*tx, *ty + check_dir))))
        {
            C4Real fvx = C4REAL10(vx), fvy = C4REAL10(vy);
            if ((*pReact->pFunc)(pReact, *tx, *ty, *tx, *ty + check_dir, fvx, fvy, mat, tmat, meePXSPos, nullptr))
            {
                // the material to be inserted killed itself in some material reaction below
                return true;
            }
        }
        if (!(check_dir = Sign(GravAccel))) break;
    }
 
    // Insert as dead material
    return InsertDeadMaterial(mat, *tx, *ty);
}

References C4M_Solid, C4REAL10(), C4Game::C4S, C4PXSSystem::Create(), FindMatPathPush(), FindMatSlide(), Game, C4Scenario::Game, GetDensity(), GetHeight(), GetMat(), C4MaterialMap::GetReactionUnsafe(), GetWidth(), GravAccel, InsertDeadMaterial(), InsertMaterialOutsideLandscape(), C4MaterialCore::Instable, itofix(), C4SRealism::LandscapePushPull, C4MaterialMap::Map, MatDensity(), MaterialMap, MatValid(), C4MaterialCore::MaxSlide, meePXSPos, C4MaterialReaction::pFunc, PXS, C4SGame::Realism, and Sign().

Referenced by C4MassMover::Execute(), InsertDeadMaterial(), C4MaterialMap::mrfIncinerate(), and C4MaterialMap::mrfInsert().

Here is the call graph for this function:

Here is the caller graph for this function:

InsertMaterialOutsideLandscape()

bool C4Landscape::InsertMaterialOutsideLandscape	(	int32_t	tx,
		int32_t	ty,
		int32_t	mdens
	)

Definition at line 967 of file C4Landscape.cpp.

{
    // Out-of-bounds insertion considered successful if inserted into same or lower density
    // This ensures pumping out of map works
    // Do allow insertion into same density because it covers the case of e.g. pumping water into the upper ocean of an underwater scenario
    return GetDensity(tx, ty) <= mdens;
}

References GetDensity().

Referenced by InsertDeadMaterial(), and InsertMaterial().

Here is the call graph for this function:

Here is the caller graph for this function:

Load()

bool C4Landscape::Load	(	C4Group &	hGroup,
		bool	fLoadSky,
		bool	fSavegame
	)

Definition at line 1831 of file C4Landscape.cpp.

{
    assert(!p->Surface8 && !p->Surface8Bkg);
 
    // Load exact landscape from group
    if ((p->Surface8 = GroupReadSurface8(hGroup, C4CFN_Landscape)) == nullptr)
    {
        if ((p->Surface8 = GroupReadSurface8(hGroup, C4CFN_LandscapeFg)) == nullptr) return false;
        p->Surface8Bkg = GroupReadSurface8(hGroup, C4CFN_LandscapeBg);
 
        if (p->Surface8Bkg)
        {
            if (p->Surface8->Wdt != p->Surface8Bkg->Wdt || p->Surface8->Hgt != p->Surface8Bkg->Hgt)
            {
                LogFatal(FormatString("Landscape has different dimensions than background landscape (%dx%d vs. %dx%d)", p->Surface8->Wdt, p->Surface8->Hgt, p->Surface8Bkg->Wdt, p->Surface8Bkg->Hgt).getData());
                return false;
            }
        }
        else
        {
            // LandscapeFg.bmp loaded: Assume full 8bit mat-tex values
            // when creating background surface.
            p->Surface8Bkg = p->CreateDefaultBkgSurface(*p->Surface8, false);
        }
    }
    else
    {
        // Landscape.bmp loaded: Assume msb is IFT flag when creating
        // background surface.
        p->Surface8Bkg = p->CreateDefaultBkgSurface(*p->Surface8, true);
    }
 
    int iWidth, iHeight;
    p->Surface8->GetSurfaceSize(iWidth, iHeight);
    p->Width = iWidth; p->Height = iHeight;
 
    // adjust pal
    if (!p->Mat2Pal()) return false;
    // Landscape should be in correct format: Make sure it is!
    for (int32_t y = 0; y < GetHeight(); ++y)
        for (int32_t x = 0; x < GetWidth(); ++x)
        {
            BYTE byPix = p->Surface8->_GetPix(x, y);
            int32_t iMat = PixCol2Mat(byPix);
 
            if (byPix && !MatValid(iMat))
            {
                LogFatal(FormatString("Landscape loading error at (%d/%d): Pixel value %d not a valid material!", (int)x, (int)y, (int)byPix).getData());
                return false;
            }
 
            BYTE byPixBkg = p->Surface8Bkg->_GetPix(x, y);
            int32_t iMatBkg = PixCol2Mat(byPixBkg);
 
            if (byPixBkg && !MatValid(iMatBkg))
            {
                LogFatal(FormatString("Background Landscape loading error at (%d/%d): Pixel value %d not a valid material!", (int)x, (int)y, (int)byPixBkg).getData());
                return false;
            }
        }
 
    // Init sky
    if (fLoadSky)
    {
        Game.SetInitProgress(70);
        if (p->Sky.Init(fSavegame)) return false;
    }
    // Success
    return true;
}

MapToLandscape()

bool C4Landscape::MapToLandscape

(

)

Definition at line 2110 of file C4Landscape.cpp.

{
    // zoom map to landscape
    return p->MapToLandscape(this, *p->Map, *p->MapBkg, 0, 0, p->MapWidth, p->MapHeight);
}

Referenced by C4ToolsDlg::SetLandscapeMode().

Here is the caller graph for this function:

PostInitMap()

bool C4Landscape::PostInitMap

(

)

Definition at line 2446 of file C4Landscape.cpp.

{
    // map creator present?
    if (!p->pMapCreator) return true;
    // call scripts
    p->pMapCreator->ExecuteCallbacks(p->MapZoom);
    // destroy map creator, if not needed later
    if (!Game.C4S.Landscape.KeepMapCreator) { p->pMapCreator.reset(); }
    // done, success
    return true;
}

References C4Game::C4S, Game, C4SLandscape::KeepMapCreator, and C4Scenario::Landscape.

RaiseTerrain()

void C4Landscape::RaiseTerrain	(	int32_t	tx,
		int32_t	ty,
		int32_t	wdt
	)

Definition at line 940 of file C4Landscape.cpp.

{
    int32_t cx, cy;
    BYTE cpix;
    for (cx = tx; cx < tx + wdt; cx++)
    {
        for (cy = ty; (cy + 1 < ::Landscape.GetHeight()) && !GBackSolid(cx, cy + 1); cy++) {}
        if (cy + 1 < ::Landscape.GetHeight()) if (cy - ty < 20)
        {
            cpix = GetPix(cx, cy + 1);
            if (!MatVehicle(PixCol2Mat(cpix)))
                while (cy >= ty) { SetPix2(cx, cy, cpix, GetBackPix(cx, cy + 1)); cy--; }
        }
    }
}

References GBackSolid(), GetBackPix(), GetHeight(), GetPix(), Landscape, MatVehicle(), PixCol2Mat(), and SetPix2().

Referenced by C4Game::CreateObjectConstruction().

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveUnusedTexMapEntries()

void C4Landscape::RemoveUnusedTexMapEntries

(

)

Definition at line 4151 of file C4Landscape.cpp.

{
    // check usage in landscape
    bool fTexUsage[C4M_MaxTexIndex];
    int32_t iMatTex;
    for (iMatTex = 0; iMatTex < C4M_MaxTexIndex; ++iMatTex)
        fTexUsage[iMatTex] = false;
    for (int32_t y = 0; y < GetHeight(); ++y)
        for (int32_t x = 0; x < GetWidth(); ++x)
        {
            const BYTE pix = p->Surface8->GetPix(x, y);
            const BYTE backPix = p->Surface8Bkg->GetPix(x, y);
            assert(pix < C4M_MaxTexIndex);
            assert(backPix < C4M_MaxTexIndex);
 
            fTexUsage[pix] = true;
            fTexUsage[backPix] = true;
        }
 
    // check usage by materials
    for (int32_t iMat = 0; iMat < ::MaterialMap.Num; ++iMat)
    {
        C4Material *pMat = ::MaterialMap.Map + iMat;
        if (pMat->BlastShiftTo >= 0) fTexUsage[pMat->BlastShiftTo] = true;
        if (pMat->BelowTempConvertTo >= 0) fTexUsage[pMat->BelowTempConvertTo] = true;
        if (pMat->AboveTempConvertTo >= 0) fTexUsage[pMat->AboveTempConvertTo] = true;
        if (pMat->DefaultMatTex >= 0) fTexUsage[pMat->DefaultMatTex] = true;
    }
    // remove unused
    for (iMatTex = 1; iMatTex < C4M_MaxTexIndex; ++iMatTex)
        if (!fTexUsage[iMatTex])
            ::TextureMap.RemoveEntry(iMatTex);
    // flag rewrite
    ::TextureMap.fEntriesAdded = true;
}

References C4Material::AboveTempConvertTo, C4Material::BelowTempConvertTo, C4Material::BlastShiftTo, C4M_MaxTexIndex, C4Material::DefaultMatTex, C4TextureMap::fEntriesAdded, GetHeight(), GetWidth(), C4MaterialMap::Map, MaterialMap, C4MaterialMap::Num, C4TextureMap::RemoveEntry(), TextureMap, CPolyEdge::x, and CPolyEdge::y.

Here is the call graph for this function:

ReplaceMapColor()

bool C4Landscape::ReplaceMapColor	(	BYTE	iOldIndex,
		BYTE	iNewIndex
	)

Definition at line 4046 of file C4Landscape.cpp.

{
    // find every occurance of iOldIndex in map; replace it by new index
    if (!p->Map) return false;
    int iPitch, iMapWdt, iMapHgt;
    BYTE *pMap = p->Map->Bits;
    iMapWdt = p->Map->Wdt;
    iMapHgt = p->Map->Hgt;
    iPitch = p->Map->Pitch;
    if (!pMap) return false;
    for (int32_t y = 0; y < iMapHgt; ++y)
    {
        for (int32_t x = 0; x < iMapWdt; ++x)
        {
            if (*pMap == iOldIndex)
                *pMap = iNewIndex;
            ++pMap;
        }
        pMap += iPitch - iMapWdt;
    }
    return true;
}

References CPolyEdge::x, and CPolyEdge::y.

Referenced by SetTextureIndex().

Here is the caller graph for this function:

Save()

bool C4Landscape::Save

(

C4Group &

hGroup

)

const

Definition at line 1693 of file C4Landscape.cpp.

{
    C4SolidMask::RemoveSolidMasks();
    bool r = p->SaveInternal(this, hGroup);
    C4SolidMask::PutSolidMasks();
    return r;
}

References C4SolidMask::PutSolidMasks(), and C4SolidMask::RemoveSolidMasks().

Referenced by C4Game::LoadScenarioSection().

Here is the call graph for this function:

Here is the caller graph for this function:

SaveDiff()

bool C4Landscape::SaveDiff	(	C4Group &	hGroup,
		bool	fSyncSave
	)		const

Definition at line 1734 of file C4Landscape.cpp.

{
    C4SolidMask::RemoveSolidMasks();
    bool r = p->SaveDiffInternal(this, hGroup, fSyncSave);
    C4SolidMask::PutSolidMasks();
    return r;
}

References C4SolidMask::PutSolidMasks(), and C4SolidMask::RemoveSolidMasks().

Here is the call graph for this function:

SaveInitial()

bool C4Landscape::SaveInitial

(

)

Definition at line 1810 of file C4Landscape.cpp.

{
 
    // Create array
    p->pInitial = std::make_unique<BYTE[]>(GetWidth() * GetHeight());
    p->pInitialBkg = std::make_unique<BYTE[]>(GetWidth() * GetHeight());
 
    // Save material data
    for (int y = 0; y < GetHeight(); y++)
    {
        const int pitch = y * GetWidth();
        for (int x = 0; x < GetWidth(); x++)
        {
            p->pInitial[pitch + x] = p->Surface8->_GetPix(x, y);
            p->pInitialBkg[pitch + x] = p->Surface8Bkg->_GetPix(x, y);
        }
    }
 
    return true;
}

References GetHeight(), GetWidth(), CPolyEdge::x, and CPolyEdge::y.

Here is the call graph for this function:

SaveMap()

bool C4Landscape::SaveMap

(

C4Group &

hGroup

)

const

Definition at line 1954 of file C4Landscape.cpp.

{
    // No map
    if (!p->Map) return false;
    assert(p->MapBkg != nullptr);
 
    // Create map palette
    CStdPalette Palette;
    ::TextureMap.StoreMapPalette(&Palette, ::MaterialMap);
 
    // Save map surface
    if (!p->Map->Save(Config.AtTempPath(C4CFN_TempMapFg), &Palette))
        return false;
 
    // Move temp file to group
    if (!hGroup.Move(Config.AtTempPath(C4CFN_TempMapFg),
        C4CFN_MapFg))
        return false;
 
    // Save background map surface
    if (!p->MapBkg->Save(Config.AtTempPath(C4CFN_TempMapBg), &Palette))
        return false;
 
    // Move temp file to group
    if (!hGroup.Move(Config.AtTempPath(C4CFN_TempMapBg),
        C4CFN_MapBg))
        return false;
 
    // Success
    return true;
}

References C4Config::AtTempPath(), C4CFN_MapBg, C4CFN_MapFg, C4CFN_TempMapBg, C4CFN_TempMapFg, Config, MaterialMap, C4Group::Move(), C4TextureMap::StoreMapPalette(), and TextureMap.

Referenced by C4Landscape::P::SaveDiffInternal(), and C4Landscape::P::SaveInternal().

Here is the call graph for this function:

Here is the caller graph for this function:

SaveTextures()

bool C4Landscape::SaveTextures

(

C4Group &

hGroup

)

const

Definition at line 1986 of file C4Landscape.cpp.

{
    // if material-texture-combinations have been added, write the texture map
    if (::TextureMap.fEntriesAdded)
    {
        C4Group *pMatGroup = new C4Group();
        bool fSuccess = false;
        // create local material group
        if (!hGroup.FindEntry(C4CFN_Material))
        {
            // delete previous item at temp path
            EraseItem(Config.AtTempPath(C4CFN_Material));
            // create at temp path
            if (pMatGroup->Open(Config.AtTempPath(C4CFN_Material), true))
                // write to it
                if (::TextureMap.SaveMap(*pMatGroup, C4CFN_TexMap))
                    // close (flush)
                    if (pMatGroup->Close())
                        // add it
                        if (hGroup.Move(Config.AtTempPath(C4CFN_Material), C4CFN_Material))
                            fSuccess = true;
            // temp group must remain for scenario file closure
            // it will be deleted when the group is closed
        }
        else
            // simply write it to the local material file
            if (pMatGroup->OpenAsChild(&hGroup, C4CFN_Material))
                fSuccess = ::TextureMap.SaveMap(*pMatGroup, C4CFN_TexMap);
        // close material group again
        if (pMatGroup->IsOpen()) pMatGroup->Close();
        delete pMatGroup;
        // fail if unsuccessful
        if (!fSuccess) return false;
    }
    // done, success
    return true;
}

References C4Config::AtTempPath(), C4CFN_Material, C4CFN_TexMap, C4Group::Close(), Config, EraseItem(), C4TextureMap::fEntriesAdded, C4Group::FindEntry(), C4Group::IsOpen(), C4Group::Move(), C4Group::Open(), C4Group::OpenAsChild(), C4TextureMap::SaveMap(), and TextureMap.

Referenced by C4Landscape::P::SaveDiffInternal(), and C4Landscape::P::SaveInternal().

Here is the call graph for this function:

Here is the caller graph for this function:

ScenarioInit()

void C4Landscape::ScenarioInit

(

)

Definition at line 1351 of file C4Landscape.cpp.

{
    // Gravity
    p->Gravity = C4REAL100(Game.C4S.Landscape.Gravity.Evaluate()) * DefaultGravAccel;
}

References C4REAL100(), C4Game::C4S, DefaultGravAccel, C4SVal::Evaluate(), Game, C4SLandscape::Gravity, and C4Scenario::Landscape.

Here is the call graph for this function:

SetGravity()

void C4Landscape::SetGravity

(

C4Real

g

)

Definition at line 3686 of file C4Landscape.cpp.

{
    p->Gravity = g;
}

SetMapChanged()

void C4Landscape::SetMapChanged

(

)

Definition at line 4149 of file C4Landscape.cpp.

{ p->fMapChanged = true; }

Referenced by DrawBox(), DrawBrush(), and DrawLine().

Here is the caller graph for this function:

SetMode()

void C4Landscape::SetMode

(

LandscapeMode

iMode

)

Definition at line 3390 of file C4Landscape.cpp.

{
    p->mode = mode;
}

Referenced by C4ToolsDlg::SetLandscapeMode().

Here is the caller graph for this function:

SetModulation()

bool C4Landscape::SetModulation

(

DWORD

dwWithClr

)

Definition at line 4019 of file C4Landscape.cpp.

{
    p->Modulation = dwWithClr;
    return true;
}

SetPix2()

bool C4Landscape::SetPix2	(	int32_t	x,
		int32_t	y,
		BYTE	fgPix,
		BYTE	bgPix
	)

Definition at line 786 of file C4Landscape.cpp.

{
    // check bounds
    if (x < 0 || y < 0 || x >= GetWidth() || y >= GetHeight())
        return false;
    // no change?
    if ((fgPix == Transparent || fgPix == _GetPix(x, y)) && (bgPix == Transparent || bgPix == p->Surface8Bkg->_GetPix(x, y)))
        return true;
    // set pixel
    return _SetPix2(x, y, fgPix, bgPix);
}

References _GetPix(), _SetPix2(), GetHeight(), GetWidth(), and Transparent.

Referenced by C4Landscape::P::BlastFreePix(), ClearPix(), C4Landscape::P::DoScan(), DrawMaterialRect(), InsertDeadMaterial(), C4SolidMask::Put(), RaiseTerrain(), and C4SolidMask::Repair().

Here is the call graph for this function:

Here is the caller graph for this function:

SetTextureIndex()

bool C4Landscape::SetTextureIndex	(	const char *	szMatTex,
		BYTE	iNewIndex,
		bool	fInsert
	)

Definition at line 4069 of file C4Landscape.cpp.

{
    if (((!szMatTex || !*szMatTex) && !fInsert) || !Inside<int>(iNewIndex, 1, C4M_MaxTexIndex - 1))
    {
        DebugLogF("Cannot insert new texture %s to index %d: Invalid parameters.", (const char *)szMatTex, (int)iNewIndex);
        return false;
    }
    // get last mat index - returns zero for not found (valid for insertion mode)
    StdStrBuf Material, Texture;
    Material.CopyUntil(szMatTex, '-'); Texture.Copy(SSearch(szMatTex, "-"));
    BYTE iOldIndex = (szMatTex && *szMatTex) ? ::TextureMap.GetIndex(Material.getData(), Texture.getData(), false) : 0;
    // insertion mode?
    if (fInsert)
    {
        // there must be room to move up to
        BYTE byLastMoveIndex = C4M_MaxTexIndex - 1;
        while (::TextureMap.GetEntry(byLastMoveIndex))
            if (--byLastMoveIndex == iNewIndex)
            {
                DebugLogF("Cannot insert new texture %s to index %d: No room for insertion.", (const char *)szMatTex, (int)iNewIndex);
                return false;
            }
        // then move up all other textures first
        // could do this in one loop, but it's just a developement call anyway, so move one index at a time
        while (--byLastMoveIndex >= iNewIndex)
            if (::TextureMap.GetEntry(byLastMoveIndex))
            {
                ReplaceMapColor(byLastMoveIndex, byLastMoveIndex + 1);
                ::TextureMap.MoveIndex(byLastMoveIndex, byLastMoveIndex + 1);
            }
        // new insertion desired?
        if (szMatTex && *szMatTex)
        {
            // move from old or create new
            if (iOldIndex)
            {
                ReplaceMapColor(iOldIndex, iNewIndex);
                ::TextureMap.MoveIndex(iOldIndex, iNewIndex);
            }
            else
            {
                StdStrBuf Material, Texture;
                Material.CopyUntil(szMatTex, '-'); Texture.Copy(SSearch(szMatTex, "-"));
                // new insertion
                if (!::TextureMap.AddEntry(iNewIndex, Material.getData(), Texture.getData()))
                {
                    LogF("Cannot insert new texture %s to index %d: Texture map entry error", (const char *)szMatTex, (int)iNewIndex);
                    return false;
                }
            }
        }
        // done, success
        return true;
    }
    else
    {
        // new index must not be occupied
        const C4TexMapEntry *pOld;
        if ((pOld = ::TextureMap.GetEntry(iNewIndex)) && !pOld->isNull())
        {
            DebugLogF("Cannot move texture %s to index %d: Index occupied by %s-%s.", (const char *)szMatTex, (int)iNewIndex, pOld->GetMaterialName(), pOld->GetTextureName());
            return false;
        }
        // must only move existing textures
        if (!iOldIndex)
        {
            DebugLogF("Cannot move texture %s to index %d: Texture not found.", (const char *)szMatTex, (int)iNewIndex);
            return false;
        }
        // update map
        ReplaceMapColor(iOldIndex, iNewIndex);
        // change to new index in texmap
        ::TextureMap.MoveIndex(iOldIndex, iNewIndex);
        // done, success
        return true;
    }
}

References C4TextureMap::AddEntry(), C4M_MaxTexIndex, StdStrBuf::Copy(), StdStrBuf::CopyUntil(), DebugLogF(), StdStrBuf::getData(), C4TextureMap::GetEntry(), C4TextureMap::GetIndex(), C4TexMapEntry::GetMaterialName(), C4TexMapEntry::GetTextureName(), C4TexMapEntry::isNull(), LogF(), C4TextureMap::MoveIndex(), ReplaceMapColor(), SSearch(), and TextureMap.

Here is the call graph for this function:

ShakeFree()

void C4Landscape::ShakeFree	(	int32_t	tx,
		int32_t	ty,
		int32_t	rad
	)

Definition at line 513 of file C4Landscape.cpp.

{
    std::vector<int32_t> vertices(GetRoundPolygon(tx, ty, rad, 50));
    p->ForPolygon(this, &vertices[0], vertices.size() / 2, [this](int32_t x, int32_t y) { return p->ShakeFreePix(this, x, y); });
}

Synchronize()

void C4Landscape::Synchronize

(

)

Definition at line 1937 of file C4Landscape.cpp.

{
    p->ScanX = 0;
}

Referenced by C4Game::Synchronize().

Here is the caller graph for this function:

UpdatePixMaps()

void C4Landscape::UpdatePixMaps

(

)

Definition at line 4226 of file C4Landscape.cpp.

{
    int32_t i;
    for (i = 0; i < C4M_MaxTexIndex; i++) p->Pix2Mat[i] = PixCol2Mat(i);
    for (i = 0; i < C4M_MaxTexIndex; i++) p->Pix2Dens[i] = MatDensity(p->Pix2Mat[i]);
    for (i = 0; i < C4M_MaxTexIndex; i++) p->Pix2Place[i] = MatValid(p->Pix2Mat[i]) ? ::MaterialMap.Map[p->Pix2Mat[i]].Placement : 0;
    for (i = 0; i < C4M_MaxTexIndex; i++) p->Pix2Light[i] = MatValid(p->Pix2Mat[i]) && (::MaterialMap.Map[p->Pix2Mat[i]].Light>0);
    p->Pix2Place[0] = 0;
    // clear bridge mat conversion buffers
    std::fill(p->BridgeMatConversion.begin(), p->BridgeMatConversion.end(), nullptr);
}

References C4M_MaxTexIndex, C4MaterialCore::Light, C4MaterialMap::Map, MatDensity(), MaterialMap, MatValid(), PixCol2Mat(), and C4MaterialCore::Placement.

Referenced by HandleTexMapUpdate(), and Init().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

Transparent

const uint8_t C4Landscape::Transparent = C4M_MaxTexIndex

static

Definition at line 50 of file C4Landscape.h.

Referenced by _SetPix2(), _SetPix2Tmp(), C4Landscape::P::BlastFreePix(), C4Landscape::P::DoScan(), C4Landscape::P::DrawChunk(), DrawPolygon(), InsertDeadMaterial(), C4SolidMask::Put(), C4SolidMask::PutTemporary(), C4SolidMask::Remove(), C4SolidMask::RemoveTemporary(), C4SolidMask::Repair(), and SetPix2().

---

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

• C4Landscape.h
• C4Landscape.cpp
• landscape-handle.cpp