C4LandscapeRenderGL Class Reference

#include <C4LandscapeRender.h>

Inheritance diagram for C4LandscapeRenderGL:

Collaboration diagram for C4LandscapeRenderGL:

Public Member Functions
	C4LandscapeRenderGL ()
	~C4LandscapeRenderGL () override
bool	ReInit (int32_t iWidth, int32_t iHeight) override
bool	Init (int32_t iWidth, int32_t iHeight, C4TextureMap *pMap, C4GroupSet *pGraphics) override
void	Clear () override
C4Rect	GetAffectedRect (C4Rect Rect) override
void	Update (C4Rect Rect, C4Landscape *pSource) override
void	Draw (const C4TargetFacet &cgo, const C4FoWRegion *Light, uint32_t clrMod) override
virtual void	Draw (const C4TargetFacet &cgo, const class C4FoWRegion *Light, uint32_t clrMod)=0

Protected Attributes
int32_t	iWidth {0}
int32_t	iHeight {0}
C4TextureMap *	pTexs {nullptr}

Detailed Description

Definition at line 111 of file C4LandscapeRender.h.

Constructor & Destructor Documentation

C4LandscapeRenderGL()

C4LandscapeRenderGL::C4LandscapeRenderGL

(

)

Definition at line 51 of file C4LandscapeRender.cpp.

{
    ZeroMem(Surfaces, sizeof(Surfaces));
    hMaterialTexture = matMapTexture = 0;
    hVBO = 0;
    hVAOIDNoLight = 0;
    hVAOIDLight = 0;
}

References ZeroMem().

Here is the call graph for this function:

~C4LandscapeRenderGL()

C4LandscapeRenderGL::~C4LandscapeRenderGL ( )

override

Definition at line 60 of file C4LandscapeRender.cpp.

{
    Clear();
}

References Clear().

Here is the call graph for this function:

Member Function Documentation

Clear()

void C4LandscapeRenderGL::Clear ( )

overridevirtual

Implements C4LandscapeRender.

Definition at line 136 of file C4LandscapeRender.cpp.

{
    ClearShaders();
 
    // free textures
    int i;
    for (i = 0; i < C4LR_SurfaceCount; i++)
    {
        delete Surfaces[i];
        Surfaces[i] = nullptr;
    }
    if (hMaterialTexture) glDeleteTextures(1, &hMaterialTexture);
    hMaterialTexture = 0;
    if (matMapTexture) glDeleteTextures(1, &matMapTexture);
    matMapTexture = 0;
 
    if (hVBO != 0)
    {
        glDeleteBuffers(1, &hVBO);
        hVBO = 0;
    }
 
    if (hVAOIDLight != 0)
    {
        pGL->FreeVAOID(hVAOIDLight);
        hVAOIDLight = 0;
    }
 
    if (hVAOIDNoLight != 0)
    {
        pGL->FreeVAOID(hVAOIDNoLight);
        hVAOIDNoLight = 0;
    }
}

References C4LR_SurfaceCount, CStdGL::FreeVAOID(), and pGL.

Referenced by Init(), and ~C4LandscapeRenderGL().

Here is the call graph for this function:

Here is the caller graph for this function:

Draw() [1/2]

void C4LandscapeRenderGL::Draw ( const C4TargetFacet &  cgo, const C4FoWRegion *  Light, uint32_t  clrMod  )

override

Definition at line 935 of file C4LandscapeRender.cpp.

