C4SolidMask Class Reference

#include <C4SolidMask.h>

Collaboration diagram for C4SolidMask:

Classes
class	DensityProvider

Public Member Functions
void	Put (bool fCauseInstability, C4TargetRect *pClipRect, bool fRestoreAttachment)
void	Remove (bool fBackupAttachment)
void	Draw (C4TargetFacet &cgo)
bool	IsPut ()
	C4SolidMask (C4Object *pForObject)
	~C4SolidMask ()
void	SetHalfVehicle (bool set)

Static Public Member Functions
static bool	CheckConsistency ()
static void	RemoveSolidMasks ()
static void	PutSolidMasks ()
static CSurface8 *	LoadMaskFromFile (class C4Group &hGroup, const char *szFilename)

Public Attributes
C4SolidMask *	Prev
C4SolidMask *	Next

Static Public Attributes
static C4SolidMask *	First = nullptr
static C4SolidMask *	Last = nullptr

Protected Member Functions
void	RemoveTemporary (C4Rect where)
void	PutTemporary (C4Rect where)
void	Repair (C4Rect where)

Protected Attributes
bool	MaskPut
int	MaskPutRotation
int	MatBuffPitch
C4Real	MaskRemovalX
int32_t	MaskRemovalY
class C4Object **	ppAttachingObjects
int	iAttachingObjectsCount
int	iAttachingObjectsCapacity
C4TargetRect	MaskPutRect
BYTE *	pSolidMaskMatBuff
BYTE	MaskMaterial
C4Object *	pForObject

Friends
class	C4Landscape
class	DensityProvider

Detailed Description

Definition at line 25 of file C4SolidMask.h.

Constructor & Destructor Documentation

C4SolidMask()

C4SolidMask::C4SolidMask

(

C4Object *

pForObject

)

Definition at line 408 of file C4SolidMask.cpp.

                                             : pForObject(pForObject)
{
    // zero fields
    MaskPut=false;
    MaskPutRotation=0;
    MaskRemovalX = Fix0;
    MaskRemovalY = 0;
    ppAttachingObjects=nullptr;
    iAttachingObjectsCount=iAttachingObjectsCapacity=0;
    MaskMaterial=MCVehic;
    // Update linked list
    Next = nullptr;
    Prev = Last;
    Last = this;
    if (Prev) Prev->Next = this;
    else First = this;
    // create mat buff to store the material replaced by the solid mask
    // the upper left corner is here the [objpos]+rot([shapexy]+[targetxy]+[realWH]/2)-maxWH/2
    MatBuffPitch = (int) sqrt(double(pForObject->SolidMask.Wdt * pForObject->SolidMask.Wdt + pForObject->SolidMask.Hgt * pForObject->SolidMask.Hgt))+1;
    if (!(pSolidMaskMatBuff= new BYTE [MatBuffPitch * MatBuffPitch] )) return;
    memset(pSolidMaskMatBuff, 0, MatBuffPitch * MatBuffPitch);
}

References First, Fix0, C4Rect::Hgt, iAttachingObjectsCapacity, iAttachingObjectsCount, Last, MaskMaterial, MaskPut, MaskPutRotation, MaskRemovalX, MaskRemovalY, MatBuffPitch, MCVehic, Next, pForObject, ppAttachingObjects, Prev, pSolidMaskMatBuff, C4Object::SolidMask, and C4Rect::Wdt.

~C4SolidMask()

C4SolidMask::~C4SolidMask

(

)

Definition at line 431 of file C4SolidMask.cpp.

{
    Remove(false);
    // Update linked list
    if (Next) Next->Prev = Prev;
    if (Prev) Prev->Next = Next;
    if (First == this) First = Next;
    if (Last == this) Last = Prev;
    delete [] pSolidMaskMatBuff;
    delete [] ppAttachingObjects;
}

References First, Last, Next, ppAttachingObjects, Prev, pSolidMaskMatBuff, and Remove().

Here is the call graph for this function:

Member Function Documentation

CheckConsistency()

bool C4SolidMask::CheckConsistency ( )

static

Definition at line 468 of file C4SolidMask.cpp.

{
    if (!SOLIDMASK_DEBUG)
        return true;
 
    C4Rect SolidMaskRect(0,0,::Landscape.GetWidth(),::Landscape.GetHeight());
    C4SolidMask *pSolid;
    for (pSolid = C4SolidMask::Last; pSolid; pSolid = pSolid->Prev)
    {
        pSolid->RemoveTemporary(SolidMaskRect);
    }
    assert(!::Landscape.GetMatCount(MVehic));
    // Restore Solidmasks
    for (pSolid = C4SolidMask::First; pSolid; pSolid = pSolid->Next)
    {
        pSolid->PutTemporary(SolidMaskRect);
    }
    return true;
}

