C4PXSSystem Class Reference

#include <C4PXS.h>

Collaboration diagram for C4PXSSystem:

Public Member Functions
	C4PXSSystem ()
	~C4PXSSystem ()
void	Default ()
void	Clear ()
void	Execute ()
void	Draw (C4TargetFacet &cgo)
void	Cast (int32_t mat, int32_t num, int32_t tx, int32_t ty, int32_t level)
bool	Create (int32_t mat, C4Real ix, C4Real iy, C4Real ixdir=Fix0, C4Real iydir=Fix0)
bool	Load (C4Group &hGroup)
bool	Save (C4Group &hGroup)
int32_t	GetCount () const
int32_t	GetCount (int32_t mat) const
int32_t	GetCount (int32_t mat, int32_t x, int32_t y, int32_t wdt, int32_t hgt) const

Public Attributes
size_t	Count

Protected Member Functions
C4PXS *	New ()

Protected Attributes
C4PXS	PXS [PXSMax]

Detailed Description

Definition at line 38 of file C4PXS.h.

Constructor & Destructor Documentation

C4PXSSystem()

C4PXSSystem::C4PXSSystem

(

)

Definition at line 148 of file C4PXS.cpp.

{
    Default();
}

References Default().

Here is the call graph for this function:

~C4PXSSystem()

C4PXSSystem::~C4PXSSystem

(

)

Definition at line 153 of file C4PXS.cpp.

{
    Clear();
}

References Clear().

Here is the call graph for this function:

Member Function Documentation

Cast()

void C4PXSSystem::Cast	(	int32_t	mat,
		int32_t	num,
		int32_t	tx,
		int32_t	ty,
		int32_t	level
	)

Definition at line 309 of file C4PXS.cpp.

{
    int32_t cnt;
    for (cnt=0; cnt<num; cnt++)
    {
        // Must do these calculation steps separately, because the order of
        // invokations of Random() is not defined if they're used as parameters
        C4Real xdir = itofix(Random(level+1)-level/2); xdir/=10;
        C4Real ydir = itofix(Random(level+1)-level); ydir/=10;
        Create(mat,
               itofix(tx),itofix(ty),
               xdir,
               ydir);
    }
}

References Create(), itofix(), and Random().

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

Here is the call graph for this function:

Here is the caller graph for this function:

Clear()

void C4PXSSystem::Clear

(

)

Definition at line 163 of file C4PXS.cpp.

{
    Count=0;
}

References Count.

Referenced by C4Game::Clear(), Load(), and ~C4PXSSystem().

Here is the caller graph for this function:

Create()

bool C4PXSSystem::Create	(	int32_t	mat,
		C4Real	ix,
		C4Real	iy,
		C4Real	ixdir = Fix0,
		C4Real	iydir = Fix0
	)

Definition at line 175 of file C4PXS.cpp.

{
    C4PXS *pxp;
    if (!MatValid(mat)) return false;
    if (!(pxp=New())) return false;
    pxp->Mat=mat;
    pxp->x=ix; pxp->y=iy;
    pxp->xdir=ixdir; pxp->ydir=iydir;
    return true;
}

References C4PXS::Mat, MatValid(), New(), C4PXS::x, C4PXS::xdir, C4PXS::y, and C4PXS::ydir.

Referenced by Cast(), C4Landscape::CheckInstability(), C4Landscape::InsertMaterial(), C4MaterialMap::mrfConvert(), and C4Landscape::P::ShakeFreePix().

Here is the call graph for this function:

Here is the caller graph for this function:

Default()

void C4PXSSystem::Default

(

)

Definition at line 158 of file C4PXS.cpp.

{
    Count=0;
}

References Count.

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

Here is the caller graph for this function:

Draw()

void C4PXSSystem::Draw

(

C4TargetFacet &

cgo

)

Definition at line 198 of file C4PXS.cpp.