{
    // Must have GL and be initialized
    if(!pGL && !Shader.Initialised() && !ShaderLight.Initialised()) return;
    
    // prepare rendering to surface
    C4Surface *sfcTarget = cgo.Surface;
    if (!pGL->PrepareRendering(sfcTarget)) return;
 
    // Choose the right shader depending on whether we have dynamic lighting or not
    const C4Shader* shader = &Shader;
    if (Light) shader = &ShaderLight;
    if (!shader->Initialised()) return;
 
    // Activate shader
    C4ShaderCall ShaderCall(shader);
    ShaderCall.Start();
 
    // Bind data
    ShaderCall.SetUniformMatrix4x4(C4LRU_ProjectionMatrix, pGL->GetProjectionMatrix());
    ShaderCall.SetUniform3fv(C4LRU_Gamma, 1, pGL->gammaOut);
    ShaderCall.SetUniform2f(C4LRU_Resolution, Surfaces[0]->Wdt, Surfaces[0]->Hgt);
    float centerX = float(cgo.TargetX)+float(cgo.Wdt)/2,
          centerY = float(cgo.TargetY)+float(cgo.Hgt)/2;
    ShaderCall.SetUniform2f(C4LRU_Center,
                            centerX / float(Surfaces[0]->Wdt),
                            centerY / float(Surfaces[0]->Hgt));
    ShaderCall.SetUniform1f(C4LRU_MaterialDepth, float(iMaterialTextureDepth));
    ShaderCall.SetUniform2f(C4LRU_MaterialSize,
                            float(iMaterialWidth) / ::Game.C4S.Landscape.MaterialZoom,
                            float(iMaterialHeight) / ::Game.C4S.Landscape.MaterialZoom);
    const float fMod[4] = {
        ((clrMod >> 16) & 0xff) / 255.0f,
        ((clrMod >>  8) & 0xff) / 255.0f,
        ((clrMod      ) & 0xff) / 255.0f,
        ((clrMod >> 24) & 0xff) / 255.0f
    };
    ShaderCall.SetUniform4fv(C4LRU_Modulation, 1, fMod);
 
    if (Light)
    {
        const FLOAT_RECT ViewportRect = Light->getViewportRegion();
        const C4Rect ClipRect = pDraw->GetClipRect();
        const C4Rect OutRect = pDraw->GetOutRect();
        float ambientTransform[6];
        Light->getFoW()->Ambient.GetFragTransform(ViewportRect, ClipRect, OutRect, ambientTransform);
        ShaderCall.SetUniformMatrix2x3fv(C4LRU_AmbientTransform, 1, ambientTransform);
        ShaderCall.SetUniform1f(C4LRU_AmbientBrightness, Light->getFoW()->Ambient.GetBrightness());
    }
 
    // time information
    ShaderCall.SetUniform1i(C4LRU_FrameCounter, ::Game.FrameCounter);
    const auto now = std::chrono::steady_clock::now();
    const int epoch = std::chrono::duration_cast<std::chrono::milliseconds>(now - TimerStart).count();
    ShaderCall.SetUniform1i(C4LRU_Time, epoch);
 
    pDraw->scriptUniform.Apply(ShaderCall);
 
    // Start binding textures
    if(shader->HaveUniform(C4LRU_LandscapeTex))
    {
        GLint iLandscapeUnits[C4LR_SurfaceCount];
        for(int i = 0; i < C4LR_SurfaceCount; i++)
        {
            iLandscapeUnits[i] = ShaderCall.AllocTexUnit(-1) - GL_TEXTURE0;
            glBindTexture(GL_TEXTURE_2D, Surfaces[i]->texture->texName);
            if (pGL->Zoom != 1.0)
            {
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
            }
            else
            {
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
            }
        }
        ShaderCall.SetUniform1iv(C4LRU_LandscapeTex, C4LR_SurfaceCount, iLandscapeUnits);
    }
    if(Light && ShaderCall.AllocTexUnit(C4LRU_LightTex))
    {
        glBindTexture(GL_TEXTURE_2D, Light->getSurfaceName());
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    }
    if(Light && ShaderCall.AllocTexUnit(C4LRU_AmbientTex))
    {
        glBindTexture(GL_TEXTURE_2D, Light->getFoW()->Ambient.Tex);
    }
    if(ShaderCall.AllocTexUnit(C4LRU_ScalerTex))
    {
        glBindTexture(GL_TEXTURE_2D, fctScaler.Surface->texture->texName);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    }
    if(ShaderCall.AllocTexUnit(C4LRU_MaterialTex))
    {
        glBindTexture(GL_TEXTURE_2D_ARRAY, hMaterialTexture);
    }
    if(ShaderCall.AllocTexUnit(C4LRU_MatMapTex))
    {
        uint32_t MatMap[2*256];
        BuildMatMap(MatMap);
        glBindTexture(GL_TEXTURE_1D, matMapTexture);
        glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA8, 2*256, 0, GL_RGBA, GL_UNSIGNED_BYTE, MatMap);
        glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    }
 
    // Calculate coordinates into landscape texture
    FLOAT_RECT fTexBlt;
    float fx = float(cgo.TargetX), fy = float(cgo.TargetY);
    fTexBlt.left  = fx / Surfaces[0]->Wdt;
    fTexBlt.top   = fy / Surfaces[0]->Hgt;
    fTexBlt.right = (fx + float(cgo.Wdt)) / Surfaces[0]->Wdt;
    fTexBlt.bottom= (fy + float(cgo.Hgt)) / Surfaces[0]->Hgt;
 
    // Calculate coordinates on screen (zoomed!)
    FLOAT_RECT tTexBlt;
    float tx = float(cgo.X), ty = float(cgo.Y);
    pGL->ApplyZoom(tx, ty);
    tTexBlt.left  = tx;
    tTexBlt.top   = ty;
    tTexBlt.right = tx + float(cgo.Wdt) * pGL->Zoom;
    tTexBlt.bottom= ty + float(cgo.Hgt) * pGL->Zoom;
 
    // Blend it
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
    // Prepare vertex data
    float vtxData[24];
    float* pos = &vtxData[0];
    float* tex = &vtxData[8];
    float* lightTex = &vtxData[16];
 
    pos[0] = tTexBlt.left;
    pos[1] = tTexBlt.top;
    pos[2] = tTexBlt.right;
    pos[3] = tTexBlt.top;
    pos[4] = tTexBlt.left;
    pos[5] = tTexBlt.bottom;
    pos[6] = tTexBlt.right;
    pos[7] = tTexBlt.bottom;
 
    tex[0] = fTexBlt.left;
    tex[1] = fTexBlt.top;
    tex[2] = fTexBlt.right;
    tex[3] = fTexBlt.top;
    tex[4] = fTexBlt.left;
    tex[5] = fTexBlt.bottom;
    tex[6] = fTexBlt.right;
    tex[7] = fTexBlt.bottom;
 
    unsigned int nFloats = 16;
    if (Light)
    {
        FLOAT_RECT lTexBlt;
        const C4Rect LightRect = Light->getRegion();
        int32_t iLightWdt = Light->getSurfaceWidth(),
            iLightHgt = Light->getSurfaceHeight();
        lTexBlt.left = (fx - LightRect.x) / iLightWdt;
        lTexBlt.top = 1.0 - (fy - LightRect.y) / iLightHgt;
        lTexBlt.right = (fx + cgo.Wdt - LightRect.x) / iLightWdt;
        lTexBlt.bottom = 1.0 - (fy + cgo.Hgt - LightRect.y) / iLightHgt;
 
        lightTex[0] = lTexBlt.left;
        lightTex[1] = lTexBlt.top;
        lightTex[2] = lTexBlt.right;
        lightTex[3] = lTexBlt.top;
        lightTex[4] = lTexBlt.left;
        lightTex[5] = lTexBlt.bottom;
        lightTex[6] = lTexBlt.right;
        lightTex[7] = lTexBlt.bottom;
        nFloats = 24;
    }
 
    // Upload vertex data
    glBindBuffer(GL_ARRAY_BUFFER, hVBO);
    glBufferSubData(GL_ARRAY_BUFFER, 0, nFloats * sizeof(float), vtxData);
 
    // Bind VAO
    unsigned int vaoid = Light ? hVAOIDLight : hVAOIDNoLight;
    GLuint vao;
    const bool has_vao = pGL->GetVAO(vaoid, vao);
    glBindVertexArray(vao);
    if (!has_vao)
    {
        // Setup state
        glEnableVertexAttribArray(shader->GetAttribute(C4LRA_Position));
        glEnableVertexAttribArray(shader->GetAttribute(C4LRA_LandscapeTexCoord));
        if (Light)
            glEnableVertexAttribArray(shader->GetAttribute(C4LRA_LightTexCoord));
 
        glVertexAttribPointer(shader->GetAttribute(C4LRA_Position), 2, GL_FLOAT, GL_FALSE, 0, nullptr);
        glVertexAttribPointer(shader->GetAttribute(C4LRA_LandscapeTexCoord), 2, GL_FLOAT, GL_FALSE, 0, reinterpret_cast<const uint8_t*>(8 * sizeof(float)));
        if (Light)
            glVertexAttribPointer(shader->GetAttribute(C4LRA_LightTexCoord), 2, GL_FLOAT, GL_FALSE, 0, reinterpret_cast<const uint8_t*>(16 * sizeof(float)));
    }
 
    // Do the blit
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
 
    // Reset state
    glBindVertexArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
 
    ShaderCall.Finish();
}