References First, C4Landscape::GetHeight(), C4Landscape::GetMatCount(), C4Landscape::GetWidth(), Landscape, Last, MVehic, Next, Prev, PutTemporary(), RemoveTemporary(), and SOLIDMASK_DEBUG.

Referenced by C4Landscape::DoRelights(), C4Landscape::P::FinishChange(), Put(), and Remove().

Here is the call graph for this function:

Here is the caller graph for this function:

Draw()

void C4SolidMask::Draw

(

C4TargetFacet &

cgo

)

Definition at line 330 of file C4SolidMask.cpp.

{
    // only if put
    if (!MaskPut) return;
    // set topface facet
    C4Facet fct; fct.Set(pForObject->GetGraphics()->GetBitmap(), pForObject->SolidMask.x, pForObject->SolidMask.y, pForObject->SolidMask.Wdt, pForObject->SolidMask.Hgt);
    // draw it
    if (MaskPutRotation)
        fct.DrawXR(cgo.Surface, pForObject->GetX()+pForObject->Shape.x+cgo.X-cgo.TargetX+pForObject->SolidMask.tx, pForObject->GetY()+pForObject->Shape.y+cgo.Y-cgo.TargetY+pForObject->SolidMask.ty, fct.Wdt, fct.Hgt, 0, 0, MaskPutRotation);
    else
        fct.DrawX(cgo.Surface, pForObject->GetX()+pForObject->Shape.x+cgo.X-cgo.TargetX+pForObject->SolidMask.tx, pForObject->GetY()+pForObject->Shape.y+cgo.Y-cgo.TargetY+pForObject->SolidMask.ty, fct.Wdt, fct.Hgt, 0, 0);
}

References C4Facet::DrawX(), C4Facet::DrawXR(), C4DefGraphics::GetBitmap(), C4Object::GetGraphics(), C4Object::GetX(), C4Object::GetY(), C4Facet::Hgt, C4Rect::Hgt, MaskPut, MaskPutRotation, pForObject, C4Facet::Set(), C4Object::Shape, C4Object::SolidMask, C4Facet::Surface, C4TargetFacet::TargetX, C4TargetFacet::TargetY, C4TargetRect::tx, C4TargetRect::ty, C4Facet::Wdt, C4Rect::Wdt, C4Facet::X, C4Rect::x, C4Facet::Y, and C4Rect::y.

Referenced by C4Object::DrawSolidMask().

Here is the call graph for this function:

Here is the caller graph for this function:

IsPut()

bool C4SolidMask::IsPut ( )

inline

Definition at line 80 of file C4SolidMask.h.

{ return MaskPut; }

References MaskPut.

LoadMaskFromFile()

CSurface8 * C4SolidMask::LoadMaskFromFile ( class C4Group &  hGroup, const char *  szFilename  )

static

Definition at line 488 of file C4SolidMask.cpp.

{
    // Construct SolidMask surface from PNG bitmap:
    // All pixels that are more than 50% transparent are not solid
    CPNGFile png;
    StdBuf png_buf;
    if (!hGroup.LoadEntry(szFilename, &png_buf)) return nullptr; // error messages done by caller
    if (!png.Load((BYTE*)png_buf.getMData(), png_buf.getSize())) return nullptr;
    CSurface8 *result = new CSurface8(png.iWdt, png.iHgt);
    for (size_t y=0u; y<png.iHgt; ++y)
        for (size_t x=0u; x<png.iWdt; ++x)
            result->SetPix(x,y,((png.GetPix(x,y)>>24)<128) ? 0x00 : 0xff);
    return result;
}

References StdBuf::getMData(), CPNGFile::GetPix(), StdBuf::getSize(), CPNGFile::iHgt, CPNGFile::iWdt, CPNGFile::Load(), C4Group::LoadEntry(), and CSurface8::SetPix().

Here is the call graph for this function:

Put()

void C4SolidMask::Put	(	bool	fCauseInstability,
		C4TargetRect *	pClipRect,
		bool	fRestoreAttachment
	)

Definition at line 32 of file C4SolidMask.cpp.

