C4FoWRegion Class Reference

#include <C4FoWRegion.h>

Public Member Functions
	C4FoWRegion (C4FoW *pFoW, C4Player *pPlayer)
	~C4FoWRegion ()
const C4FoW *	getFoW () const
const C4Rect &	getRegion () const
const FLOAT_RECT &	getViewportRegion () const
int32_t	getSurfaceHeight () const
int32_t	getSurfaceWidth () const
GLuint	getSurfaceName () const
void	Update (C4Rect r, const FLOAT_RECT &vp)
bool	Render (const C4TargetFacet *pOnScreen=nullptr)
void	GetFragTransform (const C4Rect &clipRect, const C4Rect &outRect, float lightTransform[6]) const

Detailed Description

Definition at line 30 of file C4FoWRegion.h.

Constructor & Destructor Documentation

C4FoWRegion()

C4FoWRegion::C4FoWRegion	(	C4FoW *	pFoW,
		C4Player *	pPlayer
	)

Definition at line 21 of file C4FoWRegion.cpp.

    : pFoW(pFoW)
#ifndef USE_CONSOLE
    , pPlayer(pPlayer)
    , hFrameBufDraw(0), hFrameBufRead(0), hVBO(0), vaoid(0)
#endif
    , Region(0,0,0,0), OldRegion(0,0,0,0)
    , pSurface(new C4Surface), pBackSurface(new C4Surface)
{
    ViewportRegion.left = ViewportRegion.right = ViewportRegion.top = ViewportRegion.bottom = 0.0f;
}

References FLOAT_RECT::bottom, FLOAT_RECT::left, FLOAT_RECT::right, and FLOAT_RECT::top.

~C4FoWRegion()

C4FoWRegion::~C4FoWRegion

(

)

Definition at line 33 of file C4FoWRegion.cpp.

{
#ifndef USE_CONSOLE
    if (hFrameBufDraw) {
        glDeleteFramebuffers(1, &hFrameBufDraw);
        glDeleteFramebuffers(1, &hFrameBufRead);
    }
 
    if (hVBO) {
        glDeleteBuffers(1, &hVBO);
    }
 
    if (vaoid) {
        pGL->FreeVAOID(vaoid);
    }
#endif
}

References CStdGL::FreeVAOID(), and pGL.

Here is the call graph for this function:

Member Function Documentation

getFoW()

const C4FoW* C4FoWRegion::getFoW ( ) const

inline

Definition at line 52 of file C4FoWRegion.h.

{ return pFoW; }

Referenced by C4LandscapeRenderGL::Draw(), and CStdGL::SetupMultiBlt().

Here is the caller graph for this function:

GetFragTransform()

void C4FoWRegion::GetFragTransform	(	const C4Rect &	clipRect,
		const C4Rect &	outRect,
		float	lightTransform[6]
	)		const

Definition at line 342 of file C4FoWRegion.cpp.

{
    const C4Rect& lightRect = getRegion();
    const FLOAT_RECT& vpRect = ViewportRegion;
 
    C4FragTransform trans;
    // Clip offset
    assert(outRect.Hgt >= clipRect.y + clipRect.Hgt);
    trans.Translate(-clipRect.x, -(outRect.Hgt - clipRect.y - clipRect.Hgt));
    // Clip normalization (0,0 -> 1,1)
    trans.Scale(1.0f / clipRect.Wdt, 1.0f / clipRect.Hgt);
    // Viewport/Landscape normalization
    trans.Scale(vpRect.right - vpRect.left, vpRect.bottom - vpRect.top);
    // Offset between viewport and light texture
    trans.Translate(vpRect.left - lightRect.x, vpRect.top - lightRect.y);
    // Light surface normalization
    trans.Scale(1.0f / pSurface->Wdt, 1.0f / pSurface->Hgt);
    // Light surface Y offset
    trans.Translate(0.0f, 1.0f - (float)(lightRect.Hgt) / (float)pSurface->Hgt);
 
    // Extract matrix
    trans.Get2x3(lightTransform);
}

References FLOAT_RECT::bottom, C4FragTransform::Get2x3(), getRegion(), C4Rect::Hgt, FLOAT_RECT::left, FLOAT_RECT::right, C4FragTransform::Scale(), FLOAT_RECT::top, C4FragTransform::Translate(), C4Rect::Wdt, C4Rect::x, and C4Rect::y.

Referenced by CStdGL::SetupMultiBlt().

Here is the call graph for this function:

Here is the caller graph for this function:

getRegion()

const C4Rect& C4FoWRegion::getRegion ( ) const

inline

Definition at line 53 of file C4FoWRegion.h.

{ return Region; }