References C4ShaderCall::AllocTexUnit(), C4FoW::Ambient, C4ScriptUniform::Apply(), C4Draw::ApplyZoom(), FLOAT_RECT::bottom, C4LR_SurfaceCount, C4LRA_LandscapeTexCoord, C4LRA_LightTexCoord, C4LRA_Position, C4LRU_AmbientBrightness, C4LRU_AmbientTex, C4LRU_AmbientTransform, C4LRU_Center, C4LRU_FrameCounter, C4LRU_Gamma, C4LRU_LandscapeTex, C4LRU_LightTex, C4LRU_MaterialDepth, C4LRU_MaterialSize, C4LRU_MaterialTex, C4LRU_MatMapTex, C4LRU_Modulation, C4LRU_ProjectionMatrix, C4LRU_Resolution, C4LRU_ScalerTex, C4LRU_Time, C4Game::C4S, C4ShaderCall::Finish(), C4Game::FrameCounter, Game, C4Draw::gammaOut, C4Shader::GetAttribute(), C4FoWAmbient::GetBrightness(), C4Draw::GetClipRect(), C4FoWRegion::getFoW(), C4FoWAmbient::GetFragTransform(), C4Draw::GetOutRect(), CStdGL::GetProjectionMatrix(), C4FoWRegion::getRegion(), C4FoWRegion::getSurfaceHeight(), C4FoWRegion::getSurfaceName(), C4FoWRegion::getSurfaceWidth(), CStdGL::GetVAO(), C4FoWRegion::getViewportRegion(), C4Shader::HaveUniform(), C4Facet::Hgt, C4Shader::Initialised(), C4Scenario::Landscape, FLOAT_RECT::left, C4SLandscape::MaterialZoom, pDraw, pGL, CStdGL::PrepareRendering(), FLOAT_RECT::right, C4Draw::scriptUniform, C4ShaderCall::SetUniform1f(), C4ShaderCall::SetUniform1i(), C4ShaderCall::SetUniform1iv(), C4ShaderCall::SetUniform2f(), C4ShaderCall::SetUniform3fv(), C4ShaderCall::SetUniform4fv(), C4ShaderCall::SetUniformMatrix2x3fv(), C4ShaderCall::SetUniformMatrix4x4(), C4ShaderCall::Start(), C4Facet::Surface, C4TargetFacet::TargetX, C4TargetFacet::TargetY, C4FoWAmbient::Tex, C4Surface::texture, FLOAT_RECT::top, C4Facet::Wdt, C4Facet::X, C4Rect::x, C4Facet::Y, C4Rect::y, and C4Draw::Zoom.

