C4Landscape::P Struct Reference

Collaboration diagram for C4Landscape::P:

Public Member Functions
void	ClearMatCount ()
void	ExecuteScan (C4Landscape *)
int32_t	DoScan (C4Landscape *, int32_t x, int32_t y, int32_t mat, int32_t dir)
uint32_t	ChunkyRandom (uint32_t &iOffset, uint32_t iRange) const
void	DrawChunk (C4Landscape *, int32_t tx, int32_t ty, int32_t wdt, int32_t hgt, uint8_t mcol, uint8_t mcolBkg, C4MaterialCoreShape Shape, uint32_t cro)
void	DrawSmoothOChunk (C4Landscape *, int32_t tx, int32_t ty, int32_t wdt, int32_t hgt, uint8_t mcol, uint8_t mcolBkg, int flip, uint32_t cro)
void	ChunkOZoom (C4Landscape *, const CSurface8 &sfcMap, const CSurface8 &sfcMapBkg, int32_t iMapX, int32_t iMapY, int32_t iMapWdt, int32_t iMapHgt, uint8_t iTexture, int32_t iOffX=0, int32_t iOffY=0)
bool	TexOZoom (C4Landscape *, const CSurface8 &sfcMap, const CSurface8 &sfcMapBkg, int32_t iMapX, int32_t iMapY, int32_t iMapWdt, int32_t iMapHgt, DWORD *dwpTextureUsage, int32_t iToX=0, int32_t iToY=0)
bool	MapToSurface (C4Landscape *, const CSurface8 &sfcMap, const CSurface8 &sfcMapBkg, int32_t iMapX, int32_t iMapY, int32_t iMapWdt, int32_t iMapHgt, int32_t iToX, int32_t iToY, int32_t iToWdt, int32_t iToHgt, int32_t iOffX, int32_t iOffY)
bool	MapToLandscape (C4Landscape *d, const CSurface8 &sfcMap, const CSurface8 &sfcMapBkg, int32_t iMapX, int32_t iMapY, int32_t iMapWdt, int32_t iMapHgt, int32_t iOffsX=0, int32_t iOffsY=0, bool noClear=false)
bool	InitBorderPix ()
bool	GetMapColorIndex (const char *szMaterial, const char *szTexture, BYTE &rbyCol) const
bool	CreateMap (CSurface8 *&sfcMap, CSurface8 *&sfcMapBkg)
bool	CreateMapS2 (C4Group &ScenFile, CSurface8 *&sfcMap, CSurface8 *&sfcMapBkg)
bool	Mat2Pal ()
void	UpdatePixCnt (const C4Landscape *, const C4Rect &Rect, bool fCheck=false)
void	UpdateMatCnt (const C4Landscape *, C4Rect Rect, bool fPlus)
void	PrepareChange (const C4Landscape *d, const C4Rect &BoundingBox, bool updateMatCnt=true)
void	FinishChange (C4Landscape *d, C4Rect BoundingBox, bool updateMatAndPixCnt=true)
bool	DrawLineLandscape (int32_t iX, int32_t iY, int32_t iGrade, uint8_t line_color, uint8_t line_color_bkg)
bool	DrawLineMap (int32_t iX, int32_t iY, int32_t iRadius, uint8_t line_color, uint8_t line_color_bkg)
uint8_t *	GetBridgeMatConversion (const C4Landscape *d, int32_t for_material_col) const
bool	SaveInternal (const C4Landscape *d, C4Group &hGroup) const
bool	SaveDiffInternal (const C4Landscape *d, C4Group &hGroup, bool fSyncSave) const
int32_t	ForPolygon (C4Landscape *d, int *vtcs, int length, const std::function< bool(int32_t, int32_t)> &callback, C4MaterialList *mats_count=nullptr, uint8_t col=0, uint8_t colBkg=0, uint8_t *conversion_table=nullptr)
std::unique_ptr< CSurface8 >	CreateDefaultBkgSurface (CSurface8 &sfcFg, bool msbAsIft) const
void	DigMaterial2Objects (int32_t tx, int32_t ty, C4MaterialList *mat_list, C4Object *pCollect=nullptr)
void	BlastMaterial2Objects (int32_t tx, int32_t ty, C4MaterialList *mat_list, int32_t caused_by, int32_t str, C4ValueArray *out_objects)
bool	DigFreePix (C4Landscape *d, int32_t tx, int32_t ty)
bool	DigFreePixNoInstability (C4Landscape *d, int32_t tx, int32_t ty)
bool	BlastFreePix (C4Landscape *d, int32_t tx, int32_t ty)
bool	ShakeFreePix (C4Landscape *d, int32_t tx, int32_t ty)
C4ValueArray *	PrepareFreeShape (C4Rect &BoundingBox, C4Object *by_object)
void	PostFreeShape (C4ValueArray *dig_objects, C4Object *by_object)
BYTE	DefaultBkgMat (BYTE fg) const

Public Attributes
std::unique_ptr< CSurface8 >	Surface8
std::unique_ptr< CSurface8 >	Surface8Bkg
std::unique_ptr< CSurface8 >	Map
std::unique_ptr< CSurface8 >	MapBkg
std::unique_ptr< C4LandscapeRender >	pLandscapeRender
std::vector< uint8_t >	TopRowPix
std::vector< uint8_t >	BottomRowPix
std::vector< uint8_t >	LeftColPix
std::vector< uint8_t >	RightColPix
int32_t	Pix2Mat [C4M_MaxTexIndex]
int32_t	Pix2Dens [C4M_MaxTexIndex]
int32_t	Pix2Place [C4M_MaxTexIndex]
bool	Pix2Light [C4M_MaxTexIndex]
int32_t	PixCntPitch = 0
std::vector< uint8_t >	PixCnt
std::array< C4Rect, C4LS_MaxRelights >	Relights
std::array< std::unique_ptr< uint8_t[]>, C4M_MaxTexIndex >	BridgeMatConversion
LandscapeMode	mode = LandscapeMode::Undefined
int32_t	Width = 0
int32_t	Height = 0
int32_t	MapWidth = 0
int32_t	MapHeight = 0
int32_t	MapZoom = 0
std::array< DWORD, C4MaxMaterial >	MatCount {}
std::array< DWORD, C4MaxMaterial >	EffectiveMatCount {}
bool	NoScan = false
int32_t	ScanX = 0
int32_t	ScanSpeed = 2
C4Real	Gravity = DefaultGravAccel
uint32_t	Modulation = 0
int32_t	MapSeed = 0
C4Sky	Sky
std::unique_ptr< C4MapCreatorS2 >	pMapCreator
bool	fMapChanged = false
std::unique_ptr< BYTE[]>	pInitial
std::unique_ptr< BYTE[]>	pInitialBkg
std::unique_ptr< C4FoW >	pFoW

Detailed Description

Definition at line 52 of file C4Landscape.cpp.

Member Function Documentation

BlastFreePix()

bool C4Landscape::P::BlastFreePix	(	C4Landscape *	d,
		int32_t	tx,
		int32_t	ty
	)

Definition at line 737 of file C4Landscape.cpp.

{
    int32_t mat = d->GetMat(tx, ty);
    if (MatValid(mat))
    {
        // for blast, either shift to different material or blast free
        if (::MaterialMap.Map[mat].BlastFree)
        {
            d->ClearPix(tx, ty);
            // check for instable materials to start moving by the cleared space
            d->CheckInstabilityRange(tx, ty);
            return true;
        }
        else
            if (::MaterialMap.Map[mat].BlastShiftTo)
                d->SetPix2(tx, ty, MatTex2PixCol(::MaterialMap.Map[mat].BlastShiftTo), Transparent);
    }
    return false;
}

References C4MaterialCore::BlastFree, C4Material::BlastShiftTo, C4Landscape::CheckInstabilityRange(), C4Landscape::ClearPix(), C4Landscape::GetMat(), C4MaterialMap::Map, MaterialMap, MatTex2PixCol(), MatValid(), C4Landscape::SetPix2(), and C4Landscape::Transparent.

Here is the call graph for this function:

BlastMaterial2Objects()

void C4Landscape::P::BlastMaterial2Objects	(	int32_t	tx,
		int32_t	ty,
		C4MaterialList *	mat_list,
		int32_t	caused_by,
		int32_t	str,
		C4ValueArray *	out_objects
	)

Definition at line 641 of file C4Landscape.cpp.

{
    for (int32_t mat = 0; mat < ::MaterialMap.Num; mat++)
    {
        if (mat_list->Amount[mat])
        {
            int32_t cast_strength = str;
            int32_t pxsamount = 0, blastamount = 0;
 
            if (::MaterialMap.Map[mat].Blast2PXSRatio != 0)
            {
                pxsamount = mat_list->Amount[mat] / ::MaterialMap.Map[mat].Blast2PXSRatio;
                ::PXS.Cast(mat, pxsamount, tx, ty, cast_strength * 2);
            }
 
            if (::MaterialMap.Map[mat].Blast2Object != C4ID::None)
            {
                if (::MaterialMap.Map[mat].Blast2ObjectRatio != 0)
                {
                    blastamount = mat_list->Amount[mat] / ::MaterialMap.Map[mat].Blast2ObjectRatio;
                    Game.CastObjects(::MaterialMap.Map[mat].Blast2Object, nullptr, blastamount, cast_strength, tx, ty, NO_OWNER, caused_by, out_objects);
                }
            }
 
            mat_list->Amount[mat] -= std::max(blastamount * ::MaterialMap.Map[mat].Blast2ObjectRatio,
                pxsamount * ::MaterialMap.Map[mat].Blast2PXSRatio);
        }
    }
}