{
    // If not put, put mask to background,
    // storing background pixels in cSolidMask.
 
    // No mask
    if (!pForObject || !pForObject->Def || !pForObject->Def->pSolidMask || !pSolidMaskMatBuff) { iAttachingObjectsCount = 0; return; }
    // Contained
    if (pForObject->Contained) { iAttachingObjectsCount = 0; return; }
    // Mask is put
    if (fCauseInstability) CheckConsistency();
 
    bool RegularPut;
    if (!pClipRect)
    {
        // Regular Put: Update MaskPutRect and MaskPutRotation
        MaskPutRotation = pForObject->GetR();
        pClipRect = &MaskPutRect;
        RegularPut = true;
    }
    else
    {
        // Reput by C4SolidMask::Remove
        // Don't change MaskPutRotation or MaskPutRect
        // Intersect ClipRect with the MaskPutRect
        if (!pClipRect->ClipBy(MaskPutRect)) return;
        RegularPut = false;
    }
    // Get mask surface
    CSurface8 *pSolidMask = pForObject->Def->pSolidMask;
    // Put mask pixels
    int xcnt,ycnt,iTx,iTy;
    BYTE byPixel;
    // not rotated?
    if (!MaskPutRotation)
    {
        // calc put rect
        if (RegularPut)
        {
            int ox, oy;
            ox = pForObject->GetX() + pForObject->Def->Shape.x + pForObject->SolidMask.tx;
            oy = pForObject->GetY() + pForObject->Def->Shape.y + pForObject->SolidMask.ty;
            MaskPutRect.x = ox;
            if (MaskPutRect.x < 0) { MaskPutRect.tx = -MaskPutRect.x; MaskPutRect.x = 0; }
            else MaskPutRect.tx = 0;
            MaskPutRect.y = oy;
            if (MaskPutRect.y < 0) { MaskPutRect.ty = -MaskPutRect.y; MaskPutRect.y = 0; }
            else MaskPutRect.ty = 0;
            MaskPutRect.Wdt = std::min<int32_t>(ox + pForObject->SolidMask.Wdt, ::Landscape.GetWidth()) - MaskPutRect.x;
            MaskPutRect.Hgt = std::min<int32_t>(oy + pForObject->SolidMask.Hgt, ::Landscape.GetHeight()) - MaskPutRect.y;
        }
        // fill rect with mask
        for (ycnt=0; ycnt<pClipRect->Hgt; ++ycnt)
        {
            BYTE *pPix=pSolidMask->Bits + (ycnt+pClipRect->ty+pForObject->SolidMask.y)*pSolidMask->Pitch + pClipRect->tx + pForObject->SolidMask.x;
            for (xcnt=0; xcnt<pClipRect->Wdt; ++xcnt,++pPix)
            {
                if (*pPix)
                {
                    // solid mask present here
                    // calc position in landscape
                    iTx=pClipRect->x+xcnt; iTy=pClipRect->y+ycnt;
                    // is background mat to be stored? always do this in the given rect
                    if (!MaskPut)
                    {
                        // get background pixel
                        byPixel=::Landscape.GetPix(iTx,iTy);
                        // store it. If MCVehic, also store in initial put, but won't be used in restore
                        // do not overwrite current value in re-put issued by SolidMask-remover
                        if (!IsSomeVehicle(byPixel) || RegularPut)
                            pSolidMaskMatBuff[(ycnt+pClipRect->ty)*MatBuffPitch+xcnt+pClipRect->tx]=byPixel;
                    }
                    // and set mask
                    ::Landscape.SetPix2(iTx,iTy,MaskMaterial,::Landscape.Transparent);
                }
                else
                    // no SolidMask: mark buffer as unused here
                    if (!MaskPut)
                        pSolidMaskMatBuff[(ycnt+pClipRect->ty)*MatBuffPitch+xcnt+pClipRect->tx]=MCVehic;
            }
        }
    }
    else
    {
        // calc matrix for given rotation
        C4Real Ma1 = Cos(itofix(-MaskPutRotation)), Ma2 = -Sin(itofix(-MaskPutRotation)),
                    Mb1 = Sin(itofix(-MaskPutRotation)), Mb2 = Cos(itofix(-MaskPutRotation));
        // get upper-left corner of landscape copy rect
        int centerx = pForObject->Def->Shape.x + pForObject->SolidMask.tx + pForObject->SolidMask.Wdt / 2;
        int centery = pForObject->Def->Shape.y + pForObject->SolidMask.ty + pForObject->SolidMask.Hgt / 2;
        int xstart = pForObject->GetX() + fixtoi(Ma1 * itofix(centerx) - Ma2 * itofix(centery)) - MatBuffPitch / 2;
        int ystart = pForObject->GetY() + fixtoi(-Mb1 * itofix(centerx) + Mb2 * itofix(centery)) - MatBuffPitch / 2;
        // store put rect
        if (RegularPut)
        {
            MaskPutRect.x = xstart;
            if (MaskPutRect.x < 0) { MaskPutRect.tx = -MaskPutRect.x; MaskPutRect.Wdt = MaskPutRect.x; MaskPutRect.x = 0; }
            else { MaskPutRect.tx = 0; MaskPutRect.Wdt = 0; }
            MaskPutRect.y = ystart;
            if (MaskPutRect.y < 0) { MaskPutRect.ty = -MaskPutRect.y; MaskPutRect.Hgt = MaskPutRect.y; MaskPutRect.y = 0; }
            else { MaskPutRect.ty = 0; MaskPutRect.Hgt = 0; }
            MaskPutRect.Wdt = std::min<int32_t>(xstart + MatBuffPitch, ::Landscape.GetWidth()) - MaskPutRect.x;
            MaskPutRect.Hgt = std::min<int32_t>(ystart + MatBuffPitch, ::Landscape.GetHeight()) - MaskPutRect.y;
        }
        // go through clipping rect
        const C4Real y0 = itofix(pClipRect->ty - MatBuffPitch/2);
        const C4Real x0 = itofix(pClipRect->tx - MatBuffPitch/2);
        iTy=pClipRect->y;
        int32_t w = pForObject->SolidMask.Wdt;
        int32_t h = pForObject->SolidMask.Hgt;
        int32_t mx0 = pForObject->SolidMask.x;
        int32_t my0 = pForObject->SolidMask.y;
        C4Real ya = y0 * Ma2;
        C4Real yb = y0 * Mb2;
        for (ycnt = 0; ycnt < pClipRect->Hgt; ycnt++)
        {
            iTx=pClipRect->x;
            int i = (ycnt + pClipRect->ty) * MatBuffPitch + pClipRect->tx;
            C4Real xa = x0 * Ma1;
            C4Real xb = x0 * Mb1;
            for (xcnt = 0; xcnt < pClipRect->Wdt; xcnt++)
            {
                // calc position in solidmask buffer
                int32_t iMx = fixtoi(xa + ya) + w / 2;
                int32_t iMy = fixtoi(xb + yb) + h / 2;
                // in bounds? and solidmask?
                if (iMx >= 0 && iMy >= 0 && iMx < w && iMy < h && pSolidMask->_GetPix(iMx+mx0, iMy+my0))
                {
                    // is background mat to be stored?
                    if (!MaskPut)
                    {
                        // get background pixel
                        byPixel=::Landscape._GetPix(iTx,iTy);
                        // store it. If MCVehic, also store in initial put, but won't be used in restore
                        // do not overwrite current value in re-put issued by SolidMask-remover
                        if (!IsSomeVehicle(byPixel) || RegularPut)
                            pSolidMaskMatBuff[i + xcnt] = byPixel;
                    }
                    // set mask pix
                    ::Landscape.SetPix2(iTx, iTy, MaskMaterial, ::Landscape.Transparent);
                }
                else if (!MaskPut)
                    // mark pix as unused in buf
                    pSolidMaskMatBuff[i+xcnt] = MCVehic;
                xa += Ma1; xb += Mb1;
                ++iTx;
            }
            ya += Ma2; yb += Mb2;
            ++iTy;
        }
    }
    // Store mask put status
    MaskPut=true;
    // restore attached object positions if moved
    if (fRestoreAttachment && iAttachingObjectsCount)
    {
        C4Real dx = pForObject->GetFixedX() - MaskRemovalX;
        int32_t dy = pForObject->GetY() - MaskRemovalY;
        if (dx != Fix0 || dy != 0)
            for (int i = 0; i < iAttachingObjectsCount; ++i)
            {
                C4Object *pObj = ppAttachingObjects[i];
                if (pObj->IsMoveableBySolidMask(pForObject->GetSolidMaskPlane()))
                    if (!pObj->Shape.ContactCheck(fixtoi(pObj->GetFixedX()+dx), fixtoi(pObj->GetFixedY()+dy)))
                        if (pObj->iLastAttachMovementFrame != Game.FrameCounter)
                        {
                            pObj->iLastAttachMovementFrame = Game.FrameCounter;
                            pObj->MovePosition(dx, itofix(dy));
                        }
            }
        iAttachingObjectsCount = 0;
    }
 
    if (fCauseInstability) CheckConsistency();
}