{
    // Draw PXS in this region
    C4Rect VisibleRect(cgo.TargetX, cgo.TargetY, cgo.Wdt, cgo.Hgt);
    VisibleRect.Enlarge(20);
 
    // Go through all PXS and build vertex arrays. The vertex arrays are
    // then submitted to the GL in one go.
    std::vector<C4BltVertex> pixVtx;
    std::vector<C4BltVertex> lineVtx;
    std::map<int, std::vector<C4BltVertex> > bltVtx;
    // TODO: reserve some space to avoid too many allocations
    // TODO: keep vertex mem allocated between draw invocations
 
    float cgox = cgo.X - cgo.TargetX, cgoy = cgo.Y - cgo.TargetY;
    // First pass: draw simple PXS (lines/pixels)
    for (size_t i = 0; i < Count; i++)
    {
        C4PXS *pxp = &PXS[i];
        if (pxp->Mat != MNone && VisibleRect.Contains(fixtoi(pxp->x), fixtoi(pxp->y)))
        {
            C4Material *pMat = &::MaterialMap.Map[pxp->Mat];
            const DWORD dwMatClr = ::Landscape.GetPal()->GetClr((BYTE) (Mat2PixColDefault(pxp->Mat)));
            if(pMat->PXSFace.Surface)
            {
                int32_t pnx, pny;
                pMat->PXSFace.GetPhaseNum(pnx, pny);
                int32_t fcWdt = pMat->PXSFace.Wdt;
                int32_t fcHgt = pMat->PXSFace.Hgt;
                // calculate draw width and tile to use (random-ish)
                uint32_t size = (1103515245 * i + 12345) >> 3;
                float z = pMat->PXSGfxSize * (0.625f + 0.05f * int(size % 16));
                pny = (i / pnx) % pny; pnx = i % pnx;
 
                const float w = z;
                const float h = z * fcHgt / fcWdt;
                const float x1 = fixtof(pxp->x) + cgox + z * pMat->PXSGfxRt.tx / fcWdt;
                const float y1 = fixtof(pxp->y) + cgoy + z * pMat->PXSGfxRt.ty / fcHgt;
                const float x2 = x1 + w;
                const float y2 = y1 + h;
 
                const float sfcWdt = pMat->PXSFace.Surface->Wdt;
                const float sfcHgt = pMat->PXSFace.Surface->Hgt;
 
                C4BltVertex vtx[6];
                vtx[0].tx = (pnx + 0.f) * fcWdt / sfcWdt; vtx[0].ty = (pny + 0.f) * fcHgt / sfcHgt;
                vtx[0].ftx = x1; vtx[0].fty = y1;
                vtx[1].tx = (pnx + 1.f) * fcWdt / sfcWdt; vtx[1].ty = (pny + 0.f) * fcHgt / sfcHgt;
                vtx[1].ftx = x2; vtx[1].fty = y1;
                vtx[2].tx = (pnx + 1.f) * fcWdt / sfcWdt; vtx[2].ty = (pny + 1.f) * fcHgt / sfcHgt;
                vtx[2].ftx = x2; vtx[2].fty = y2;
                vtx[3].tx = (pnx + 0.f) * fcWdt / sfcWdt; vtx[3].ty = (pny + 1.f) * fcHgt / sfcHgt;
                vtx[3].ftx = x1; vtx[3].fty = y2;
                DwTo4UB(0xFFFFFFFF, vtx[0].color);
                DwTo4UB(0xFFFFFFFF, vtx[1].color);
                DwTo4UB(0xFFFFFFFF, vtx[2].color);
                DwTo4UB(0xFFFFFFFF, vtx[3].color);
                vtx[4] = vtx[2];
                vtx[5] = vtx[0];
 
                std::vector<C4BltVertex>& vec = bltVtx[pxp->Mat];
                vec.push_back(vtx[0]);
                vec.push_back(vtx[1]);
                vec.push_back(vtx[2]);
                vec.push_back(vtx[3]);
                vec.push_back(vtx[4]);
                vec.push_back(vtx[5]);
            }
            else
            {
                // old-style: unicolored pixels or lines
                if (fixtoi(pxp->xdir) || fixtoi(pxp->ydir))
                {
                    // lines for stuff that goes whooosh!
                    int len = fixtoi(Abs(pxp->xdir) + Abs(pxp->ydir));
                    const DWORD dwMatClrLen = uint32_t(std::max<int>(dwMatClr >> 24, 195 - (195 - (dwMatClr >> 24)) / len)) << 24 | (dwMatClr & 0xffffff);
                    C4BltVertex begin, end;
                    begin.ftx = fixtof(pxp->x - pxp->xdir) + cgox; begin.fty = fixtof(pxp->y - pxp->ydir) + cgoy;
                    end.ftx = fixtof(pxp->x) + cgox; end.fty = fixtof(pxp->y) + cgoy;
                    DwTo4UB(dwMatClrLen, begin.color);
                    DwTo4UB(dwMatClrLen, end.color);
                    lineVtx.push_back(begin);
                    lineVtx.push_back(end);
                }
                else
                {
                    // single pixels for slow stuff
                    C4BltVertex vtx;
                    vtx.ftx = fixtof(pxp->x) + cgox;
                    vtx.fty = fixtof(pxp->y) + cgoy;
                    DwTo4UB(dwMatClr, vtx.color);
                    pixVtx.push_back(vtx);
                }
            }
        }
    }
 
    if(!pixVtx.empty()) pDraw->PerformMultiPix(cgo.Surface, &pixVtx[0], pixVtx.size(), nullptr);
    if(!lineVtx.empty()) pDraw->PerformMultiLines(cgo.Surface, &lineVtx[0], lineVtx.size(), 1.0f, nullptr);
 
    // PXS graphics disabled?
    if (!Config.Graphics.PXSGfx)
        return;
 
    for(std::map<int, std::vector<C4BltVertex> >::const_iterator iter = bltVtx.begin(); iter != bltVtx.end(); ++iter)
    {
        C4Material *pMat = &::MaterialMap.Map[iter->first];
        pDraw->PerformMultiTris(cgo.Surface, &iter->second[0], iter->second.size(), nullptr, pMat->PXSFace.Surface->texture.get(), nullptr, nullptr, 0, nullptr);
    }
}