References C4MaterialList::Amount, C4MaterialCore::Blast2Object, C4MaterialCore::Blast2ObjectRatio, C4MaterialCore::Blast2PXSRatio, C4PXSSystem::Cast(), C4Game::CastObjects(), Game, C4MaterialMap::Map, MaterialMap, NO_OWNER, C4ID::None, C4MaterialMap::Num, and PXS.

Here is the call graph for this function:

ChunkOZoom()

void C4Landscape::P::ChunkOZoom	(	C4Landscape *	d,
		const CSurface8 &	sfcMap,
		const CSurface8 &	sfcMapBkg,
		int32_t	iMapX,
		int32_t	iMapY,
		int32_t	iMapWdt,
		int32_t	iMapHgt,
		uint8_t	iTexture,
		int32_t	iOffX = 0,
		int32_t	iOffY = 0
	)

Definition at line 2187 of file C4Landscape.cpp.

{
    const C4TexMapEntry *entry = ::TextureMap.GetEntry(iTexture);
    C4Material *pMaterial = entry->GetMaterial();
    if (!pMaterial) return;
    const char *texture_name = entry->GetTextureName();
    C4Texture *texture = ::TextureMap.GetTexture(texture_name);
    C4TextureShape *shape = texture ? texture->GetMaterialShape() : nullptr;
    // Chunk type by material
    C4MaterialCoreShape iChunkType = ::Game.C4S.Landscape.FlatChunkShapes ? C4M_Flat : pMaterial->MapChunkType;
    // Get map & landscape size
    int iMapWidth, iMapHeight;
    sfcMap.GetSurfaceSize(iMapWidth, iMapHeight);
    // Clip desired map segment to map size
    iMapX = Clamp<int32_t>(iMapX, 0, iMapWidth - 1);
    iMapY = Clamp<int32_t>(iMapY, 0, iMapHeight - 1);
    iMapWdt = Clamp<int32_t>(iMapWdt, 0, iMapWidth - iMapX);
    iMapHgt = Clamp<int32_t>(iMapHgt, 0, iMapHeight - iMapY);
    // get chunk size
    int iChunkWidth = MapZoom, iChunkHeight = MapZoom;
    // Scan map lines
    for (int iY = iMapY; iY < iMapY + iMapHgt; iY++)
    {
        // Landscape target coordinate vertical
        int iToY = iY * iChunkHeight + iOffY;
        // Scan map line
        for (int iX = iMapX; iX < iMapX + iMapWdt; iX++)
        {
            // Map scan line start
            uint8_t MapPixel = sfcMap._GetPix(iX, iY);
            uint8_t MapPixelBkg = sfcMapBkg._GetPix(iX, iY);
            // Landscape target coordinate horizontal
            int iToX = iX * iChunkWidth + iOffX;
            // Here's a chunk of the texture-material to zoom
            if (MapPixel == iTexture)
            {
                // Draw chunk
                DrawChunk(d, iToX, iToY, iChunkWidth, iChunkHeight, MapPixel, MapPixelBkg, iChunkType, (iX << 16) + iY);
            }
            // Other chunk, check for slope smoothers
            else if (iChunkType == C4M_Smooth || iChunkType == C4M_Smoother || iChunkType == C4M_Octagon)
            {
                // Map scan line pixel below
                uint8_t below = sfcMap.GetPix(iX, iY + 1);
                uint8_t above = sfcMap.GetPix(iX, iY - 1);
                uint8_t left = sfcMap.GetPix(iX - 1, iY);
                uint8_t right = sfcMap.GetPix(iX + 1, iY);
                uint8_t leftBkg = sfcMapBkg.GetPix(iX - 1, iY);
                uint8_t rightBkg = sfcMapBkg.GetPix(iX + 1, iY);
                // do not fill a tiny hole
                if (below == iTexture && above == iTexture && left == iTexture && right == iTexture)
                    continue;
                int flat = iChunkType == C4M_Octagon ? 4 : 0;
                // Smooth chunk & same texture-material below
                if (iY < iMapHeight - 1 && below == iTexture)
                {
                    // Same texture-material on left
                    if (iX > 0 && left == iTexture)
                    {
                        // Draw smoother
                        DrawSmoothOChunk(d, iToX, iToY, iChunkWidth, iChunkHeight, left, leftBkg, 3 + flat, (iX << 16) + iY);
                    }
                    // Same texture-material on right
                    if (iX < iMapWidth - 1 && right == iTexture)
                    {
                        // Draw smoother
                        DrawSmoothOChunk(d, iToX, iToY, iChunkWidth, iChunkHeight, right, rightBkg, 0 + flat, (iX << 16) + iY);
                    }
                }
                // Smooth chunk & same texture-material above
                if (iY > 0 && above == iTexture)
                {
                    // Same texture-material on left
                    if (iX > 0 && left == iTexture)
                    {
                        // Draw smoother
                        DrawSmoothOChunk(d, iToX, iToY, iChunkWidth, iChunkHeight, left, leftBkg, 2 + flat, (iX << 16) + iY);
                    }
                    // Same texture-material on right
                    if (iX < iMapWidth - 1 && right == iTexture)
                    {
                        // Draw smoother
                        DrawSmoothOChunk(d, iToX, iToY, iChunkWidth, iChunkHeight, right, rightBkg, 1 + flat, (iX << 16) + iY);
                    }
                }
            }
        }
    }
    // Draw custom shapes on top of regular materials
    if (shape && !::Game.C4S.Landscape.FlatChunkShapes) shape->Draw(sfcMap, sfcMapBkg, iMapX, iMapY, iMapWdt, iMapHgt, iTexture, iOffX, iOffY, MapZoom, pMaterial->MinShapeOverlap);
}

References CSurface8::_GetPix(), C4M_Flat, C4M_Octagon, C4M_Smooth, C4M_Smoother, C4Game::C4S, C4TextureShape::Draw(), C4SLandscape::FlatChunkShapes, Game, C4TextureMap::GetEntry(), C4TexMapEntry::GetMaterial(), C4Texture::GetMaterialShape(), CSurface8::GetPix(), CSurface8::GetSurfaceSize(), C4TextureMap::GetTexture(), C4TexMapEntry::GetTextureName(), C4Scenario::Landscape, C4ScriptGuiWindowPropertyName::left, C4MaterialCore::MapChunkType, C4MaterialCore::MinShapeOverlap, C4ScriptGuiWindowPropertyName::right, and TextureMap.

Here is the call graph for this function:

ChunkyRandom()

uint32_t C4Landscape::P::ChunkyRandom	(	uint32_t &	iOffset,
		uint32_t	iRange
	)		const

Definition at line 2117 of file C4Landscape.cpp.

{
    if (!iRange) return 0;
    iOffset = (iOffset * 16807) % 2147483647;
    return (iOffset ^ MapSeed) % iRange;
}

ClearMatCount()

void C4Landscape::P::ClearMatCount

(

)

Definition at line 1931 of file C4Landscape.cpp.

{
    std::fill(MatCount.begin(), MatCount.end(), 0);
    std::fill(EffectiveMatCount.begin(), EffectiveMatCount.end(), 0);
}

CreateDefaultBkgSurface()

std::unique_ptr< CSurface8 > C4Landscape::P::CreateDefaultBkgSurface	(	CSurface8 &	sfcFg,
		bool	msbAsIft
	)		const

Definition at line 1101 of file C4Landscape.cpp.

{
    auto sfcBg = std::make_unique<CSurface8>();
    if (!sfcBg->Create(sfcFg.Wdt, sfcFg.Hgt))
    {
        return nullptr;
    }
 
    for (int32_t y = 0; y < sfcFg.Hgt; ++y)
    {
        for (int32_t x = 0; x < sfcFg.Wdt; ++x)
        {
            BYTE fgPix = sfcFg._GetPix(x, y);
            BYTE bgPix;
 
            // If we treat the most significant bit as the IFT flag
            // (compatibility option for pre-7.0 maps), then set
            // the background pixel to 0 if the foreground does not
            // have IFT set, and remove the IFT flag from the
            // foreground pixel.
            if (msbAsIft)
            {
                if (fgPix & 0x80)
                {
                    fgPix &= ~0x80;
                    sfcFg._SetPix(x, y, fgPix);
                    bgPix = DefaultBkgMat(fgPix);
                }
                else
                {
                    bgPix = 0;
                }
            }
            else
            {
                bgPix = DefaultBkgMat(fgPix);
            }
 
            sfcBg->_SetPix(x, y, bgPix);
        }
    }
 
    return sfcBg;
}

References CSurface8::_GetPix(), CSurface8::_SetPix(), CSurface8::Hgt, and CSurface8::Wdt.

Here is the call graph for this function:

CreateMap()

bool C4Landscape::P::CreateMap	(	CSurface8 *&	sfcMap,
		CSurface8 *&	sfcMapBkg
	)

Definition at line 2404 of file C4Landscape.cpp.

{
    int32_t iWidth = 0, iHeight = 0;
 
    // Create map surface
    Game.C4S.Landscape.GetMapSize(iWidth, iHeight, Game.StartupPlayerCount);
    auto fg_map = std::make_unique<CSurface8>(iWidth, iHeight);
 
    // Fill sfcMap
    C4MapCreator MapCreator;
    MapCreator.Create(fg_map.get(),
        Game.C4S.Landscape, ::TextureMap,
        Game.StartupPlayerCount);
 
    auto bg_map = CreateDefaultBkgSurface(*fg_map, false);
    if (!bg_map)
        return false;
 
    sfcMap = fg_map.release();
    sfcMapBkg = bg_map.release();
    return true;
}