Referenced by C4FoWLightSection::CalculateTriangles(), C4LandscapeRenderGL::Draw(), and GetFragTransform().

Here is the caller graph for this function:

getSurfaceHeight()

int32_t C4FoWRegion::getSurfaceHeight

(

)

const

Definition at line 161 of file C4FoWRegion.cpp.

{
    return pSurface->Hgt;
}

Referenced by C4LandscapeRenderGL::Draw(), and C4FoWDrawLightTextureStrategy::End().

Here is the caller graph for this function:

getSurfaceName()

GLuint C4FoWRegion::getSurfaceName

(

)

const

Definition at line 172 of file C4FoWRegion.cpp.

{
    assert(pSurface->texture);
    if (!pSurface->texture)
        return 0;
    return pSurface->texture->texName;
}

Referenced by C4LandscapeRenderGL::Draw(), and CStdGL::SetupMultiBlt().

Here is the caller graph for this function:

getSurfaceWidth()

int32_t C4FoWRegion::getSurfaceWidth

(

)

const

Definition at line 166 of file C4FoWRegion.cpp.

{
    return pSurface->Wdt;
}

Referenced by C4LandscapeRenderGL::Draw(), and C4FoWDrawLightTextureStrategy::End().

Here is the caller graph for this function:

getViewportRegion()

const FLOAT_RECT& C4FoWRegion::getViewportRegion ( ) const

inline

Definition at line 54 of file C4FoWRegion.h.

{ return ViewportRegion; }

Referenced by C4LandscapeRenderGL::Draw(), and CStdGL::SetupMultiBlt().

Here is the caller graph for this function:

Render()

bool C4FoWRegion::Render

(

const C4TargetFacet *

pOnScreen = nullptr

)

Definition at line 188 of file C4FoWRegion.cpp.