References C4Landscape::_GetPix(), CSurface8::Bits, CheckConsistency(), C4TargetRect::ClipBy(), C4Shape::ContactCheck(), C4Object::Contained, Cos(), C4Object::Def, Fix0, fixtoi(), C4Game::FrameCounter, Game, C4Object::GetFixedX(), C4Object::GetFixedY(), C4Landscape::GetHeight(), C4Landscape::GetPix(), C4Object::GetR(), C4Object::GetSolidMaskPlane(), C4Landscape::GetWidth(), C4Object::GetX(), C4Object::GetY(), C4Rect::Hgt, iAttachingObjectsCount, C4Object::iLastAttachMovementFrame, C4Object::IsMoveableBySolidMask(), IsSomeVehicle(), itofix(), Landscape, MaskMaterial, MaskPut, MaskPutRect, MaskPutRotation, MaskRemovalX, MaskRemovalY, MatBuffPitch, MCVehic, C4Object::MovePosition(), pForObject, CSurface8::Pitch, ppAttachingObjects, C4Def::pSolidMask, pSolidMaskMatBuff, C4Landscape::SetPix2(), C4Def::Shape, C4Object::Shape, Sin(), C4Object::SolidMask, C4Landscape::Transparent, C4TargetRect::tx, C4TargetRect::ty, C4Rect::Wdt, C4Rect::x, and C4Rect::y.