References C4Game::C4S, C4MapCreator::Create(), Game, C4SLandscape::GetMapSize(), C4Scenario::Landscape, C4Game::StartupPlayerCount, and TextureMap.

Here is the call graph for this function:

CreateMapS2()

bool C4Landscape::P::CreateMapS2	(	C4Group &	ScenFile,
		CSurface8 *&	sfcMap,
		CSurface8 *&	sfcMapBkg
	)

Definition at line 2427 of file C4Landscape.cpp.

{
    // file present?
    if (!ScenFile.AccessEntry(C4CFN_DynLandscape)) return false;
 
    // create map creator
    if (!pMapCreator)
        pMapCreator = std::make_unique<C4MapCreatorS2>(&Game.C4S.Landscape, &::TextureMap, &::MaterialMap, Game.StartupPlayerCount);
 
    // read file
    pMapCreator->ReadFile(C4CFN_DynLandscape, &ScenFile);
    // render landscape
    if (!pMapCreator->Render(nullptr, sfcMap, sfcMapBkg))
        return false;
 
    // keep map creator until script callbacks have been done
    return true;
}

References C4Group::AccessEntry(), C4CFN_DynLandscape, C4Game::C4S, Game, C4Scenario::Landscape, MaterialMap, C4Game::StartupPlayerCount, and TextureMap.

Here is the call graph for this function:

DefaultBkgMat()

BYTE C4Landscape::P::DefaultBkgMat

(

BYTE

fg

)

const

Definition at line 1096 of file C4Landscape.cpp.

{
    return ::TextureMap.DefaultBkgMatTex(fg);
}

References C4TextureMap::DefaultBkgMatTex(), and TextureMap.

Here is the call graph for this function:

DigFreePix()

bool C4Landscape::P::DigFreePix	(	C4Landscape *	d,
		int32_t	tx,
		int32_t	ty
	)

Definition at line 723 of file C4Landscape.cpp.

{
    int32_t mat = d->GetMat(tx, ty);
    if (MatValid(mat))
        if (::MaterialMap.Map[mat].DigFree)
        {
            d->ClearPix(tx, ty);
            // check for instable materials to start moving by the cleared space
            d->CheckInstabilityRange(tx, ty);
            return true;
        }
    return false;
}

References C4Landscape::CheckInstabilityRange(), C4Landscape::ClearPix(), C4MaterialCore::DigFree, C4Landscape::GetMat(), C4MaterialMap::Map, MaterialMap, and MatValid().

Here is the call graph for this function:

DigFreePixNoInstability()

bool C4Landscape::P::DigFreePixNoInstability	(	C4Landscape *	d,
		int32_t	tx,
		int32_t	ty
	)

Definition at line 711 of file C4Landscape.cpp.

{
    int32_t mat = d->GetMat(tx, ty);
    if (MatValid(mat))
        if (::MaterialMap.Map[mat].DigFree)
        {
            d->ClearPix(tx, ty);
            return true;
        }
    return false;
}

References C4Landscape::ClearPix(), C4MaterialCore::DigFree, C4Landscape::GetMat(), C4MaterialMap::Map, MaterialMap, and MatValid().

Here is the call graph for this function:

DigMaterial2Objects()

void C4Landscape::P::DigMaterial2Objects	(	int32_t	tx,
		int32_t	ty,
		C4MaterialList *	mat_list,
		C4Object *	pCollect = nullptr
	)

Definition at line 671 of file C4Landscape.cpp.

{
    C4AulParSet pars(pCollect);
    for (int32_t mat = 0; mat < ::MaterialMap.Num; mat++)
    {
        if (mat_list->Amount[mat])
        {
            if (::MaterialMap.Map[mat].Dig2Object != C4ID::None)
                if (::MaterialMap.Map[mat].Dig2ObjectRatio != 0)
                    while (mat_list->Amount[mat] >= ::MaterialMap.Map[mat].Dig2ObjectRatio)
                    {
                        mat_list->Amount[mat] -= ::MaterialMap.Map[mat].Dig2ObjectRatio;
                        C4Object *pObj = Game.CreateObject(::MaterialMap.Map[mat].Dig2Object, nullptr, NO_OWNER, tx, ty);
                        if (!pObj || !pObj->Status) continue;
                        // Set controller to the controller of the object responsible for digging out
                        if (pCollect && pCollect->Status)
                            pObj->Controller = pCollect->Controller;
                        // Do callbacks to dug object and digger
                        pObj->Call(PSF_OnDugOut, &pars);
                        if (!pObj->Status || !pCollect || !pCollect->Status || pObj->Contained) continue;
                        C4AulParSet pars(C4VObj(pObj));
                        pCollect->Call(PSF_DigOutObject, &pars);
                        if (!pObj->Status || !pCollect->Status || pObj->Contained) continue;
                        // Try to collect object
                        if (::MaterialMap.Map[mat].Dig2ObjectCollect)
                            if (pCollect && pCollect->Status && pObj && pObj->Status)
                                if (!pCollect->Collect(pObj))
                                    // Collection forced? Don't generate objects
                                    if (::MaterialMap.Map[mat].Dig2ObjectCollect == 2)
                                    {
                                        pObj->AssignRemoval();
                                        // Cap so we never have more than one object worth of material in the store
                                        mat_list->Amount[mat] = ::MaterialMap.Map[mat].Dig2ObjectRatio;
                                        break;
                                    }
                    }
        }
    }
}

References C4MaterialList::Amount, C4Object::AssignRemoval(), C4VObj(), C4PropList::Call(), C4Object::Collect(), C4Object::Contained, C4Object::Controller, C4Game::CreateObject(), C4MaterialCore::Dig2Object, C4MaterialCore::Dig2ObjectCollect, C4MaterialCore::Dig2ObjectRatio, Game, C4MaterialMap::Map, MaterialMap, NO_OWNER, C4ID::None, C4MaterialMap::Num, PSF_DigOutObject, PSF_OnDugOut, and C4PropList::Status.

Here is the call graph for this function:

DoScan()

int32_t C4Landscape::P::DoScan	(	C4Landscape *	d,
		int32_t	x,
		int32_t	y,
		int32_t	mat,
		int32_t	dir
	)

Definition at line 274 of file C4Landscape.cpp.

{
    int32_t conv_to_tex = 0;
    int32_t iTemperature = ::Weather.GetTemperature();
    // Check below conv
    if (::MaterialMap.Map[mat].BelowTempConvertDir == dir)
        if (::MaterialMap.Map[mat].BelowTempConvertTo)
            if (iTemperature< ::MaterialMap.Map[mat].BelowTempConvert)
                conv_to_tex = ::MaterialMap.Map[mat].BelowTempConvertTo;
    // Check above conv
    if (::MaterialMap.Map[mat].AboveTempConvertDir == dir)
        if (::MaterialMap.Map[mat].AboveTempConvertTo)
            if (iTemperature>::MaterialMap.Map[mat].AboveTempConvert)
                conv_to_tex = ::MaterialMap.Map[mat].AboveTempConvertTo;
    // nothing to do?
    if (!conv_to_tex) return 0;
    // find material
    int32_t conv_to = ::TextureMap.GetEntry(conv_to_tex)->GetMaterialIndex();
    // find mat top
    int32_t mconv = ::MaterialMap.Map[mat].TempConvStrength,
        mconvs = mconv;
    if (DEBUGREC_MATSCAN && Config.General.DebugRec)
    {
        C4RCMatScan rc = { cx, cy, mat, conv_to, dir, mconvs };
        AddDbgRec(RCT_MatScanDo, &rc, sizeof(C4RCMatScan));
    }
    int32_t ydir = (dir == 0 ? +1 : -1), cy2;
#ifdef PRETTY_TEMP_CONV
    // get left pixel
    int32_t lmat = (cx > 0 ? d->_GetMat(cx - 1, cy) : -1);
    // left pixel not converted? do nothing
    if (lmat == mat) return 0;
    // left pixel converted? suppose it was done by a prior scan and skip check
    if (lmat != conv_to)
    {
        int32_t iSearchRange = std::max<int32_t>(5, mconvs);
        // search upper/lower bound
        int32_t cys = cy, cxs = cx;
        while (cxs < ::Landscape.GetWidth() - 1)
        {
            // one step right
            cxs++;
            if (d->_GetMat(cxs, cys) == mat)
            {
                // search surface
                cys -= ydir;
                while (Inside<int32_t>(cys, 0, ::Landscape.GetHeight() - 1) && d->_GetMat(cxs, cys) == mat)
                {
                    cys -= ydir;
                    if ((mconvs = std::min(mconv - Abs(cys - cy), mconvs)) < 0)
                        return 0;
                }
                // out of bounds?
                if (!Inside<int32_t>(cys, 0, ::Landscape.GetHeight() - 1)) break;
                // back one step
                cys += ydir;
            }
            else
            {
                // search surface
                cys += ydir;
                while (Inside<int32_t>(cys, 0, ::Landscape.GetHeight() - 1) && d->_GetMat(cxs, cys) != mat)
                {
                    cys += ydir;
                    if (Abs(cys - cy) > iSearchRange)
                        break;
                }
                // out of bounds?
                if (!Inside<int32_t>(cys, 0, ::Landscape.GetHeight() - 1)) break;
                if (Abs(cys - cy) > iSearchRange) break;
            }
        }
    }
#endif
    // Conversion
    bool conv_to_is_solid = (conv_to > -1) && DensitySolid(::MaterialMap.Map[conv_to].Density);
    for (cy2 = cy; mconvs >= 0 && Inside<int32_t>(cy2, 0, ::Landscape.GetHeight() - 1); cy2 += ydir, mconvs--)
    {
        // material changed?
        int32_t pix = d->_GetPix(cx, cy2);
        if (PixCol2Mat(pix) != mat) break;
#ifdef PRETTY_TEMP_CONV
        // get left pixel
        int32_t lmat = (cx > 0 ? d->_GetMat(cx - 1, cy2) : -1);
        // left pixel not converted? break
        if (lmat == mat) break;
#endif
        // set mat (and keep background material)
        d->SetPix2(cx, cy2, MatTex2PixCol(conv_to_tex), Transparent);
        if (!conv_to_is_solid) d->CheckInstabilityRange(cx, cy2);
    }
    // return pixel converted
    return Abs(cy2 - cy);
}