Here is the call graph for this function:

Draw() [2/2]

virtual void C4LandscapeRender::Draw ( const C4TargetFacet &  cgo, const class C4FoWRegion *  Light, uint32_t  clrMod  )

pure virtualinherited

GetAffectedRect()

C4Rect C4LandscapeRenderGL::GetAffectedRect ( C4Rect  Rect )

overridevirtual

Implements C4LandscapeRender.

Definition at line 350 of file C4LandscapeRender.cpp.

{
    Rect.Enlarge(C4LR_BiasDistanceX, C4LR_BiasDistanceY);
    return Rect;
}

References C4LR_BiasDistanceX, C4LR_BiasDistanceY, and C4Rect::Enlarge().

Here is the call graph for this function:

Init()

bool C4LandscapeRenderGL::Init ( int32_t  iWidth, int32_t  iHeight, C4TextureMap *  pMap, C4GroupSet *  pGraphics  )

overridevirtual

Implements C4LandscapeRender.

Definition at line 65 of file C4LandscapeRender.cpp.

{
    Clear();
 
    // Safe info
    this->iWidth = iWidth;
    this->iHeight = iHeight;
    this->pTexs = pTexs;
 
    // Start timer
    this->TimerStart = std::chrono::steady_clock::now();
 
    // Allocate landscape textures
    if (!InitLandscapeTexture())
    {
        LogFatal("[!] Could not initialize landscape texture!");
        return false;
    }
 
    // Build texture, er, texture
    if (!InitMaterialTexture(pTexs))
    {
        LogFatal("[!] Could not initialize landscape textures for rendering!");
        return false;
    }
    
    // Load sclaer
    if (!LoadScaler(pGraphics))
    {
        LogFatal("[!] Could not load scaler!");
        return false;
    }
 
    // Load shader
    if (!LoadShaders(pGraphics))
    {
        LogFatal("[!] Could not initialize landscape shader!");
        return false;
    }
 
    if (!InitVBO())
    {
        LogFatal("[!] Could not initialize landscape VBO!");
        return false;
    }
 
    return true;
}