Referenced by C4Object::UpdateSolidMask().

Here is the call graph for this function:

Here is the caller graph for this function:

PutSolidMasks()

void C4SolidMask::PutSolidMasks ( )

static

Definition at line 453 of file C4SolidMask.cpp.

{
    C4Rect SolidMaskRect(0,0,::Landscape.GetWidth(),::Landscape.GetHeight());
    C4SolidMask *pSolid;
    // Restore Solidmasks
    for (pSolid = C4SolidMask::First; pSolid; pSolid = pSolid->Next)
    {
        pSolid->PutTemporary(SolidMaskRect);
    }
}

References First, C4Landscape::GetHeight(), C4Landscape::GetWidth(), Landscape, Next, and PutTemporary().

Referenced by C4Game::ReloadDef(), C4Landscape::Save(), and C4Landscape::SaveDiff().

Here is the call graph for this function:

Here is the caller graph for this function:

PutTemporary()

void C4SolidMask::PutTemporary ( C4Rect  where )

protected

Definition at line 365 of file C4SolidMask.cpp.

{
    if (!MaskPut || !pSolidMaskMatBuff) return;
    where.Intersect(MaskPutRect);
    // reput vehicle pixels
    for (int y = where.y; y < where.y + where.Hgt; ++y)
    {
        for (int x = where.x; x < where.x + where.Wdt; ++x)
        {
            BYTE *pPix = pSolidMaskMatBuff + (y - MaskPutRect.y + MaskPutRect.ty) * MatBuffPitch + x - MaskPutRect.x + MaskPutRect.tx;
            // only if mask was used here
            if (!IsSomeVehicle(*pPix))
            {
                // put
                assert(::Landscape.GetPix(x,y)==*pPix);
                ::Landscape._SetPix2Tmp(x, y, MaskMaterial, ::Landscape.Transparent);
            }
        }
    }
}

References C4Landscape::_SetPix2Tmp(), C4Landscape::GetPix(), C4Rect::Hgt, C4Rect::Intersect(), IsSomeVehicle(), Landscape, MaskMaterial, MaskPut, MaskPutRect, MatBuffPitch, pSolidMaskMatBuff, C4Landscape::Transparent, C4TargetRect::tx, C4TargetRect::ty, C4Rect::Wdt, C4Rect::x, and C4Rect::y.

Referenced by CheckConsistency(), C4Landscape::DoRelights(), and PutSolidMasks().

Here is the call graph for this function:

Here is the caller graph for this function:

Remove()

void C4SolidMask::Remove

(

bool

fBackupAttachment

)

Definition at line 241 of file C4SolidMask.cpp.