References C4Landscape::_GetMat(), C4Landscape::_GetPix(), C4MaterialCore::AboveTempConvert, C4MaterialCore::AboveTempConvertDir, C4Material::AboveTempConvertTo, Abs(), AddDbgRec(), C4MaterialCore::BelowTempConvert, C4MaterialCore::BelowTempConvertDir, C4Material::BelowTempConvertTo, C4Landscape::CheckInstabilityRange(), Config, C4ConfigGeneral::DebugRec, DEBUGREC_MATSCAN, C4MaterialCore::Density, DensitySolid(), C4Config::General, C4TextureMap::GetEntry(), C4Landscape::GetHeight(), C4TexMapEntry::GetMaterialIndex(), C4Weather::GetTemperature(), C4Landscape::GetWidth(), Landscape, C4MaterialMap::Map, MaterialMap, MatTex2PixCol(), PixCol2Mat(), RCT_MatScanDo, C4Landscape::SetPix2(), C4MaterialCore::TempConvStrength, TextureMap, C4Landscape::Transparent, and Weather.

Referenced by ExecuteScan().

Here is the call graph for this function:

Here is the caller graph for this function:

DrawChunk()

void C4Landscape::P::DrawChunk	(	C4Landscape *	d,
		int32_t	tx,
		int32_t	ty,
		int32_t	wdt,
		int32_t	hgt,
		uint8_t	mcol,
		uint8_t	mcolBkg,
		C4MaterialCoreShape	Shape,
		uint32_t	cro
	)

Definition at line 2124 of file C4Landscape.cpp.

{
    unsigned int top_rough = 0, side_rough = 0, bottom_rough = 0;
    // what to do?
    switch (Shape)
    {
    case C4M_Flat: case C4M_Octagon:
        if (mcol != Transparent) Surface8->Box(tx, ty, tx + wdt, ty + hgt, mcol);
        if (mcolBkg != Transparent) Surface8Bkg->Box(tx, ty, tx + wdt, ty + hgt, mcolBkg);
        return;
    case C4M_TopFlat:
        top_rough = 0; side_rough = 2; bottom_rough = 4;
        break;
    case C4M_Smooth:
        top_rough = 2; side_rough = 2; bottom_rough = 2;
        break;
    case C4M_Rough:
        top_rough = 4; side_rough = 4; bottom_rough = 4;
        break;
    case C4M_Smoother:
        top_rough = 1; side_rough = 1; bottom_rough = 1;
        break;
    }
    int vtcs[16];
    unsigned int rx = std::max(wdt / 2, 1);
 
    vtcs[0] = tx - ChunkyRandom(cro, rx * side_rough / 4);       vtcs[1] = ty - ChunkyRandom(cro, rx * top_rough / 4);
    vtcs[2] = tx - ChunkyRandom(cro, rx * side_rough / 2);       vtcs[3] = ty + hgt / 2;
    vtcs[4] = tx - ChunkyRandom(cro, rx * side_rough / 4);       vtcs[5] = ty + hgt + ChunkyRandom(cro, rx * bottom_rough / 4);
    vtcs[6] = tx + wdt / 2;                                      vtcs[7] = ty + hgt + ChunkyRandom(cro, rx * bottom_rough / 2);
    vtcs[8] = tx + wdt + ChunkyRandom(cro, rx * side_rough / 4); vtcs[9] = ty + hgt + ChunkyRandom(cro, rx * bottom_rough / 4);
    vtcs[10] = tx + wdt + ChunkyRandom(cro, rx * side_rough / 2); vtcs[11] = ty + hgt / 2;
    vtcs[12] = tx + wdt + ChunkyRandom(cro, rx * side_rough / 4); vtcs[13] = ty - ChunkyRandom(cro, rx * top_rough / 4);
    vtcs[14] = tx + wdt / 2;                                      vtcs[15] = ty - ChunkyRandom(cro, rx * top_rough / 2);
 
    ForPolygon(d, vtcs, 8, nullptr, nullptr, mcol, mcolBkg);
}

References C4M_Flat, C4M_Octagon, C4M_Rough, C4M_Smooth, C4M_Smoother, C4M_TopFlat, and C4Landscape::Transparent.

DrawLineLandscape()

bool C4Landscape::P::DrawLineLandscape	(	int32_t	iX,
		int32_t	iY,
		int32_t	iGrade,
		uint8_t	line_color,
		uint8_t	line_color_bkg
	)

Definition at line 3471 of file C4Landscape.cpp.

{
    Surface8->Circle(iX, iY, iGrade, line_color);
    Surface8Bkg->Circle(iX, iY, iGrade, line_color_bkg);
    return true;
}

DrawLineMap()

bool C4Landscape::P::DrawLineMap	(	int32_t	iX,
		int32_t	iY,
		int32_t	iRadius,
		uint8_t	line_color,
		uint8_t	line_color_bkg
	)

Definition at line 3478 of file C4Landscape.cpp.

{
    if (!Map) return false;
    if (iRadius == 1)
    {
        Map->SetPix(iX, iY, line_color); MapBkg->SetPix(iX, iY, line_color_bkg);
    }
    else
    {
        Map->Circle(iX, iY, iRadius, line_color); MapBkg->Circle(iX, iY, iRadius, line_color_bkg);
    }
    return true;
}

DrawSmoothOChunk()

void C4Landscape::P::DrawSmoothOChunk	(	C4Landscape *	d,
		int32_t	tx,
		int32_t	ty,
		int32_t	wdt,
		int32_t	hgt,
		uint8_t	mcol,
		uint8_t	mcolBkg,
		int	flip,
		uint32_t	cro
	)

Definition at line 2162 of file C4Landscape.cpp.

{
    int vtcs[8];
    unsigned int rx = std::max(wdt / 2, 1);
 
    vtcs[0] = tx;       vtcs[1] = ty;
    vtcs[2] = tx;       vtcs[3] = ty + hgt;
    vtcs[4] = tx + wdt; vtcs[5] = ty + hgt;
    vtcs[6] = tx + wdt; vtcs[7] = ty;
 
    switch (flip)
    {
    case 0: vtcs[0] = tx + wdt / 2; vtcs[1] += hgt / 3; vtcs[7] -= ChunkyRandom(cro, rx / 2); break;
    case 1: vtcs[2] = tx + wdt / 2; vtcs[3] -= hgt / 3; vtcs[5] += ChunkyRandom(cro, rx / 2); break;
    case 2: vtcs[4] = tx + wdt / 2; vtcs[5] -= hgt / 3; vtcs[3] += ChunkyRandom(cro, rx / 2); break;
    case 3: vtcs[6] = tx + wdt / 2; vtcs[7] += hgt / 3; vtcs[1] -= ChunkyRandom(cro, rx / 2); break;
    case 4: vtcs[0] = tx + wdt / 2; vtcs[1] += hgt / 2; break;
    case 5: vtcs[2] = tx + wdt / 2; vtcs[3] -= hgt / 2; break;
    case 6: vtcs[4] = tx + wdt / 2; vtcs[5] -= hgt / 2; break;
    case 7: vtcs[6] = tx + wdt / 2; vtcs[7] += hgt / 2; break;
    }
 
    ForPolygon(d, vtcs, 4, nullptr, nullptr, mcol, mcolBkg);
}

ExecuteScan()

void C4Landscape::P::ExecuteScan

(

C4Landscape *

d

)

Definition at line 220 of file C4Landscape.cpp.

{
    int32_t cy, mat;
 
    // Check: Scan needed?
    const int32_t iTemperature = ::Weather.GetTemperature();
    for (mat = 0; mat < ::MaterialMap.Num; mat++)
        if (MatCount[mat])
        {
            if (::MaterialMap.Map[mat].BelowTempConvertTo &&
                iTemperature < ::MaterialMap.Map[mat].BelowTempConvert)
                break;
            else if (::MaterialMap.Map[mat].AboveTempConvertTo &&
                iTemperature > ::MaterialMap.Map[mat].AboveTempConvert)
                break;
        }
    if (mat >= ::MaterialMap.Num)
        return;
 
    if (DEBUGREC_MATSCAN && Config.General.DebugRec)
        AddDbgRec(RCT_MatScan, &ScanX, sizeof(ScanX));
 
    for (int32_t cnt = 0; cnt < ScanSpeed; cnt++)
    {
 
        // Scan landscape column: sectors down
        int32_t last_mat = -1;
        for (cy = 0; cy < Height; cy++)
        {
            mat = d->_GetMat(ScanX, cy);
            // material change?
            if (last_mat != mat)
            {
                // upwards
                if (last_mat != -1)
                    DoScan(d, ScanX, cy - 1, last_mat, 1);
                // downwards
                if (mat != -1)
                    cy += DoScan(d, ScanX, cy, mat, 0);
            }
            last_mat = mat;
        }
 
        // Scan advance & rewind
        ScanX++;
        if (ScanX >= Width)
            ScanX = 0;
 
    }
 
}