References Abs(), C4BltVertex::color, Config, C4Rect::Contains(), Count, DwTo4UB(), C4Rect::Enlarge(), fixtof(), fixtoi(), C4BltVertex::ftx, C4BltVertex::fty, CStdPalette::GetClr(), C4Landscape::GetPal(), C4Facet::GetPhaseNum(), C4Config::Graphics, C4Facet::Hgt, C4Surface::Hgt, Landscape, C4MaterialMap::Map, C4PXS::Mat, Mat2PixColDefault(), MaterialMap, MNone, pDraw, C4Draw::PerformMultiLines(), C4Draw::PerformMultiPix(), C4Draw::PerformMultiTris(), PXS, C4Material::PXSFace, C4ConfigGraphics::PXSGfx, C4MaterialCore::PXSGfxRt, C4MaterialCore::PXSGfxSize, C4Facet::Surface, C4TargetFacet::TargetX, C4TargetFacet::TargetY, C4Surface::texture, C4BltVertex::tx, C4TargetRect::tx, C4BltVertex::ty, C4TargetRect::ty, C4Facet::Wdt, C4Surface::Wdt, C4Facet::X, C4PXS::x, C4PXS::xdir, C4Facet::Y, C4PXS::y, C4PXS::ydir, and z.

Referenced by C4Viewport::Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

Execute()

void C4PXSSystem::Execute

(

)

Definition at line 186 of file C4PXS.cpp.

{
    for (size_t i = 0; i < Count; i++)
    {
        if (!PXS[i].Execute())
        {
            assert(PXS[i].Mat == MNone);
            PXS[i--] = PXS[--Count];
        }
    }
}

References Count, MNone, and PXS.

Referenced by C4Game::Execute().

Here is the caller graph for this function:

GetCount() [1/3]

int32_t C4PXSSystem::GetCount ( ) const

inline

Definition at line 56 of file C4PXS.h.

{ return Count; } // count all PXS

References Count.

GetCount() [2/3]

int32_t C4PXSSystem::GetCount

(

int32_t

mat

)

const

Definition at line 398 of file C4PXS.cpp.

{
    // count PXS of given material
    int32_t result = 0;
    for (size_t i = 0; i < Count; i++)
    {
        if (PXS[i].Mat == mat) ++result;
    }
    return result;
}

References Count, and PXS.

GetCount() [3/3]

int32_t C4PXSSystem::GetCount	(	int32_t	mat,
		int32_t	x,
		int32_t	y,
		int32_t	wdt,
		int32_t	hgt
	)		const

Definition at line 409 of file C4PXS.cpp.

{
    // count PXS of given material in given area
    int32_t result = 0;
    for (size_t i = 0; i < Count; i++)
    {
        const C4PXS *pxp = &PXS[i];
        if (pxp->Mat == mat || mat == MNone)
            if (Inside(pxp->x, x, x + wdt - 1) && Inside(pxp->y, y, y + hgt - 1))
                ++result;
    }
    return result;
}

References Count, Inside(), C4PXS::Mat, MNone, PXS, C4PXS::x, and C4PXS::y.