{
    // If put, restore background pixels from buffer
 
    // Not put
    if (!MaskPut || !pSolidMaskMatBuff) return;
 
    CheckConsistency();
 
    // reput background pixels
    for (int ycnt=0; ycnt<MaskPutRect.Hgt; ++ycnt)
    {
        BYTE *pPix=pSolidMaskMatBuff+(ycnt+MaskPutRect.ty)*MatBuffPitch+MaskPutRect.tx;
        for (int xcnt=0; xcnt<MaskPutRect.Wdt; ++xcnt,++pPix)
            // only if mask was used here
            if (*pPix != MCVehic)
            {
                // calc position in landscape
                int iTx=MaskPutRect.x+xcnt; int iTy=MaskPutRect.y+ycnt;
                // restore pixel here
                // The pPix-check ensures that only pixels that hads been overwritten by this SolidMask are restored
                // Non-SolidMask-pixels should not happen here, because all relevant landscape change routines should
                // temp remove SolidMasks before
                assert(IsSomeVehicle(::Landscape._GetPix(iTx,iTy)));
                if (IsSomeVehicle(::Landscape._GetPix(iTx, iTy)))
                    ::Landscape._SetPix2(iTx, iTy, *pPix, ::Landscape.Transparent);
                // Instability
                ::Landscape.CheckInstabilityRange(iTx,iTy);
            }
    }
    // Mask not put flag
    MaskPut=false;
    // update surrounding masks in that range
    C4TargetRect ClipRect;
    for (C4SolidMask *pSolid = C4SolidMask::Last; pSolid; pSolid = pSolid->Prev)
        if (pSolid->MaskPut) if (pSolid->MaskPutRect.Overlap(MaskPutRect))
            {
                // set clipping rect for all calls, since they may modify it
                ClipRect.Set(MaskPutRect.x, MaskPutRect.y, MaskPutRect.Wdt, MaskPutRect.Hgt, 0, 0);
                // doubled solidmask-pixels have just been removed in the clipped area!
                pSolid->MaskPut = false;
                // re-put the solidmask
                pSolid->Put(false, &ClipRect, false);
            }
 
    // backup attachment if desired: Backup old pos and all objects that attach to or lie on the SolidMask
    if (fBackupAttachment)
    {
        MaskRemovalX = pForObject->GetFixedX();
        MaskRemovalY = pForObject->GetY();
        iAttachingObjectsCount = 0;
        // Search in area slightly larger than SolidMask because objects might have vertices slightly outside their shape
        C4LArea SolidArea(&::Objects.Sectors, MaskPutRect.x-1, MaskPutRect.y-4, MaskPutRect.Wdt+2, MaskPutRect.Hgt+2);
        C4LSector *pSct;
        for (C4ObjectList *pLst=SolidArea.FirstObjectShapes(&pSct); pLst; pLst=SolidArea.NextObjectShapes(pLst, &pSct))
            for (C4Object *pObj : *pLst)
                if (pObj && pObj != pForObject && pObj->IsMoveableBySolidMask(pForObject->GetSolidMaskPlane()) && !pObj->Shape.CheckContact(pObj->GetX(),pObj->GetY()))
                {
                    // avoid duplicate that may be found due to sector overlaps
                    bool has_dup = false;
                    for (int32_t i_dup = 0; i_dup < iAttachingObjectsCount; ++i_dup)
                        if (ppAttachingObjects[i_dup] == pObj)
                        {
                            has_dup = true;
                            break;
                        }
                    if (has_dup) continue;
                    // check for any contact to own SolidMask - attach-directions, bottom - "stuck" (CNAT_Center) is ignored, because that causes problems with things being stuck in basements :(
                    int iVtx = 0;
                    for (; iVtx < pObj->Shape.VtxNum; ++iVtx)
                        if (pObj->Shape.GetVertexContact(iVtx, pObj->Action.t_attach | CNAT_Bottom, pObj->GetX(), pObj->GetY(), DensityProvider(*this)))
                            break;
                    if (iVtx == pObj->Shape.VtxNum) continue; // no contact
                    // contact: Add object to list
                    if (iAttachingObjectsCapacity == iAttachingObjectsCount)
                    {
                        iAttachingObjectsCapacity += 4;
                        C4Object **ppNewAttachingObjects = new C4Object *[iAttachingObjectsCapacity];
                        if (iAttachingObjectsCount) memcpy(ppNewAttachingObjects, ppAttachingObjects, sizeof(C4Object *) * iAttachingObjectsCount);
                        delete [] ppAttachingObjects;
                        ppAttachingObjects = ppNewAttachingObjects;
                    }
                    ppAttachingObjects[iAttachingObjectsCount++] = pObj;
                }
    }
 
    CheckConsistency();
}

References C4Landscape::_GetPix(), C4Landscape::_SetPix2(), CheckConsistency(), C4Landscape::CheckInstabilityRange(), CNAT_Bottom, C4LArea::FirstObjectShapes(), C4Object::GetFixedX(), C4Object::GetSolidMaskPlane(), C4Object::GetY(), C4Rect::Hgt, iAttachingObjectsCapacity, iAttachingObjectsCount, C4Object::IsMoveableBySolidMask(), IsSomeVehicle(), Landscape, Last, MaskPut, MaskPutRect, MaskRemovalX, MaskRemovalY, MatBuffPitch, MCVehic, C4LArea::NextObjectShapes(), Objects, pForObject, ppAttachingObjects, Prev, pSolidMaskMatBuff, C4GameObjects::Sectors, C4TargetRect::Set(), C4Landscape::Transparent, C4TargetRect::tx, C4TargetRect::ty, C4Rect::Wdt, C4Rect::x, and C4Rect::y.