References C4Landscape::_GetMat(), C4MaterialCore::AboveTempConvert, C4Material::AboveTempConvertTo, AddDbgRec(), C4MaterialCore::BelowTempConvert, C4Material::BelowTempConvertTo, Config, C4ConfigGeneral::DebugRec, DEBUGREC_MATSCAN, DoScan(), C4Config::General, C4Weather::GetTemperature(), Height, C4MaterialMap::Map, MatCount, MaterialMap, C4MaterialMap::Num, RCT_MatScan, ScanSpeed, ScanX, Weather, and Width.

Here is the call graph for this function:

FinishChange()

void C4Landscape::P::FinishChange	(	C4Landscape *	d,
		C4Rect	BoundingBox,
		bool	updateMatAndPixCnt = true
	)

Definition at line 3927 of file C4Landscape.cpp.

{
    // Intersect bounding box with landscape
    BoundingBox.Intersect(C4Rect(0, 0, Width, Height));
    if (!BoundingBox.Wdt || !BoundingBox.Hgt) return;
    // update render
    if (pLandscapeRender)
        pLandscapeRender->Update(BoundingBox, d);
    if (updateMatAndPixCnt) UpdateMatCnt(d, BoundingBox, true);
    // Restore Solidmasks
    C4Rect SolidMaskRect = BoundingBox;
    if (pLandscapeRender)
        SolidMaskRect = pLandscapeRender->GetAffectedRect(pLandscapeRender->GetAffectedRect(SolidMaskRect));
    for (C4SolidMask * pSolid = C4SolidMask::First; pSolid; pSolid = pSolid->Next)
    {
        pSolid->Repair(SolidMaskRect);
    }
    C4SolidMask::CheckConsistency();
    if (updateMatAndPixCnt) UpdatePixCnt(d, BoundingBox);
    // update FoW
    if (pFoW)
    {
        pFoW->Invalidate(BoundingBox);
        pFoW->Ambient.UpdateFromLandscape(*d, BoundingBox);
    }
}

References C4SolidMask::CheckConsistency(), C4SolidMask::First, C4Rect::Hgt, C4Rect::Intersect(), C4SolidMask::Next, and C4Rect::Wdt.

Here is the call graph for this function:

ForPolygon()

int32_t C4Landscape::P::ForPolygon	(	C4Landscape *	d,
		int *	vtcs,
		int	length,
		const std::function< bool(int32_t, int32_t)> &	callback,
		C4MaterialList *	mats_count = nullptr,
		uint8_t	col = 0,
		uint8_t	colBkg = 0,
		uint8_t *	conversion_table = nullptr
	)

Definition at line 1216 of file C4Landscape.cpp.

{
    // Variables for polygon drawer
    int c, x1, x2, y;
    int top = INT_MAX;
    int bottom = INT_MIN;
    int *i1, *i2;
    CPolyEdge *edge, *next_edge, *edgebuf;
    CPolyEdge *active_edges = nullptr;
    CPolyEdge *inactive_edges = nullptr;
    bool use_qpb = false;
 
    // Return value
    int32_t amount = 0;
    // Poly Buf
    if (length <= QuickPolyBufSize)
    {
        edgebuf = QuickPolyBuf; use_qpb = true;
    }
    else if (!(edgebuf = new CPolyEdge[length])) { return 0; }
 
    // Fill the edge table
    edge = edgebuf;
    i1 = vtcs;
    i2 = vtcs + (length - 1) * 2;
    for (c = 0; c < length; c++)
    {
        if (i1[1] != i2[1])
        {
            fill_edge_structure(edge, i1, i2);
            if (edge->bottom >= edge->y)
            {
                if (edge->y < top)  top = edge->y;
                if (edge->bottom > bottom) bottom = edge->bottom;
                inactive_edges = add_edge(inactive_edges, edge, false);
                edge++;
            }
        }
        i2 = i1; i1 += 2;
    }
 
    // For each scanline in the polygon...
    for (c = top; c <= bottom; c++)
    {
        // Check for newly active edges
        edge = inactive_edges;
        while ((edge) && (edge->y == c))
        {
            next_edge = edge->next;
            inactive_edges = remove_edge(inactive_edges, edge);
            active_edges = add_edge(active_edges, edge, true);
            edge = next_edge;
        }
 
        // Draw horizontal line segments
        edge = active_edges;
        while ((edge) && (edge->next))
        {
            x1 = edge->x >> POLYGON_FIX_SHIFT;
            x2 = (edge->next->x + edge->next->w) >> POLYGON_FIX_SHIFT;
            y = c;
            // Fix coordinates
            if (x1 > x2) std::swap(x1, x2);
            // Set line
            if (callback)
            {
                for (int xcnt = x2 - x1 - 1; xcnt >= 0; xcnt--)
                {
                    uint8_t pix = d->GetPix(x1 + xcnt, y);
                    if (!conversion_table || conversion_table[pix])
                    {
                        int32_t mat = d->GetPixMat(pix);
                        if (callback(x1 + xcnt, y))
                            if (mats_count)
                            {
                                mats_count->Add(mat, 1);
                                amount++;
                            }
                    }
                }
            }
            else if (conversion_table)
                for (int xcnt = x2 - x1 - 1; xcnt >= 0; xcnt--)
                {
                    const uint8_t pix = conversion_table[uint8_t(d->GetPix(x1 + xcnt, y))];
                    Surface8->SetPix(x1 + xcnt, y, pix);
                    if (colBkg != Transparent) Surface8Bkg->SetPix(x1 + xcnt, y, colBkg);
                }
            else
                for (int xcnt = x2 - x1 - 1; xcnt >= 0; xcnt--)
                {
                    if (col != Transparent) Surface8->SetPix(x1 + xcnt, y, col);
                    if (colBkg != Transparent) Surface8Bkg->SetPix(x1 + xcnt, y, colBkg);
                }
            edge = edge->next->next;
        }
 
        // Update edges, sorting and removing dead ones
        edge = active_edges;
        while (edge)
        {
            next_edge = edge->next;
            if (c >= edge->bottom)
            {
                active_edges = remove_edge(active_edges, edge);
            }
            else
            {
                edge->x += edge->dx;
                while ((edge->prev) && (edge->x + edge->w / 2 < edge->prev->x + edge->prev->w / 2))
                {
                    if (edge->next) edge->next->prev = edge->prev;
                    edge->prev->next = edge->next;
                    edge->next = edge->prev;
                    edge->prev = edge->prev->prev;
                    edge->next->prev = edge;
                    if (edge->prev) edge->prev->next = edge;
                    else active_edges = edge;
                }
            }
            edge = next_edge;
        }
    }
 
    // Clear scratch memory
    if (!use_qpb) delete[] edgebuf;
 
    return amount;
}

References C4ScriptGuiWindowPropertyName::bottom, QuickPolyBuf, QuickPolyBufSize, C4ScriptGuiWindowPropertyName::top, and CPolyEdge::y.

GetBridgeMatConversion()

uint8_t * C4Landscape::P::GetBridgeMatConversion	(	const C4Landscape *	d,
		int32_t	for_material_col
	)		const

Definition at line 3864 of file C4Landscape.cpp.

{
    // safety
    int32_t for_material = d->GetPixMat(for_material_col);
    if (for_material < 0 || for_material >= MaterialMap.Num) return nullptr;
    // query map. create if not done yet
    if (!BridgeMatConversion[for_material_col])
    {
        auto conv_map = std::make_unique<uint8_t[]>(C4M_MaxTexIndex);
        for (int32_t i = 0; i < C4M_MaxTexIndex; ++i)
        {
            if ((MatDensity(for_material) >= d->GetPixDensity(i)))
            {
                // bridge pixel OK here. change pixel.
                conv_map[i] = for_material_col;
            }
            else
            {
                // bridge pixel not OK - keep current pixel
                conv_map[i] = i;
            }
        }
        BridgeMatConversion[for_material_col] = std::move(conv_map);
    }
    return BridgeMatConversion[for_material_col].get();
}

References C4M_MaxTexIndex, C4Landscape::GetPixDensity(), C4Landscape::GetPixMat(), MatDensity(), MaterialMap, and C4MaterialMap::Num.

Here is the call graph for this function:

GetMapColorIndex()

bool C4Landscape::P::GetMapColorIndex	(	const char *	szMaterial,
		const char *	szTexture,
		BYTE &	rbyCol
	)		const

Definition at line 3400 of file C4Landscape.cpp.

{
    // Sky
    if (SEqual(szMaterial, C4TLS_MatSky))
        rbyCol = 0;
    // Material-Texture
    else
    {
        rbyCol = ::TextureMap.GetIndex(szMaterial, szTexture);
        if (!rbyCol) return false;
    }
    // Found
    return true;
}

References C4TLS_MatSky, C4TextureMap::GetIndex(), SEqual(), and TextureMap.

Here is the call graph for this function:

InitBorderPix()

bool C4Landscape::P::InitBorderPix

(

)

Definition at line 2024 of file C4Landscape.cpp.