References Clear(), C4LandscapeRender::iHeight, C4LandscapeRender::iWidth, LogFatal(), and C4LandscapeRender::pTexs.

Here is the call graph for this function:

ReInit()

bool C4LandscapeRenderGL::ReInit ( int32_t  iWidth, int32_t  iHeight  )

overridevirtual

Implements C4LandscapeRender.

Definition at line 114 of file C4LandscapeRender.cpp.

{
    // Safe info
    this->iWidth = iWidth;
    this->iHeight = iHeight;
 
    // Clear old landscape textures
    for (auto & Surface : Surfaces)
    {
        delete Surface;
        Surface = nullptr;
    }
 
    // Allocate new landscape textures
    if (!InitLandscapeTexture())
    {
        LogFatal("[!] Could not initialize landscape texture!");
        return false;
    }
    return true;
}

References C4LandscapeRender::iHeight, C4LandscapeRender::iWidth, and LogFatal().

Here is the call graph for this function:

Update()

void C4LandscapeRenderGL::Update ( C4Rect  Rect, C4Landscape *  pSource  )

overridevirtual

Implements C4LandscapeRender.

Definition at line 356 of file C4LandscapeRender.cpp.

{
    // clip to landscape size
    To.Intersect(C4Rect(0,0,iWidth,iHeight));
    // everything clipped?
    if (To.Wdt<=0 || To.Hgt<=0) return;
 
    // Lock surfaces
    // We clear the affected region here because ClearBoxDw allocates the
    // main memory buffer for the box, so that only that box needs to be
    // sent to the gpu, and not the whole texture, or every pixel
    // separately. It's an important optimization.
    for (auto & Surface : Surfaces)
    {
        if (!Surface->Lock()) return;
        Surface->ClearBoxDw(To.x, To.y, To.Wdt, To.Hgt);
    }
 
    // Initialize up & down placement arrays. These arrays are always updated
    // so that they contain the placement sums of C4LR_BiasDistanceY pixels
    // above and below the current row.
    int x, y;
    int placementSumsWidth = C4LR_BiasDistanceX * 2 + To.Wdt;
    int *placementSumsUp = new int [placementSumsWidth * 2];
    int *placementSumsDown = placementSumsUp + placementSumsWidth;
    for(x = 0; x < placementSumsWidth; x++)
    {
        placementSumsUp[x] = 0;
        placementSumsDown[x] = 0;
        if (To.x + x - C4LR_BiasDistanceX < 0 || To.x + x - C4LR_BiasDistanceX >= iWidth) continue;
        for(y = 1; y <= std::min(C4LR_BiasDistanceY, To.y); y++)
            placementSumsUp[x] += pSource->_GetPlacement(To.x+x-C4LR_BiasDistanceX, To.y-y);
        for(y = 1; y <= std::min(C4LR_BiasDistanceY, iHeight - 1 - To.y); y++)
            placementSumsDown[x] += pSource->_GetPlacement(To.x+x-C4LR_BiasDistanceX, To.y+y);
    }
 
    // Get tex refs (shortcut, we will use them quite heavily)
    C4TexRef *texture[C4LR_SurfaceCount];
    x = y = 0;
    for(int i = 0; i < C4LR_SurfaceCount; i++)
        texture[i] = Surfaces[i]->texture.get();
 
    // Go through it from top to bottom
    for(y = 0; y < To.Hgt; y++)
    {
        // Initialize left & right placement sums. These are meant to contain
        // the placement sum of a (C4LR_BiasDistanceX, 2*C4LR_BiasDistanceY+1)
        // rectangle left/right of the current pixel. So we initialise it to
        // be correct at x=0. Note that the placementSum arrays don't contain
        // information about the current row, therefore we need a special case
        // for those pixels.
        int sumLeft = 0, sumRight = 0;
        for(x = 1; x <= std::min(C4LR_BiasDistanceX, To.x); x++)
            sumLeft += pSource->_GetPlacement(To.x-x,To.y+y);
        for(x = 1; x <= std::min(C4LR_BiasDistanceX, iWidth - 1 - To.x ); x++)
            sumRight += pSource->_GetPlacement(To.x+x,To.y+y);
        for (int i = 1; i <= C4LR_BiasDistanceX; i++) {
            sumLeft += placementSumsUp[C4LR_BiasDistanceX - i];
            sumLeft += placementSumsDown[C4LR_BiasDistanceX - i];
            sumRight += placementSumsUp[C4LR_BiasDistanceX + i];
            sumRight += placementSumsDown[C4LR_BiasDistanceX + i];
        }
 
        // Initialise up & down sums. Same principle as above, but slightly
        // easier as we do not miss pixels if we just use the placement sums.
        int sumUp = 0, sumDown = 0;
        for (int i = -C4LR_BiasDistanceX; i <= C4LR_BiasDistanceX; i++) {
            sumUp += placementSumsUp[C4LR_BiasDistanceX + i];
            sumDown += placementSumsDown[C4LR_BiasDistanceX + i];
        }
 
        for(x = 0; x < To.Wdt; x++)
        {
            int pixel = pSource->_GetPix(To.x+x, To.y+y);
            int placement = pSource->_GetPlacement(To.x+x, To.y+y);
 
            // Calculate bias. The scale here is the size of the rectangle (see above)
            const int horizontalFactor = C4LR_BiasDistanceX * (2 * C4LR_BiasDistanceY + 1);
            int horizontalBias = std::max(0, placement * horizontalFactor - sumRight) -
                                 std::max(0, placement * horizontalFactor - sumLeft);
            const int verticalFactor = C4LR_BiasDistanceY * (2 * C4LR_BiasDistanceX + 1);
            int verticalBias = std::max(0, placement * verticalFactor - sumDown) -
                               std::max(0, placement * verticalFactor - sumUp);
 
            // Maximum placement differences that make a difference in the result,  after which we are at the limits of
            // what can be packed into a byte
            const int maximumPlacementDifference = 40;
            int horizontalBiasScaled = Clamp(horizontalBias * 127 / maximumPlacementDifference / horizontalFactor + 128, 0, 255);
            int verticalBiasScaled = Clamp(verticalBias * 127 / maximumPlacementDifference / verticalFactor + 128, 0, 255);
 
            // Collect data to save per pixel
            unsigned char data[C4LR_SurfaceCount * 4];
            memset(data, 0, sizeof(data));
 
            data[C4LR_Material] = pixel;
            data[C4LR_BiasX] = horizontalBiasScaled;
            data[C4LR_BiasY] = verticalBiasScaled;
            data[C4LR_Scaler] = CalculateScalerBitmask(x, y, To, pSource);
            data[C4LR_Place] = placement;
 
            for(int i = 0; i < C4LR_SurfaceCount; i++)
                texture[i]->SetPix(To.x+x, To.y+y, 
                    RGBA(data[i*4+0], data[i*4+1], data[i*4+2], data[i*4+3]));
 
            // Update sums (last column would be out-of-bounds, and not
            // necessary as we will re-initialise it for the next row)
            if (x < To.Wdt - 1) {
                sumLeft -= placementSumsUp[x] + placementSumsDown[x];
                sumLeft += placementSumsUp[x + C4LR_BiasDistanceX] + placementSumsDown[x + C4LR_BiasDistanceX];
                sumRight -= placementSumsUp[x + C4LR_BiasDistanceX + 1] + placementSumsDown[x + C4LR_BiasDistanceX + 1];
                sumUp -= placementSumsUp[x];
                sumDown -= placementSumsDown[x];
                sumRight += placementSumsUp[x + 2 * C4LR_BiasDistanceX + 1] + placementSumsDown[x + 2 * C4LR_BiasDistanceX + 1];
                sumUp += placementSumsUp[x + 2 * C4LR_BiasDistanceX + 1];
                sumDown += placementSumsDown[x + 2 * C4LR_BiasDistanceX + 1];
            }
 
            // Update left & right for next pixel in line
            if(x + To.x + 1 < iWidth)
                sumRight -= pSource->_GetPlacement(To.x+x + 1, To.y+y);
            if(To.x+x + C4LR_BiasDistanceX + 1 < iWidth)
                sumRight += pSource->_GetPlacement(To.x+x + C4LR_BiasDistanceX + 1, To.y+y);
            sumLeft += placement;
            if(To.x+x - C4LR_BiasDistanceX >= 0)
                sumLeft -= pSource->_GetPlacement(To.x+x - C4LR_BiasDistanceX, To.y+y);
 
            // Update up & down arrays (for next line already)
            if (To.x + x >= C4LR_BiasDistanceX) {
                if (To.y + y + 1 < iHeight)
                    placementSumsDown[x] -= pSource->_GetPlacement(To.x + x - C4LR_BiasDistanceX, To.y + y + 1);
                if (To.y + y + C4LR_BiasDistanceY + 1 < iHeight)
                    placementSumsDown[x] += pSource->_GetPlacement(To.x + x - C4LR_BiasDistanceX, To.y + y + C4LR_BiasDistanceY + 1);
                if (To.y + y - C4LR_BiasDistanceY >= 0)
                    placementSumsUp[x] -= pSource->_GetPlacement(To.x + x - C4LR_BiasDistanceX, To.y + y - C4LR_BiasDistanceY);
                placementSumsUp[x] += pSource->_GetPlacement(To.x + x - C4LR_BiasDistanceX, To.y + y);
            }
        }
 
        // Finish updating up & down arrays for the next line
        if (To.x + x >= C4LR_BiasDistanceX)
        {
            for (; x < std::min(placementSumsWidth, iWidth - To.x + C4LR_BiasDistanceX); x++) {
                if (To.y + y + 1 < iHeight)
                    placementSumsDown[x] -= pSource->_GetPlacement(To.x + x - C4LR_BiasDistanceX, To.y + y + 1);
                if (To.y + y + C4LR_BiasDistanceY + 1 < iHeight)
                    placementSumsDown[x] += pSource->_GetPlacement(To.x + x - C4LR_BiasDistanceX, To.y + y + C4LR_BiasDistanceY + 1);
                if (To.y + y - C4LR_BiasDistanceY >= 0)
                    placementSumsUp[x] -= pSource->_GetPlacement(To.x + x - C4LR_BiasDistanceX, To.y + y - C4LR_BiasDistanceY);
                placementSumsUp[x] += pSource->_GetPlacement(To.x + x - C4LR_BiasDistanceX, To.y + y);
            }
        }
    }
 
    // done
    delete[] placementSumsUp;
    for (auto & Surface : Surfaces)
        Surface->Unlock();
}

References C4Landscape::_GetPix(), C4Landscape::_GetPlacement(), C4LR_BiasDistanceX, C4LR_BiasDistanceY, C4LR_BiasX, C4LR_BiasY, C4LR_Material, C4LR_Place, C4LR_Scaler, C4LR_SurfaceCount, Clamp(), C4Rect::Hgt, C4LandscapeRender::iHeight, C4Rect::Intersect(), C4LandscapeRender::iWidth, RGBA(), C4Rect::Wdt, C4Rect::x, and C4Rect::y.

Here is the call graph for this function:

Member Data Documentation

iHeight

int32_t C4LandscapeRender::iHeight {0}

protectedinherited

Definition at line 91 of file C4LandscapeRender.h.

Referenced by Init(), ReInit(), and Update().

iWidth

int32_t C4LandscapeRender::iWidth {0}

protectedinherited

Definition at line 91 of file C4LandscapeRender.h.

Referenced by Init(), ReInit(), and Update().

pTexs

C4TextureMap* C4LandscapeRender::pTexs {nullptr}

protectedinherited

Definition at line 92 of file C4LandscapeRender.h.

Referenced by Init().

---

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

• C4LandscapeRender.h
• C4LandscapeRender.cpp