Here is the call graph for this function:

Load()

bool C4PXSSystem::Load

(

C4Group &

hGroup

)

Definition at line 358 of file C4PXS.cpp.

{
    // load new
    size_t iBinSize, PXSNum;
    if (!hGroup.AccessEntry(C4CFN_PXS,&iBinSize)) return false;
    // clear previous
    Clear();
    // using C4Real or float?
    int32_t iNumForm = 1;
    if (iBinSize % sizeof(C4PXS) == 4)
    {
        if (!hGroup.Read(&iNumForm, sizeof (iNumForm))) return false;
        if (!Inside<int32_t>(iNumForm, 1, 2)) return false;
        iBinSize -= 4;
    }
    // old pxs-files have no tag for the number format
    else if (iBinSize % sizeof(C4PXS) != 0) return false;
    // calc chunk count
    PXSNum = iBinSize / sizeof(C4PXS);
    if (PXSNum > PXSMax) return false;
    if (!hGroup.Read(PXS, iBinSize)) return false;
    // count the PXS, Peter!
    Count = PXSNum;
    // convert num format, if neccessary
    for (size_t i = 0; i < Count; i++)
    {
        C4PXS *pxp = &PXS[i];
        if (pxp->Mat != MNone)
        {
            // convert number format
#ifdef C4REAL_USE_FIXNUM
            if (iNumForm == 2) { FLOAT_TO_FIXED(&pxp->x); FLOAT_TO_FIXED(&pxp->y); FLOAT_TO_FIXED(&pxp->xdir); FLOAT_TO_FIXED(&pxp->ydir); }
#else
            if (iNumForm == 1) { FIXED_TO_FLOAT(&pxp->x); FIXED_TO_FLOAT(&pxp->y); FIXED_TO_FLOAT(&pxp->xdir); FIXED_TO_FLOAT(&pxp->ydir); }
#endif
        }
    }
    return true;
}

References C4Group::AccessEntry(), C4CFN_PXS, Clear(), Count, FLOAT_TO_FIXED(), C4PXS::Mat, MNone, PXS, PXSMax, C4Group::Read(), C4PXS::x, C4PXS::xdir, C4PXS::y, and C4PXS::ydir.

Here is the call graph for this function:

New()

C4PXS * C4PXSSystem::New ( )

protected

Definition at line 168 of file C4PXS.cpp.

{
    if (Count < PXSMax)
        return &PXS[Count++];
    return nullptr;
}

References Count, PXS, and PXSMax.

Referenced by Create().

Here is the caller graph for this function:

Save()

bool C4PXSSystem::Save

(

C4Group &

hGroup

)

Definition at line 325 of file C4PXS.cpp.

{
    if (Count == 0)
    {
        hGroup.Delete(C4CFN_PXS);
        return true;
    }
 
    // Save chunks to temp file
    CStdFile hTempFile;
    if (!hTempFile.Create(Config.AtTempPath(C4CFN_TempPXS)))
        return false;
#ifdef C4REAL_USE_FIXNUM
    int32_t iNumFormat = 1;
#else
    int32_t iNumFormat = 2;
#endif
    if (!hTempFile.Write(&iNumFormat, sizeof (iNumFormat)))
        return false;
    if (!hTempFile.Write(PXS, Count * sizeof(C4PXS)))
        return false;
 
    if (!hTempFile.Close())
        return false;
 
    // Move temp file to group
    if (!hGroup.Move( Config.AtTempPath(C4CFN_TempPXS),
                      C4CFN_PXS ))
        return false;
 
    return true;
}

References C4Config::AtTempPath(), C4CFN_PXS, C4CFN_TempPXS, CStdFile::Close(), Config, Count, CStdFile::Create(), C4Group::Delete(), C4Group::Move(), PXS, and CStdFile::Write().

Referenced by C4Game::LoadScenarioSection().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

Count

size_t C4PXSSystem::Count

Definition at line 44 of file C4PXS.h.

Referenced by Clear(), Default(), Draw(), Execute(), GetCount(), Load(), New(), Save(), and C4ControlSyncCheck::Set().

PXS

C4PXS C4PXSSystem::PXS[PXSMax]

protected

Definition at line 46 of file C4PXS.h.

Referenced by Draw(), Execute(), GetCount(), Load(), New(), and Save().

---

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

• C4PXS.h
• C4PXS.cpp
• stub-handle.cpp