{
    assert(Width > 0);
    // Init Top-/BottomRowPix array, which determines if out-of-landscape pixels on top/bottom side of the map are solid or not
    // In case of Top-/BottomOpen=2, unit by map and not landscape to avoid runtime join sync losses
    if (!Width) return true;
    TopRowPix.clear();
    BottomRowPix.clear();
    LeftColPix.clear();
    RightColPix.clear();
    // must access Game.C4S here because Landscape.TopOpen / Landscape.BottomOpen may not be initialized yet
    // why is there a local copy of that static variable anyway?
    int32_t top_open_flag = Game.C4S.Landscape.TopOpen;
    int32_t bottom_open_flag = Game.C4S.Landscape.BottomOpen;
    if (top_open_flag == 2 && !Map) top_open_flag = 1;
    if (bottom_open_flag == 2 && !Map) bottom_open_flag = 1;
 
    // Init TopRowPix
    switch (top_open_flag)
    {
        // TopOpen=0: Top is closed
    case 0: TopRowPix.assign(Width, MCVehic); break;
        // TopOpen=2: Top is open when pixel below has sky background
    case 2:
        TopRowPix.resize(Width);
        for (int32_t x = 0; x < Width; ++x)
        {
            uint8_t map_pix = MapBkg->GetPix(x / MapZoom, 0);
            TopRowPix[x] = ((map_pix != 0) ? MCVehic : 0);
        }
        break;
        // TopOpen=1: Top is open
    default: TopRowPix.assign(Width, 0); break;
    }
 
    // Init BottomRowPix
    switch (bottom_open_flag)
    {
        // BottomOpen=0: Bottom is closed
    case 0: BottomRowPix.assign(Width, MCVehic); break;
        // BottomOpen=2: Bottom is open when pixel above has sky background
    case 2:
        BottomRowPix.resize(Width);
        for (int32_t x = 0; x < Width; ++x)
        {
            uint8_t map_pix = MapBkg->GetPix(x / MapZoom, Map->Hgt - 1);
            BottomRowPix[x] = ((map_pix != 0) ? MCVehic : 0);
        }
        break;
        // BottomOpen=1: Bottom is open
    default: BottomRowPix.assign(Width, 0); break;
    }
 
    if (Game.C4S.Landscape.AutoScanSideOpen)
    {
        // Compatibility: check both foreground and background material per
        // default, Top/BottomOpen=2-like behavior with AutoScanSideOpen=2.
        bool only_bg = Game.C4S.Landscape.AutoScanSideOpen == 2;
        LeftColPix.resize(Height);
        RightColPix.resize(Height);
        uint8_t map_pix;
        for (int32_t y = 0; y < Height; ++y)
        {
            map_pix = MapBkg->GetPix(0, y / MapZoom);
            if (!only_bg) map_pix += Map->GetPix(0, y / MapZoom);
            LeftColPix[y] = ((map_pix != 0) ? MCVehic : 0);
            map_pix = MapBkg->GetPix(Map->Wdt - 1, y / MapZoom);
            if (!only_bg) map_pix += Map->GetPix(Map->Wdt - 1, y / MapZoom);
            RightColPix[y] = ((map_pix != 0) ? MCVehic : 0);
        }
    }
    else
    {
        int32_t LeftOpen = std::min(Height, Game.C4S.Landscape.LeftOpen);
        int32_t RightOpen = std::min(Height, Game.C4S.Landscape.RightOpen);
        LeftColPix.assign(Height, MCVehic);
        RightColPix.assign(Height, MCVehic);
        for (int32_t cy = 0; cy < LeftOpen; cy++)
            LeftColPix[cy] = 0;
        for (int32_t cy = 0; cy < RightOpen; cy++)
            RightColPix[cy] = 0;
    }
 
    return true;
}

References C4SLandscape::AutoScanSideOpen, C4SLandscape::BottomOpen, C4Game::C4S, Game, C4Scenario::Landscape, C4SLandscape::LeftOpen, MCVehic, C4SLandscape::RightOpen, C4SLandscape::TopOpen, CPolyEdge::x, and CPolyEdge::y.

MapToLandscape()

bool C4Landscape::P::MapToLandscape	(	C4Landscape *	d,
		const CSurface8 &	sfcMap,
		const CSurface8 &	sfcMapBkg,
		int32_t	iMapX,
		int32_t	iMapY,
		int32_t	iMapWdt,
		int32_t	iMapHgt,
		int32_t	iOffsX = 0,
		int32_t	iOffsY = 0,
		bool	noClear = false
	)

Definition at line 2369 of file C4Landscape.cpp.

{
    assert(Surface8 && Surface8Bkg);
    // Clip to map/landscape segment
    int iMapWidth, iMapHeight, iLandscapeWidth, iLandscapeHeight;
    // Get map & landscape size
    sfcMap.GetSurfaceSize(iMapWidth, iMapHeight);
    Surface8->GetSurfaceSize(iLandscapeWidth, iLandscapeHeight);
    // Clip map segment to map size
    iMapX = Clamp<int32_t>(iMapX, 0, iMapWidth - 1); iMapY = Clamp<int32_t>(iMapY, 0, iMapHeight - 1);
    iMapWdt = Clamp<int32_t>(iMapWdt, 0, iMapWidth - iMapX); iMapHgt = Clamp<int32_t>(iMapHgt, 0, iMapHeight - iMapY);
    // No segment
    if (!iMapWdt || !iMapHgt) return true;
 
    // Get affected landscape rect
    C4Rect To;
    To.x = iMapX*MapZoom + iOffsX;
    To.y = iMapY*MapZoom + iOffsY;
    To.Wdt = iMapWdt*MapZoom;
    To.Hgt = iMapHgt*MapZoom;
 
    PrepareChange(d, To);
 
    // clear the old landscape if not supressed
    if (!noClear)
    {
        Surface8->ClearBox8Only(To.x, To.y, To.Wdt, To.Hgt);
        Surface8Bkg->ClearBox8Only(To.x, To.y, To.Wdt, To.Hgt);
    }
 
    MapToSurface(d, sfcMap, sfcMapBkg, iMapX, iMapY, iMapWdt, iMapHgt, To.x, To.y, To.Wdt, To.Hgt, iOffsX, iOffsY);
    FinishChange(d, To);
    return true;
}

References CSurface8::GetSurfaceSize(), C4Rect::Hgt, C4Rect::Wdt, C4Rect::x, and C4Rect::y.

Here is the call graph for this function:

MapToSurface()

bool C4Landscape::P::MapToSurface	(	C4Landscape *	d,
		const CSurface8 &	sfcMap,
		const CSurface8 &	sfcMapBkg,
		int32_t	iMapX,
		int32_t	iMapY,
		int32_t	iMapWdt,
		int32_t	iMapHgt,
		int32_t	iToX,
		int32_t	iToY,
		int32_t	iToWdt,
		int32_t	iToHgt,
		int32_t	iOffX,
		int32_t	iOffY
	)

Definition at line 2341 of file C4Landscape.cpp.

{
 
    // assign clipper
    Surface8->Clip(iToX, iToY, iToX + iToWdt - 1, iToY + iToHgt - 1);
    Surface8Bkg->Clip(iToX, iToY, iToX + iToWdt - 1, iToY + iToHgt - 1);
    pDraw->NoPrimaryClipper();
 
    // Enlarge map segment for chunky rim
    iMapX -= 2 + MaterialMap.max_shape_width / MapZoom;
    iMapY -= 2 + MaterialMap.max_shape_height / MapZoom;
    iMapWdt += 4 + MaterialMap.max_shape_width / MapZoom * 2;
    iMapHgt += 4 + MaterialMap.max_shape_height / MapZoom * 2;
 
    // Determine texture usage in map segment
    DWORD dwTexUsage[C4M_MaxTexIndex];
    if (!GetTexUsage(sfcMap, sfcMapBkg, iMapX, iMapY, iMapWdt, iMapHgt, dwTexUsage)) return false;
    // Texture zoom map to landscape
    if (!TexOZoom(d, sfcMap, sfcMapBkg, iMapX, iMapY, iMapWdt, iMapHgt, dwTexUsage, iOffX, iOffY)) return false;
 
    // remove clipper
    Surface8->NoClip();
    Surface8Bkg->NoClip();
 
    // success
    return true;
}

References C4M_MaxTexIndex, MaterialMap, C4MaterialMap::max_shape_height, C4MaterialMap::max_shape_width, C4Draw::NoPrimaryClipper(), and pDraw.

Here is the call graph for this function:

Mat2Pal()

bool C4Landscape::P::Mat2Pal

(

)

Definition at line 4238 of file C4Landscape.cpp.

{
    if (!Surface8 || !Surface8Bkg) return false;
    // set landscape pal
    int32_t tex;
    for (tex = 0; tex < C4M_MaxTexIndex; tex++)
    {
        const C4TexMapEntry *pTex = ::TextureMap.GetEntry(tex);
        if (!pTex || pTex->isNull())
            continue;
        // colors
        DWORD dwPix = pTex->GetPattern().PatternClr(0, 0);
        Surface8->pPal->Colors[MatTex2PixCol(tex)] = dwPix;
        Surface8Bkg->pPal->Colors[MatTex2PixCol(tex)] = dwPix;
    }
    // success
    return true;
}

References C4M_MaxTexIndex, C4TextureMap::GetEntry(), C4TexMapEntry::GetPattern(), C4TexMapEntry::isNull(), MatTex2PixCol(), C4Pattern::PatternClr(), and TextureMap.

Here is the call graph for this function:

PostFreeShape()

void C4Landscape::P::PostFreeShape	(	C4ValueArray *	dig_objects,
		C4Object *	by_object
	)

Definition at line 530 of file C4Landscape.cpp.

{
    // Do callbacks to digger and dug out objects for objects that are now dug free
    if (by_object)
    {
        for (int32_t i = 0; i < dig_objects->GetSize(); ++i)
        {
            C4Object *dig_object = dig_objects->GetItem(i).getObj();
            if (dig_object && !GBackSolid(dig_object->GetX(), dig_object->GetY()))
                if (dig_object != by_object)
                    if (!dig_object->Contained && dig_object->Status)
                    {
                        C4AulParSet pars(by_object);
                        dig_object->Call(PSF_OnDugOut, &pars);
                        if (dig_object->Status && by_object->Status)
                        {
                            C4AulParSet pars(dig_object);
                            by_object->Call(PSF_DigOutObject, &pars);
                        }
                    }
        }
    }
}