{
#ifndef USE_CONSOLE
    GLint prev_fb;
    glGetIntegerv(GL_FRAMEBUFFER_BINDING, &prev_fb);
 
    // Update FoW at interesting location
    pFoW->Update(Region, pPlayer);
 
    // On screen? No need to set up frame buffer - simply shortcut
    if (pOnScreen)
    {
        pFoW->Render(this, pOnScreen, pPlayer, pGL->GetProjectionMatrix());
        return true;
    }
 
    // Set up shader. If this one doesn't work, we're really in trouble.
    C4Shader *pShader = pFoW->GetFramebufShader();
    assert(pShader);
    if (!pShader) return false;
 
    // Create & bind the frame buffer
    pDraw->StorePrimaryClipper();
    if(!BindFramebuf(prev_fb))
    {
        pDraw->RestorePrimaryClipper();
        return false;
    }
    assert(pSurface && hFrameBufDraw);
    if (!pSurface || !hFrameBufDraw)
        return false;
 
    // Set up a clean context
    glViewport(0, 0, pSurface->Wdt, pSurface->Hgt);
    const StdProjectionMatrix projectionMatrix = StdProjectionMatrix::Orthographic(0.0f, pSurface->Wdt, pSurface->Hgt, 0.0f);
 
    // Clear texture contents
    assert(pSurface->Hgt % 2 == 0);
    glScissor(0, pSurface->Hgt / 2, pSurface->Wdt, pSurface->Hgt / 2);
    glClearColor(0.0f, 0.5f / 1.5f, 0.5f / 1.5f, 0.0f);
    glEnable(GL_SCISSOR_TEST);
    glClear(GL_COLOR_BUFFER_BIT);
 
    // clear lower half of texture
    glScissor(0, 0, pSurface->Wdt, pSurface->Hgt / 2);
    glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);
    glDisable(GL_SCISSOR_TEST);
 
    // Render FoW to frame buffer object
    glBlendFunc(GL_ONE, GL_ONE);
    pFoW->Render(this, nullptr, pPlayer, projectionMatrix);
 
    // Copy over the old state
    if (OldRegion.Wdt > 0)
    {
 
        // How much the borders have moved
        int dx0 = Region.x - OldRegion.x,
            dy0 = Region.y - OldRegion.y,
            dx1 = Region.x + Region.Wdt - OldRegion.x - OldRegion.Wdt,
            dy1 = Region.y + Region.Hgt - OldRegion.y - OldRegion.Hgt;
 
        // Source and target rect coordinates (landscape coordinate system)
        int sx0 = std::max(0, dx0),                  sy0 = std::max(0, dy0),
            sx1 = OldRegion.Wdt - std::max(0, -dx1), sy1 = OldRegion.Hgt - std::max(0, -dy1),
            tx0 = std::max(0, -dx0),                 ty0 = std::max(0, -dy0),
            tx1 = Region.Wdt - std::max(0, dx1),     ty1 = Region.Hgt - std::max(0, dy1);
 
        // Quad coordinates
        float vtxData[16];
        float* squad = &vtxData[0];
        float* tquad = &vtxData[8];
 
        squad[0] = float(sx0);
        squad[1] = float(sy0);
        squad[2] = float(sx0);
        squad[3] = float(sy1);
        squad[4] = float(sx1);
        squad[5] = float(sy0);
        squad[6] = float(sx1);
        squad[7] = float(sy1);
 
        tquad[0] = float(tx0);
        tquad[1] = float(ty0);
        tquad[2] = float(tx0);
        tquad[3] = float(ty1);
        tquad[4] = float(tx1);
        tquad[5] = float(ty0);
        tquad[6] = float(tx1);
        tquad[7] = float(ty1);
 
        // Transform into texture coordinates
        for (int i = 0; i < 4; i++)
        {
            squad[i*2] = squad[i*2] / pBackSurface->Wdt;
            squad[i*2+1] = 1.0 - squad[i*2+1] / pBackSurface->Hgt;
        }
 
        // Load coordinates into vertex buffer
        if (hVBO == 0)
        {
            glGenBuffers(1, &hVBO);
            glBindBuffer(GL_ARRAY_BUFFER, hVBO);
            glBufferData(GL_ARRAY_BUFFER, sizeof(vtxData), vtxData, GL_STREAM_DRAW);
 
            assert(vaoid == 0);
            vaoid = pGL->GenVAOID();
        }
        else
        {
            glBindBuffer(GL_ARRAY_BUFFER, hVBO);
            glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vtxData), vtxData);
        }
 
        // Copy using shader
        C4ShaderCall Call(pShader);
        Call.Start();
        if (Call.AllocTexUnit(C4FoWFSU_Texture))
            glBindTexture(GL_TEXTURE_2D, pBackSurface->texture->texName);
        Call.SetUniformMatrix4x4(C4FoWFSU_ProjectionMatrix, projectionMatrix);
        glBlendFunc(GL_ONE_MINUS_CONSTANT_COLOR, GL_CONSTANT_COLOR);
        float normalBlend = 1.0f / 4.0f, // Normals change quickly
              brightBlend = 1.0f / 16.0f; // Intensity more slowly
        glBlendColor(0.0f,normalBlend,normalBlend,brightBlend);
 
        GLuint vao;
        const bool has_vao = pGL->GetVAO(vaoid, vao);
        glBindVertexArray(vao);
        if (!has_vao)
        {
            glEnableVertexAttribArray(pShader->GetAttribute(C4FoWFSA_Position));
            glEnableVertexAttribArray(pShader->GetAttribute(C4FoWFSA_TexCoord));
            glVertexAttribPointer(pShader->GetAttribute(C4FoWFSA_Position), 2, GL_FLOAT, GL_FALSE, 0, reinterpret_cast<const uint8_t*>(8 * sizeof(float)));
            glVertexAttribPointer(pShader->GetAttribute(C4FoWFSA_TexCoord), 2, GL_FLOAT, GL_FALSE, 0, reinterpret_cast<const uint8_t*>(0));
        }
 
        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 
        glBindVertexArray(0);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
 
        Call.Finish();
    }
 
    // Done!
    glBindFramebuffer(GL_FRAMEBUFFER, prev_fb);
    pDraw->RestorePrimaryClipper();
 
    OldRegion = Region;
#endif
    return true;
}

References C4FoWFSA_Position, C4FoWFSA_TexCoord, C4FoWFSU_ProjectionMatrix, C4FoWFSU_Texture, C4ScriptGuiWindowActionID::Call, CStdGL::GenVAOID(), C4Shader::GetAttribute(), C4FoW::GetFramebufShader(), CStdGL::GetProjectionMatrix(), CStdGL::GetVAO(), C4Rect::Hgt, StdProjectionMatrix::Orthographic(), pDraw, pGL, C4FoW::Render(), C4Draw::RestorePrimaryClipper(), C4Draw::StorePrimaryClipper(), C4FoW::Update(), C4Rect::Wdt, C4Rect::x, and C4Rect::y.

Referenced by C4Viewport::Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

Update()

void C4FoWRegion::Update	(	C4Rect	r,
		const FLOAT_RECT &	vp
	)

Definition at line 181 of file C4FoWRegion.cpp.

{
    // Set the new region
    Region = r;
    ViewportRegion = vp;
}

Referenced by C4Viewport::Draw().

Here is the caller graph for this function:

---

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

• C4FoWRegion.h
• C4FoWRegion.cpp