Referenced by C4Object::UpdateSolidMask(), and ~C4SolidMask().

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveSolidMasks()

void C4SolidMask::RemoveSolidMasks ( )

static

Definition at line 443 of file C4SolidMask.cpp.

{
    C4Rect SolidMaskRect(0,0,::Landscape.GetWidth(),::Landscape.GetHeight());
    C4SolidMask *pSolid;
    for (pSolid = C4SolidMask::Last; pSolid; pSolid = pSolid->Prev)
    {
        pSolid->RemoveTemporary(SolidMaskRect);
    }
}

References C4Landscape::GetHeight(), C4Landscape::GetWidth(), Landscape, Last, Prev, and RemoveTemporary().

Referenced by C4Game::ReloadDef(), C4Landscape::Save(), and C4Landscape::SaveDiff().

Here is the call graph for this function:

Here is the caller graph for this function:

RemoveTemporary()

void C4SolidMask::RemoveTemporary ( C4Rect  where )

protected

Definition at line 344 of file C4SolidMask.cpp.

{
    if (!MaskPut || !pSolidMaskMatBuff) return;
    where.Intersect(MaskPutRect);
    // reput background pixels
    for (int y = where.y; y < where.y + where.Hgt; ++y)
    {
        for (int x = where.x; x < where.x + where.Wdt; ++x)
        {
            BYTE *pPix = pSolidMaskMatBuff + (y - MaskPutRect.y + MaskPutRect.ty) * MatBuffPitch + x - MaskPutRect.x + MaskPutRect.tx;
            // only if mask was used here
            if (!IsSomeVehicle(*pPix)) //
            {
                // restore
                assert(IsSomeVehicle(::Landscape.GetPix(x,y)));
                ::Landscape._SetPix2Tmp(x, y, *pPix, ::Landscape.Transparent);
            }
        }
    }
}

References C4Landscape::_SetPix2Tmp(), C4Landscape::GetPix(), C4Rect::Hgt, C4Rect::Intersect(), IsSomeVehicle(), Landscape, MaskPut, MaskPutRect, MatBuffPitch, pSolidMaskMatBuff, C4Landscape::Transparent, C4TargetRect::tx, C4TargetRect::ty, C4Rect::Wdt, C4Rect::x, and C4Rect::y.

Referenced by CheckConsistency(), C4Landscape::DoRelights(), and RemoveSolidMasks().

Here is the call graph for this function:

Here is the caller graph for this function:

Repair()

void C4SolidMask::Repair ( C4Rect  where )

protected

Definition at line 386 of file C4SolidMask.cpp.

{
    if (!MaskPut || !pSolidMaskMatBuff) return;
    where.Intersect(MaskPutRect);
    // reput vehicle pixels
    for (int y = where.y; y < where.y + where.Hgt; ++y)
    {
        for (int x = where.x; x < where.x + where.Wdt; ++x)
        {
            BYTE *pPix = pSolidMaskMatBuff + (y - MaskPutRect.y + MaskPutRect.ty) * MatBuffPitch + x - MaskPutRect.x + MaskPutRect.tx;
            // only if mask was used here
            if (!IsSomeVehicle(*pPix))
            {
                // record changed landscape in MatBuff
                *pPix = ::Landscape.GetPix(x,y);
                // put
                ::Landscape.SetPix2(x, y, MaskMaterial, ::Landscape.Transparent);
            }
        }
    }
}

References C4Landscape::GetPix(), C4Rect::Hgt, C4Rect::Intersect(), IsSomeVehicle(), Landscape, MaskMaterial, MaskPut, MaskPutRect, MatBuffPitch, pSolidMaskMatBuff, C4Landscape::SetPix2(), C4Landscape::Transparent, C4TargetRect::tx, C4TargetRect::ty, C4Rect::Wdt, C4Rect::x, and C4Rect::y.

Here is the call graph for this function:

SetHalfVehicle()

void C4SolidMask::SetHalfVehicle

(

bool

set

)

Definition at line 503 of file C4SolidMask.cpp.

{
    MaskMaterial = set ? MCHalfVehic : MCVehic;
    // TODO: Redraw
}

References MaskMaterial, MCHalfVehic, and MCVehic.

Referenced by C4Object::SetHalfVehicleSolidMask().

Here is the caller graph for this function:

Friends And Related Function Documentation

C4Landscape

friend class C4Landscape

friend

Definition at line 66 of file C4SolidMask.h.

DensityProvider

friend class DensityProvider

friend

Definition at line 67 of file C4SolidMask.h.

Member Data Documentation

First

C4SolidMask * C4SolidMask::First = nullptr

static

Definition at line 71 of file C4SolidMask.h.

Referenced by C4SolidMask(), CheckConsistency(), C4Landscape::DoRelights(), C4Landscape::P::FinishChange(), PutSolidMasks(), and ~C4SolidMask().

iAttachingObjectsCapacity

int C4SolidMask::iAttachingObjectsCapacity

protected

Definition at line 38 of file C4SolidMask.h.

Referenced by C4SolidMask(), and Remove().

iAttachingObjectsCount

int C4SolidMask::iAttachingObjectsCount

protected

Definition at line 38 of file C4SolidMask.h.

Referenced by C4SolidMask(), Put(), and Remove().

Last

C4SolidMask * C4SolidMask::Last = nullptr

static

Definition at line 72 of file C4SolidMask.h.

Referenced by C4SolidMask(), CheckConsistency(), C4Landscape::DoRelights(), C4Landscape::P::PrepareChange(), Remove(), RemoveSolidMasks(), and ~C4SolidMask().

MaskMaterial

BYTE C4SolidMask::MaskMaterial

protected

Definition at line 44 of file C4SolidMask.h.

Referenced by C4SolidMask(), Put(), PutTemporary(), Repair(), and SetHalfVehicle().

MaskPut

bool C4SolidMask::MaskPut

protected

Definition at line 28 of file C4SolidMask.h.

Referenced by C4SolidMask(), Draw(), IsPut(), Put(), PutTemporary(), Remove(), RemoveTemporary(), and Repair().

MaskPutRect

C4TargetRect C4SolidMask::MaskPutRect

protected

Definition at line 40 of file C4SolidMask.h.

Referenced by C4SolidMask::DensityProvider::GetDensity(), Put(), PutTemporary(), Remove(), RemoveTemporary(), and Repair().

MaskPutRotation

int C4SolidMask::MaskPutRotation

protected

Definition at line 29 of file C4SolidMask.h.

Referenced by C4SolidMask(), Draw(), C4SolidMask::DensityProvider::GetDensity(), and Put().

MaskRemovalX

C4Real C4SolidMask::MaskRemovalX

protected

Definition at line 34 of file C4SolidMask.h.

Referenced by C4SolidMask(), Put(), and Remove().

MaskRemovalY

int32_t C4SolidMask::MaskRemovalY

protected

Definition at line 35 of file C4SolidMask.h.

Referenced by C4SolidMask(), Put(), and Remove().

MatBuffPitch

int C4SolidMask::MatBuffPitch

protected

Definition at line 30 of file C4SolidMask.h.

Referenced by C4SolidMask(), C4SolidMask::DensityProvider::GetDensity(), Put(), PutTemporary(), Remove(), RemoveTemporary(), and Repair().

Next

C4SolidMask* C4SolidMask::Next

Definition at line 74 of file C4SolidMask.h.

Referenced by C4SolidMask(), CheckConsistency(), C4Landscape::DoRelights(), C4Landscape::P::FinishChange(), PutSolidMasks(), and ~C4SolidMask().

pForObject

C4Object* C4SolidMask::pForObject

protected

Definition at line 46 of file C4SolidMask.h.

Referenced by C4SolidMask(), Draw(), C4SolidMask::DensityProvider::GetDensity(), Put(), and Remove().

ppAttachingObjects

class C4Object** C4SolidMask::ppAttachingObjects

protected

Definition at line 37 of file C4SolidMask.h.

Referenced by C4SolidMask(), Put(), Remove(), and ~C4SolidMask().

Prev

C4SolidMask* C4SolidMask::Prev

Definition at line 73 of file C4SolidMask.h.

Referenced by C4SolidMask(), CheckConsistency(), C4Landscape::DoRelights(), C4Landscape::P::PrepareChange(), Remove(), RemoveSolidMasks(), and ~C4SolidMask().

pSolidMaskMatBuff

BYTE* C4SolidMask::pSolidMaskMatBuff

protected

Definition at line 42 of file C4SolidMask.h.

Referenced by C4SolidMask(), C4SolidMask::DensityProvider::GetDensity(), Put(), PutTemporary(), Remove(), RemoveTemporary(), Repair(), and ~C4SolidMask().

---

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

• C4SolidMask.h
• C4SolidMask.cpp