References C4PropList::Call(), C4Object::Contained, GBackSolid(), C4ValueArray::GetItem(), C4Value::getObj(), C4ValueArray::GetSize(), C4Object::GetX(), C4Object::GetY(), PSF_DigOutObject, PSF_OnDugOut, and C4PropList::Status.

Here is the call graph for this function:

PrepareChange()

void C4Landscape::P::PrepareChange	(	const C4Landscape *	d,
		const C4Rect &	BoundingBox,
		bool	updateMatCnt = true
	)

Definition at line 3914 of file C4Landscape.cpp.

{
    // move solidmasks out of the way
    C4Rect SolidMaskRect = BoundingBox;
    if (pLandscapeRender)
        SolidMaskRect = pLandscapeRender->GetAffectedRect(pLandscapeRender->GetAffectedRect(SolidMaskRect));
    for (C4SolidMask * pSolid = C4SolidMask::Last; pSolid; pSolid = pSolid->Prev)
    {
        pSolid->RemoveTemporary(SolidMaskRect);
    }
    if (updateMatCnt) UpdateMatCnt(d, BoundingBox, false);
}

References C4SolidMask::Last, and C4SolidMask::Prev.

PrepareFreeShape()

C4ValueArray * C4Landscape::P::PrepareFreeShape	(	C4Rect &	BoundingBox,
		C4Object *	by_object
	)

Definition at line 519 of file C4Landscape.cpp.

{
    // Remember any in-earth objects in area
    C4FindObjectInRect fo_inrect(BoundingBox);
    C4FindObjectOCF fo_insolid(OCF_InSolid);
    C4FindObjectLayer fo_layer(by_object ? by_object->Layer : nullptr);
    C4FindObject *fo_list[] = { &fo_inrect, &fo_insolid, &fo_layer };
    C4FindObjectAndStatic fo_srch(3, fo_list);
    return fo_srch.FindMany(::Objects, ::Objects.Sectors);
}

References C4FindObject::FindMany(), C4Object::Layer, Objects, OCF_InSolid, and C4GameObjects::Sectors.

Here is the call graph for this function:

SaveDiffInternal()

bool C4Landscape::P::SaveDiffInternal	(	const C4Landscape *	d,
		C4Group &	hGroup,
		bool	fSyncSave
	)		const

Definition at line 1742 of file C4Landscape.cpp.

{
    assert(pInitial && pInitialBkg);
    if (!pInitial || !pInitialBkg) return false;
 
    // If it shouldn't be sync-save: Clear all bytes that have not changed, i.e.
    // set them to C4M_MaxTexIndex
    bool fChanged = false, fChangedBkg = false;;
    if (!fSyncSave)
        for (int y = 0; y < Height; y++)
            for (int x = 0; x < Width; x++)
            {
                if (pInitial[y * Width + x] == Surface8->_GetPix(x, y))
                    Surface8->SetPix(x, y, C4M_MaxTexIndex);
                else
                    fChanged = true;
 
                if (pInitialBkg[y * Width + x] == Surface8Bkg->_GetPix(x, y))
                    Surface8Bkg->SetPix(x, y, C4M_MaxTexIndex);
                else
                    fChangedBkg = true;
            }
 
    if (fSyncSave || fChanged)
    {
        // Save landscape surface
        if (!Surface8->Save(Config.AtTempPath(C4CFN_TempLandscape)))
            return false;
 
        // Move temp file to group
        if (!hGroup.Move(Config.AtTempPath(C4CFN_TempLandscape),
            C4CFN_DiffLandscape))
            return false;
    }
 
    if (fSyncSave || fChangedBkg)
    {
        // Save landscape surface
        if (!Surface8Bkg->Save(Config.AtTempPath(C4CFN_TempLandscapeBkg)))
            return false;
 
        // Move temp file to group
        if (!hGroup.Move(Config.AtTempPath(C4CFN_TempLandscapeBkg),
            C4CFN_DiffLandscapeBkg))
            return false;
    }
 
    // Restore landscape pixels
    if (!fSyncSave)
        for (int y = 0; y < Height; y++)
            for (int x = 0; x < Width; x++)
            {
                if (Surface8->_GetPix(x, y) == C4M_MaxTexIndex)
                    Surface8->SetPix(x, y, pInitial[y * Width + x]);
                if (Surface8Bkg->_GetPix(x, y) == C4M_MaxTexIndex)
                    Surface8Bkg->SetPix(x, y, pInitialBkg[y * Width + x]);
            }
 
    // Save changed map, too
    if (fMapChanged && Map)
        if (!d->SaveMap(hGroup)) return false;
 
    // and textures (if changed)
    if (!d->SaveTextures(hGroup)) return false;
 
    return true;
}

References C4Config::AtTempPath(), C4CFN_DiffLandscape, C4CFN_DiffLandscapeBkg, C4CFN_TempLandscape, C4CFN_TempLandscapeBkg, C4M_MaxTexIndex, Config, C4Group::Move(), C4Landscape::SaveMap(), C4Landscape::SaveTextures(), CPolyEdge::x, and CPolyEdge::y.

Here is the call graph for this function:

SaveInternal()

bool C4Landscape::P::SaveInternal	(	const C4Landscape *	d,
		C4Group &	hGroup
	)		const

Definition at line 1701 of file C4Landscape.cpp.

{
    // Save landscape surface
    char szTempLandscape[_MAX_PATH_LEN];
    SCopy(Config.AtTempPath(C4CFN_TempLandscape), szTempLandscape);
    MakeTempFilename(szTempLandscape);
    if (!Surface8->Save(szTempLandscape))
        return false;
 
    // Move temp file to group
    if (!hGroup.Move(szTempLandscape, C4CFN_LandscapeFg))
        return false;
 
    // Same for background surface
    SCopy(Config.AtTempPath(C4CFN_TempLandscapeBkg), szTempLandscape);
    MakeTempFilename(szTempLandscape);
    if (!Surface8Bkg->Save(szTempLandscape))
        return false;
    if (!hGroup.Move(szTempLandscape, C4CFN_LandscapeBg))
        return false;
 
    // Save map
    if (fMapChanged && Map)
        if (!d->SaveMap(hGroup))
            return false;
 
    // save textures (if changed)
    if (!d->SaveTextures(hGroup))
        return false;
 
    return true;
}

References _MAX_PATH_LEN, C4Config::AtTempPath(), C4CFN_LandscapeBg, C4CFN_LandscapeFg, C4CFN_TempLandscape, C4CFN_TempLandscapeBkg, Config, MakeTempFilename(), C4Group::Move(), C4Landscape::SaveMap(), C4Landscape::SaveTextures(), and SCopy().

Here is the call graph for this function:

ShakeFreePix()

bool C4Landscape::P::ShakeFreePix	(	C4Landscape *	d,
		int32_t	tx,
		int32_t	ty
	)

Definition at line 757 of file C4Landscape.cpp.

{
    int32_t mat = d->GetMat(tx, ty);
    if (MatValid(mat))
    {
        if (::MaterialMap.Map[mat].DigFree)
        {
            d->ClearPix(tx, ty);
            ::PXS.Create(mat, itofix(tx), itofix(ty));
            // check for instable materials to start moving by the cleared space
            d->CheckInstabilityRange(tx, ty);
            return true;
        }
    }
    return false;
}

References C4Landscape::CheckInstabilityRange(), C4Landscape::ClearPix(), C4PXSSystem::Create(), C4MaterialCore::DigFree, C4Landscape::GetMat(), itofix(), C4MaterialMap::Map, MaterialMap, MatValid(), and PXS.

Here is the call graph for this function:

TexOZoom()

bool C4Landscape::P::TexOZoom	(	C4Landscape *	d,
		const CSurface8 &	sfcMap,
		const CSurface8 &	sfcMapBkg,
		int32_t	iMapX,
		int32_t	iMapY,
		int32_t	iMapWdt,
		int32_t	iMapHgt,
		DWORD *	dwpTextureUsage,
		int32_t	iToX = 0,
		int32_t	iToY = 0
	)

Definition at line 2325 of file C4Landscape.cpp.

{
    // ChunkOZoom all used textures
    for (auto iIndex : ::TextureMap.Order)
    {
        if (dwpTextureUsage[iIndex] > 0)
        {
            // ChunkOZoom map to landscape
            ChunkOZoom(d, sfcMap, sfcMapBkg, iMapX, iMapY, iMapWdt, iMapHgt, iIndex, iToX, iToY);
        }
    }
 
    // Done
    return true;
}

References C4TextureMap::Order, and TextureMap.

UpdateMatCnt()

void C4Landscape::P::UpdateMatCnt	(	const C4Landscape *	d,
		C4Rect	Rect,
		bool	fPlus
	)

Definition at line 4275 of file C4Landscape.cpp.

{
    Rect.Intersect(C4Rect(0, 0, Width, Height));
    if (!Rect.Hgt || !Rect.Wdt) return;
    // Multiplicator for changes
    const int32_t iMul = fPlus ? +1 : -1;
    // Count pixels
    for (int32_t x = 0; x < Rect.Wdt; x++)
    {
        int iHgt = 0;
        int32_t y;
        for (y = 1; y < Rect.Hgt; y++)
        {
            int32_t iMat = d->_GetMat(Rect.x + x, Rect.y + y - 1);
            // Same material? Count it.
            if (iMat == d->_GetMat(Rect.x + x, Rect.y + y))
                iHgt++;
            else
            {
                if (iMat >= 0)
                {
                    // Normal material counting
                    MatCount[iMat] += iMul * (iHgt + 1);
                    // Effective material counting enabled?
                    if (int32_t iMinHgt = ::MaterialMap.Map[iMat].MinHeightCount)
                    {
                        // First chunk? Add any material above when checking chunk height
                        int iAddedHeight = 0;
                        if (Rect.y && iHgt + 1 == y)
                            iAddedHeight = d->GetMatHeight(Rect.x + x, Rect.y - 1, -1, iMat, iMinHgt);
                        // Check the chunk height
                        if (iHgt + 1 + iAddedHeight >= iMinHgt)
                        {
                            EffectiveMatCount[iMat] += iMul * (iHgt + 1);
                            if (iAddedHeight < iMinHgt)
                                EffectiveMatCount[iMat] += iMul * iAddedHeight;
                        }
                    }
                }
                // Next chunk of material
                iHgt = 0;
            }
        }
        // Check last pixel
        int32_t iMat = d->_GetMat(Rect.x + x, Rect.y + Rect.Hgt - 1);
        if (iMat >= 0)
        {
            // Normal material counting
            MatCount[iMat] += iMul * (iHgt + 1);
            // Minimum height counting?
            if (int32_t iMinHgt = ::MaterialMap.Map[iMat].MinHeightCount)
            {
                int iAddedHeight1 = 0, iAddedHeight2 = 0;
                // Add any material above for chunk size check
                if (Rect.y && iHgt + 1 == Rect.Hgt)
                    iAddedHeight1 = d->GetMatHeight(Rect.x + x, Rect.y - 1, -1, iMat, iMinHgt);
                // Add any material below for chunk size check
                if (Rect.y + y < Height)
                    iAddedHeight2 = d->GetMatHeight(Rect.x + x, Rect.y + Rect.Hgt, 1, iMat, iMinHgt);
                // Chunk tall enough?
                if (iHgt + 1 + iAddedHeight1 + iAddedHeight2 >= ::MaterialMap.Map[iMat].MinHeightCount)
                {
                    EffectiveMatCount[iMat] += iMul * (iHgt + 1);
                    if (iAddedHeight1 < iMinHgt)
                        EffectiveMatCount[iMat] += iMul * iAddedHeight1;
                    if (iAddedHeight2 < iMinHgt)
                        EffectiveMatCount[iMat] += iMul * iAddedHeight2;
                }
            }
        }
    }
}

References C4Landscape::_GetMat(), C4Landscape::GetMatHeight(), C4Rect::Hgt, C4Rect::Intersect(), C4MaterialMap::Map, MaterialMap, C4MaterialCore::MinHeightCount, C4Rect::Wdt, CPolyEdge::x, C4Rect::x, CPolyEdge::y, and C4Rect::y.

Here is the call graph for this function:

UpdatePixCnt()

void C4Landscape::P::UpdatePixCnt	(	const C4Landscape *	d,
		const C4Rect &	Rect,
		bool	fCheck = false
	)

Definition at line 4258 of file C4Landscape.cpp.

{
    int32_t PixCntWidth = (Width + 16) / 17;
    for (int32_t y = std::max<int32_t>(0, Rect.y / 15); y < std::min<int32_t>(PixCntPitch, (Rect.y + Rect.Hgt + 14) / 15); y++)
        for (int32_t x = std::max<int32_t>(0, Rect.x / 17); x < std::min<int32_t>(PixCntWidth, (Rect.x + Rect.Wdt + 16) / 17); x++)
        {
            int iCnt = 0;
            for (int32_t x2 = x * 17; x2 < std::min<int32_t>(x * 17 + 17, Width); x2++)
                for (int32_t y2 = y * 15; y2 < std::min<int32_t>(y * 15 + 15, Height); y2++)
                    if (d->_GetDensity(x2, y2))
                        iCnt++;
            if (fCheck)
                assert(iCnt == PixCnt[x * PixCntPitch + y]);
            PixCnt[x * PixCntPitch + y] = iCnt;
        }
}

References C4Landscape::_GetDensity(), C4Rect::Hgt, iCnt, C4Rect::Wdt, CPolyEdge::x, C4Rect::x, CPolyEdge::y, and C4Rect::y.

Here is the call graph for this function:

Member Data Documentation

BottomRowPix

std::vector<uint8_t> C4Landscape::P::BottomRowPix

Definition at line 60 of file C4Landscape.cpp.

BridgeMatConversion

std::array< std::unique_ptr< uint8_t[]>, C4M_MaxTexIndex > C4Landscape::P::BridgeMatConversion

mutable

Definition at line 66 of file C4Landscape.cpp.

EffectiveMatCount

std::array<DWORD, C4MaxMaterial> C4Landscape::P::EffectiveMatCount {}

Definition at line 72 of file C4Landscape.cpp.

fMapChanged

bool C4Landscape::P::fMapChanged = false

Definition at line 81 of file C4Landscape.cpp.

Gravity

C4Real C4Landscape::P::Gravity = DefaultGravAccel

Definition at line 76 of file C4Landscape.cpp.

Height

int32_t C4Landscape::P::Height = 0

Definition at line 69 of file C4Landscape.cpp.

Referenced by ExecuteScan().

LeftColPix

std::vector<uint8_t> C4Landscape::P::LeftColPix

Definition at line 60 of file C4Landscape.cpp.

Map

std::unique_ptr<CSurface8> C4Landscape::P::Map

Definition at line 56 of file C4Landscape.cpp.

MapBkg

std::unique_ptr<CSurface8> C4Landscape::P::MapBkg

Definition at line 57 of file C4Landscape.cpp.

MapHeight

int32_t C4Landscape::P::MapHeight = 0

Definition at line 70 of file C4Landscape.cpp.

MapSeed

int32_t C4Landscape::P::MapSeed = 0

Definition at line 78 of file C4Landscape.cpp.

MapWidth

int32_t C4Landscape::P::MapWidth = 0

Definition at line 70 of file C4Landscape.cpp.

MapZoom

int32_t C4Landscape::P::MapZoom = 0

Definition at line 70 of file C4Landscape.cpp.

MatCount

std::array<DWORD, C4MaxMaterial> C4Landscape::P::MatCount {}

Definition at line 71 of file C4Landscape.cpp.

Referenced by ExecuteScan().

mode

LandscapeMode C4Landscape::P::mode = LandscapeMode::Undefined

Definition at line 68 of file C4Landscape.cpp.

Modulation

uint32_t C4Landscape::P::Modulation = 0

Definition at line 77 of file C4Landscape.cpp.

NoScan

bool C4Landscape::P::NoScan = false

Definition at line 74 of file C4Landscape.cpp.

pFoW

std::unique_ptr<C4FoW> C4Landscape::P::pFoW

Definition at line 84 of file C4Landscape.cpp.

pInitial

std::unique_ptr<BYTE[]> C4Landscape::P::pInitial

Definition at line 82 of file C4Landscape.cpp.

pInitialBkg

std::unique_ptr<BYTE[]> C4Landscape::P::pInitialBkg

Definition at line 83 of file C4Landscape.cpp.

Pix2Dens

int32_t C4Landscape::P::Pix2Dens

Definition at line 61 of file C4Landscape.cpp.

Pix2Light

bool C4Landscape::P::Pix2Light

Definition at line 62 of file C4Landscape.cpp.

Pix2Mat

int32_t C4Landscape::P::Pix2Mat

Definition at line 61 of file C4Landscape.cpp.

Pix2Place

int32_t C4Landscape::P::Pix2Place

Definition at line 61 of file C4Landscape.cpp.

PixCnt

std::vector<uint8_t> C4Landscape::P::PixCnt

Definition at line 64 of file C4Landscape.cpp.

PixCntPitch

int32_t C4Landscape::P::PixCntPitch = 0

Definition at line 63 of file C4Landscape.cpp.

pLandscapeRender

std::unique_ptr<C4LandscapeRender> C4Landscape::P::pLandscapeRender

Definition at line 58 of file C4Landscape.cpp.

pMapCreator

std::unique_ptr<C4MapCreatorS2> C4Landscape::P::pMapCreator

Definition at line 80 of file C4Landscape.cpp.

Relights

std::array<C4Rect, C4LS_MaxRelights> C4Landscape::P::Relights

Definition at line 65 of file C4Landscape.cpp.

RightColPix

std::vector<uint8_t> C4Landscape::P::RightColPix

Definition at line 60 of file C4Landscape.cpp.

ScanSpeed

int32_t C4Landscape::P::ScanSpeed = 2

Definition at line 75 of file C4Landscape.cpp.

Referenced by ExecuteScan().

ScanX

int32_t C4Landscape::P::ScanX = 0

Definition at line 75 of file C4Landscape.cpp.

Referenced by ExecuteScan().

Sky

C4Sky C4Landscape::P::Sky

Definition at line 79 of file C4Landscape.cpp.

Surface8

std::unique_ptr< CSurface8 > C4Landscape::P::Surface8

Definition at line 54 of file C4Landscape.cpp.

Surface8Bkg

std::unique_ptr<CSurface8> C4Landscape::P::Surface8Bkg

Definition at line 55 of file C4Landscape.cpp.

TopRowPix

std::vector<uint8_t> C4Landscape::P::TopRowPix

Definition at line 60 of file C4Landscape.cpp.

Width

int32_t C4Landscape::P::Width = 0

Definition at line 69 of file C4Landscape.cpp.

Referenced by ExecuteScan().

---

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

• C4Landscape.cpp
• landscape-handle.cpp