C4Viewport Class Reference

#include <C4Viewport.h>

Collaboration diagram for C4Viewport:

Public Member Functions
	C4Viewport ()
	~C4Viewport ()
float	GetZoom ()
void	SetZoom (float zoom_value)
float	GetGUIZoom () const
void	Execute ()
void	ClearPointers (C4Object *obj)
void	SetOutputSize (int32_t draw_x, int32_t draw_y, int32_t out_x, int32_t out_y, int32_t out_wdt, int32_t out_hgt)
void	CalculateZoom ()
void	ChangeZoom (float by_factor)
void	SetZoom (float to_zoom, bool direct=false)
void	SetZoomLimits (float to_min_zoom, float to_max_zoom)
float	GetZoomByViewRange (int32_t size_x, int32_t size_y) const
float	GetZoomLimitMin () const
float	GetZoomLimitMax () const
float	GetZoomTarget () const
bool	Init (int32_t for_player, bool set_temporary_only)
void	DropFile (const char *filename, float x, float y)
bool	TogglePlayerLock ()
bool	GetPlayerLock ()
void	NextPlayer ()
C4Rect	GetOutputRect ()
bool	IsViewportMenu (class C4Menu *menu)
C4Viewport *	GetNext ()
int32_t	GetPlayer ()
void	CenterPosition ()
void	DisableFoW ()
void	EnableFoW ()
float	GetViewX ()
float	GetViewY ()
float	GetViewCenterX ()
float	GetViewCenterY ()
float	WindowToGameX (int32_t win_x)
float	WindowToGameY (int32_t win_y)
void	ScrollView (float by_x, float by_y)
void	SetViewX (float x)
void	SetViewY (float y)
void	SetViewOffset (int32_t x, int32_t y)
float	GetZoom () const
void	AdjustPosition (bool immediate=false)
C4ViewportWindow *	GetWindow ()
bool	UpdateOutputSize (int32_t new_width=0, int32_t new_height=0)
bool	ViewPositionByScrollBars ()
bool	ScrollBarsByViewPosition ()

Public Attributes
int32_t	ViewWdt
int32_t	ViewHgt
float	BorderLeft
float	BorderTop
float	BorderRight
float	BorderBottom
int32_t	DrawX
int32_t	DrawY
C4TargetFacet	last_game_draw_cgo
C4TargetFacet	last_gui_draw_cgo
bool	fIsNoOwnerViewport

Protected Member Functions
void	DrawPlayerStartup (C4TargetFacet &cgo)
void	Draw (C4TargetFacet &cgo, bool draw_game, bool draw_overlay)
void	DrawOverlay (C4TargetFacet &cgo, const ZoomData &GameZoom)
void	DrawMenu (C4TargetFacet &cgo)
void	DrawPlayerInfo (C4TargetFacet &cgo)
void	InitZoom ()
void	BlitOutput ()
void	AdjustZoomAndPosition ()

Protected Attributes
float	Zoom
float	ZoomTarget
float	ZoomLimitMin
float	ZoomLimitMax
int32_t	ViewportOpenFrame
int32_t	Player
bool	PlayerLock
int32_t	OutX
int32_t	OutY
bool	ResetMenuPositions
C4Viewport *	Next
std::unique_ptr< C4ViewportWindow >	pWindow
std::unique_ptr< C4FoWRegion >	pFoW

Friends
class	C4MouseControl
class	C4ViewportWindow
class	C4ViewportList
class	C4GraphicsSystem
class	C4ConsoleQtViewportView

Detailed Description

Definition at line 29 of file C4Viewport.h.

Constructor & Destructor Documentation

C4Viewport()

C4Viewport::C4Viewport

(

)

Definition at line 102 of file C4Viewport.cpp.

{
    Player = 0;
    viewX = viewY = 0;
    targetViewX = targetViewY = 0;
    ViewWdt = ViewHgt = 0;
    BorderLeft = BorderTop = BorderRight = BorderBottom = 0;
    OutX = OutY = ViewWdt = ViewHgt = 0;
    DrawX = DrawY = 0;
    Zoom = 1.0;
    ZoomTarget = 0.0;
    ViewportOpenFrame = 0;
    ZoomLimitMin = ZoomLimitMax = 0; // no limit
    Next = nullptr;
    PlayerLock = true;
    ResetMenuPositions = false;
    viewOffsX = viewOffsY = 0;
    fIsNoOwnerViewport = false;
}

References BorderBottom, BorderLeft, BorderRight, BorderTop, DrawX, DrawY, fIsNoOwnerViewport, Next, OutX, OutY, Player, PlayerLock, ResetMenuPositions, ViewHgt, ViewportOpenFrame, ViewWdt, Zoom, ZoomLimitMax, ZoomLimitMin, and ZoomTarget.

~C4Viewport()

C4Viewport::~C4Viewport

(

)

Definition at line 122 of file C4Viewport.cpp.

{
    DisableFoW();
    if (pWindow)
    {
        delete pWindow->pSurface;
        pWindow->Clear();
    }
}

References DisableFoW(), and pWindow.

Here is the call graph for this function:

Member Function Documentation

AdjustPosition()

void C4Viewport::AdjustPosition

(

bool

immediate = false

)

Definition at line 653 of file C4Viewport.cpp.

{
    if (ViewWdt == 0 || ViewHgt == 0)
    {
        // zero-sized viewport, possibly minimized editor window
        // don't do anything then
        return;
    }
 
    assert(Zoom > 0);
    assert(ZoomTarget > 0);
 
    float ViewportScrollBorder = fIsNoOwnerViewport ? 0 : float(C4ViewportScrollBorder);
    C4Player *player = ::Players.Get(Player);
 
    // View position
    if (PlayerLock && ValidPlr(Player))
    {
        float scrollRange = 0;
        float extraBoundsX = 0;
        float extraBoundsY = 0;
 
        // target view position (landscape coordinates)
        float targetCenterViewX = fixtof(player->ViewX);
        float targetCenterViewY = fixtof(player->ViewY);
 
        if (player->ViewMode == C4PVM_Scrolling)
        {
            extraBoundsX = extraBoundsY = ViewportScrollBorder;
        }
        else
        {
            scrollRange = std::min(ViewWdt/(10*Zoom),ViewHgt/(10*Zoom));
 
            // if view is close to border, allow scrolling
            if (targetCenterViewX < ViewportScrollBorder)
            {
                extraBoundsX = std::min<float>(ViewportScrollBorder - targetCenterViewX, ViewportScrollBorder);
            }
            else if (targetCenterViewX >= ::Landscape.GetWidth() - ViewportScrollBorder)
            {
                extraBoundsX = std::min<float>(targetCenterViewX - ::Landscape.GetWidth(), 0) + ViewportScrollBorder;
            }
            if (targetCenterViewY < ViewportScrollBorder)
            {
                extraBoundsY = std::min<float>(ViewportScrollBorder - targetCenterViewY, ViewportScrollBorder);
            }
            else if (targetCenterViewY >= ::Landscape.GetHeight() - ViewportScrollBorder)
            {
                extraBoundsY = std::min<float>(targetCenterViewY - ::Landscape.GetHeight(), 0) + ViewportScrollBorder;
            }
        }
 
        extraBoundsX = std::max(extraBoundsX, (ViewWdt/Zoom - ::Landscape.GetWidth())/2 + 1);
        extraBoundsY = std::max(extraBoundsY, (ViewHgt/Zoom - ::Landscape.GetHeight())/2 + 1);
 
        // add mouse auto scroll
        if (player->MouseControl && ::MouseControl.InitCentered && Config.Controls.MouseAutoScroll)
        {
            float strength = Config.Controls.MouseAutoScroll/100.0f;
            targetCenterViewX += strength*(::MouseControl.VpX - ViewWdt/2.0f)/Zoom;
            targetCenterViewY += strength*(::MouseControl.VpY - ViewHgt/2.0f)/Zoom;
        }
        
        // scroll range
        if (!immediate)
        {
            targetCenterViewX = Clamp(targetCenterViewX, targetCenterViewX - scrollRange, targetCenterViewX + scrollRange);
            targetCenterViewY = Clamp(targetCenterViewY, targetCenterViewY - scrollRange, targetCenterViewY + scrollRange);
        }
        // bounds
        targetCenterViewX = Clamp(targetCenterViewX, ViewWdt/Zoom/2 - extraBoundsX, ::Landscape.GetWidth() - ViewWdt/Zoom/2 + extraBoundsX);
        targetCenterViewY = Clamp(targetCenterViewY, ViewHgt/Zoom/2 - extraBoundsY, ::Landscape.GetHeight() - ViewHgt/Zoom/2 + extraBoundsY);
 
        targetViewX = targetCenterViewX - ViewWdt/Zoom/2 + viewOffsX;
        targetViewY = targetCenterViewY - ViewHgt/Zoom/2 + viewOffsY;
        
        if (immediate)
        {
            // immediate scroll
            SetViewX(targetViewX);
            SetViewY(targetViewY);
        }
        else
        {
            // smooth scroll
            int32_t smooth = Clamp<int32_t>(Config.General.ScrollSmooth, 1, 50);
            ScrollView((targetViewX - viewX) / smooth, (targetViewY - viewY) / smooth);
        }
    }
 
    UpdateBordersX();
    UpdateBordersY();
 
    // NO_OWNER can't scroll
    if (fIsNoOwnerViewport)
    {
        viewOffsX = 0;
        viewOffsY = 0;
    }
}

References C4PVM_Scrolling, C4ViewportScrollBorder, Clamp(), Config, C4Config::Controls, fIsNoOwnerViewport, fixtof(), C4Config::General, C4PlayerList::Get(), C4Landscape::GetHeight(), C4Landscape::GetWidth(), C4MouseControl::InitCentered, Landscape, C4ConfigControls::MouseAutoScroll, MouseControl, Player, C4ScriptGuiWindowPropertyName::player, PlayerLock, Players, C4ConfigGeneral::ScrollSmooth, ScrollView(), SetViewX(), SetViewY(), ValidPlr(), ViewHgt, ViewWdt, C4MouseControl::VpX, C4MouseControl::VpY, Zoom, and ZoomTarget.

Referenced by AdjustZoomAndPosition(), and C4Player::SetViewMode().

Here is the call graph for this function:

Here is the caller graph for this function:

AdjustZoomAndPosition()

void C4Viewport::AdjustZoomAndPosition ( )

protected

Definition at line 599 of file C4Viewport.cpp.

{
    // Move zoom towards target zoom
    if (ZoomTarget < 0.000001f)
    {
        CalculateZoom();
    }
    // Change Zoom
 
    if (Zoom != ZoomTarget)
    {
        float DeltaZoom = Zoom / ZoomTarget;
        if (DeltaZoom < 1)
        {
            DeltaZoom = 1 / DeltaZoom;
        }
 
        // Minimal Zoom change factor
        static const float Z0 = pow(C4GFX_ZoomStep, 1.0f / 8.0f);
 
        // We change zoom based on (logarithmic) distance of current zoom
        // to target zoom. The greater the distance the more we adjust the
        // zoom in one frame. There is a minimal zoom change Z0 to make sure
        // we reach ZoomTarget in finite time.
        float ZoomAdjustFactor = Z0 * pow(DeltaZoom, 1.0f / 8.0f);
 
        if (Zoom == 0)
        {
            Zoom = ZoomTarget;
        }
        else
        {
            // Remember old viewport center
            float view_mid_x = this->viewX + float(this->ViewWdt) / Zoom / 2.0f;
            float view_mid_y = this->viewY + float(this->ViewHgt) / Zoom / 2.0f;
 
            if (Zoom < ZoomTarget)
            {
                Zoom = std::min(Zoom * ZoomAdjustFactor, ZoomTarget);
            }
            if (Zoom > ZoomTarget)
            {
                Zoom = std::max(Zoom / ZoomAdjustFactor, ZoomTarget);
            }
 
            // Restore new viewport center
            this->viewX = view_mid_x - float(this->ViewWdt) / Zoom / 2.0f;
            this->viewY = view_mid_y - float(this->ViewHgt) / Zoom / 2.0f;
        }
    }
    // Adjust position
    AdjustPosition(false);
}

References AdjustPosition(), C4GFX_ZoomStep, CalculateZoom(), ViewHgt, ViewWdt, Zoom, and ZoomTarget.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

BlitOutput()

void C4Viewport::BlitOutput ( )

protected

Definition at line 432 of file C4Viewport.cpp.

{
    if (pWindow)
    {
        C4Rect src, dst;
        src.x = DrawX; src.y = DrawY;  src.Wdt = ViewWdt; src.Hgt = ViewHgt;
        dst.x = OutX;  dst.y = OutY;   dst.Wdt = ViewWdt; dst.Hgt = ViewHgt;
        pWindow->pSurface->PageFlip(&src, &dst);
    }
}

References DrawX, DrawY, C4Rect::Hgt, OutX, OutY, pWindow, ViewHgt, ViewWdt, C4Rect::Wdt, C4Rect::x, and C4Rect::y.

Referenced by Execute().

Here is the caller graph for this function:

CalculateZoom()

void C4Viewport::CalculateZoom

(

)

Definition at line 481 of file C4Viewport.cpp.

{
    // Zoom is only initialized by player or global setting during viewport creation time, because after that
    // the player may have changed to another preferred zoom.
    // However, viewports may change multiple times during startup (because of NO_OWNER viewport being deleted
    // and possible other player joins). So check by frame counter. Zoom changes done in paused mode on the
    // player init frame will be lost, but that should not be a problem.
    if(ViewportOpenFrame >= Game.FrameCounter)
    {
        InitZoom();
    }
 
    C4Player *player = Players.Get(Player);
    if (player)
    {
        player->ZoomLimitsToViewport(this);
    }
    else
    {
        SetZoomLimits(0.8*std::min<float>(float(ViewWdt)/::Landscape.GetWidth(),float(ViewHgt)/::Landscape.GetHeight()), 8);
    }
 
}

References C4Game::FrameCounter, Game, C4PlayerList::Get(), C4Landscape::GetHeight(), C4Landscape::GetWidth(), InitZoom(), Landscape, Player, C4ScriptGuiWindowPropertyName::player, Players, SetZoomLimits(), ViewHgt, ViewportOpenFrame, and ViewWdt.

Referenced by AdjustZoomAndPosition(), and SetOutputSize().

Here is the call graph for this function:

Here is the caller graph for this function:

CenterPosition()

void C4Viewport::CenterPosition

(

)

Definition at line 755 of file C4Viewport.cpp.

{
    // center viewport position on map
    // set center position
    SetViewX(::Landscape.GetWidth()/2 + ViewWdt/Zoom/2);
    SetViewY(::Landscape.GetHeight()/2 + ViewHgt/Zoom/2);
}

References C4Landscape::GetHeight(), C4Landscape::GetWidth(), Landscape, SetViewX(), SetViewY(), ViewHgt, ViewWdt, and Zoom.

Referenced by C4ViewportList::CreateViewport().

Here is the call graph for this function:

Here is the caller graph for this function:

ChangeZoom()

void C4Viewport::ChangeZoom

(

float

by_factor

)

Definition at line 519 of file C4Viewport.cpp.

{
    ZoomTarget *= by_factor;
    if (ZoomLimitMin && ZoomTarget < ZoomLimitMin) ZoomTarget = ZoomLimitMin;
    if (ZoomLimitMax && ZoomTarget > ZoomLimitMax) ZoomTarget = ZoomLimitMax;
}

References ZoomLimitMax, ZoomLimitMin, and ZoomTarget.

Referenced by SetZoomLimits().

Here is the caller graph for this function:

ClearPointers()

void C4Viewport::ClearPointers

(

C4Object *

obj

)

Definition at line 957 of file C4Viewport.cpp.

{
 
}

DisableFoW()

void C4Viewport::DisableFoW

(

)

Definition at line 829 of file C4Viewport.cpp.

{
    pFoW.reset();
}

References pFoW.

Referenced by EnableFoW(), and ~C4Viewport().

Here is the caller graph for this function:

Draw()

void C4Viewport::Draw ( C4TargetFacet &  cgo, bool  draw_game, bool  draw_overlay  )

protected

Definition at line 235 of file C4Viewport.cpp.

{
#ifdef USE_CONSOLE
    // No drawing in console mode
    return;
#endif
    C4TargetFacet cgo; cgo.Set(cgo0);
    ZoomData GameZoom;
    GameZoom.X = cgo.X;
    GameZoom.Y = cgo.Y;
    GameZoom.Zoom = cgo.Zoom;
 
    // Draw landscape borders
    if (BorderLeft > 0.0f)   pDraw->BlitSurfaceTile(::GraphicsResource.fctBackground.Surface, cgo.Surface, DrawX, DrawY, BorderLeft, ViewHgt, -DrawX, -DrawY, nullptr);
    if (BorderTop > 0.0f)    pDraw->BlitSurfaceTile(::GraphicsResource.fctBackground.Surface, cgo.Surface, DrawX + BorderLeft, DrawY, ViewWdt - BorderLeft - BorderRight, BorderTop, -DrawX - BorderLeft, -DrawY, nullptr);
    if (BorderRight > 0.0f)  pDraw->BlitSurfaceTile(::GraphicsResource.fctBackground.Surface, cgo.Surface, DrawX + ViewWdt - BorderRight, DrawY, BorderRight, ViewHgt, -DrawX - ViewWdt + BorderRight, -DrawY, nullptr);
    if (BorderBottom > 0.0f) pDraw->BlitSurfaceTile(::GraphicsResource.fctBackground.Surface, cgo.Surface, DrawX + BorderLeft, DrawY + ViewHgt - BorderBottom, ViewWdt - BorderLeft - BorderRight, BorderBottom, -DrawX - BorderLeft, -DrawY - ViewHgt + BorderBottom, nullptr);
 
    // Compute non-bordered viewport area
    cgo.X += BorderLeft;
    cgo.Y += BorderTop;
    cgo.Wdt -= (BorderLeft + BorderRight) / cgo.Zoom;
    cgo.Hgt -= (BorderTop + BorderBottom) / cgo.Zoom;
    cgo.TargetX += BorderLeft / Zoom;
    cgo.TargetY += BorderTop / Zoom;
 
    // Apply Zoom
    GameZoom.X = cgo.X;
    GameZoom.Y = cgo.Y;
    pDraw->SetZoom(GameZoom);
 
    // Set clipper to integer bounds around floating point viewport region
    const FLOAT_RECT clipRect = { DrawX + BorderLeft, DrawX + ViewWdt - BorderRight, DrawY + BorderTop, DrawY + ViewHgt - BorderBottom };
    const C4Rect& clipRectInt(clipRect);
    pDraw->SetPrimaryClipper(clipRectInt.x, clipRectInt.y, clipRectInt.x + clipRectInt.Wdt - 1, clipRectInt.y + clipRectInt.Hgt - 1);
 
    last_game_draw_cgo = cgo;
 
    if (draw_game)
    {
        // --- activate FoW here ---
 
        // Render FoW only if active for player
        C4Player *player = ::Players.Get(Player);
        C4FoWRegion* FoW = nullptr;
        if (player && player->fFogOfWar)
        {
            FoW = this->pFoW.get();
        }
 
        // Update FoW
        if (FoW)
        {
            // Viewport region in landscape coordinates
            const FLOAT_RECT vpRect = { cgo.TargetX, cgo.TargetX + cgo.Wdt, cgo.TargetY, cgo.TargetY + cgo.Hgt };
            // Region in which the light is calculated
            // At the moment, just choose integer coordinates to surround the viewport
            const C4Rect lightRect(vpRect);
            if (!lightRect.Wdt || !lightRect.Hgt)
            {
                // Do not bother initializing FoW on empty region; would cause errors in drawing proc
                FoW = nullptr;
            }
            else
            {
                FoW->Update(lightRect, vpRect);
 
                if (!FoW->Render())
                {
                    // If FoW init fails, do not set it for further drawing
                    FoW = nullptr;
                }
            }
        }
 
        pDraw->SetFoW(FoW);
 
        C4ST_STARTNEW(SkyStat, "C4Viewport::Draw: Sky")
            ::Landscape.GetSky().Draw(cgo);
        C4ST_STOP(SkyStat)
 
            ::Objects.Draw(cgo, Player, -2147483647 - 1 /* INT32_MIN */, 0);
 
        // Draw Landscape
        C4ST_STARTNEW(LandStat, "C4Viewport::Draw: Landscape")
            ::Landscape.Draw(cgo, FoW);
        C4ST_STOP(LandStat)
 
        // draw PXS (unclipped!)
        C4ST_STARTNEW(PXSStat, "C4Viewport::Draw: PXS")
            ::PXS.Draw(cgo);
        C4ST_STOP(PXSStat)
 
        // Draw objects which are behind the particle plane.
        const int particlePlane = 900;
        C4ST_STARTNEW(ObjStat, "C4Viewport::Draw: Objects (1)")
            ::Objects.Draw(cgo, Player, 1, particlePlane);
        C4ST_STOP(ObjStat)
 
        // Draw global dynamic particles on a specific Plane
        // to enable scripters to put objects both behind and in front of particles.
        C4ST_STARTNEW(PartStat, "C4Viewport::Draw: Dynamic Particles")
            ::Particles.DrawGlobalParticles(cgo);
        C4ST_STOP(PartStat)
 
        // Now the remaining objects in front of the particles (e.g. GUI elements)
        C4ST_STARTNEW(Obj2Stat, "C4Viewport::Draw: Objects (2)")
            ::Objects.Draw(cgo, Player, particlePlane + 1, 2147483647 /* INT32_MAX */);
        C4ST_STOP(Obj2Stat)
 
        // Draw everything else without FoW
        pDraw->SetFoW(nullptr);
    }
    else
    {
        pDraw->DrawBoxDw(cgo.Surface, cgo.X, cgo.Y, cgo.X + cgo.Wdt, cgo.Y + cgo.Hgt, 0xff000000);
    }
 
    // Draw PathFinder
    if (::GraphicsSystem.ShowPathfinder)
    {
        Game.PathFinder.Draw(cgo);
    }
 
    // Draw overlay
    if (!Game.C4S.Head.Film || !Game.C4S.Head.Replay)
    {
        Game.DrawCrewOverheadText(cgo, Player);
    }
 
    // Lights overlay
    if (::GraphicsSystem.ShowLights && pFoW)
    {
        pFoW->Render(&cgo);
    }
 
    if (draw_overlay)
    {
        // Determine zoom of overlay
        float gui_zoom = GetGUIZoom();
        // now restore complete cgo range for overlay drawing
        pDraw->SetZoom(DrawX, DrawY, gui_zoom);
        pDraw->SetPrimaryClipper(DrawX, DrawY, DrawX+(ViewWdt-1), DrawY+(ViewHgt-1));
        C4TargetFacet gui_cgo;
        gui_cgo.Set(cgo0);
 
        gui_cgo.X = DrawX;
        gui_cgo.Y = DrawY;
        gui_cgo.Zoom = gui_zoom;
        gui_cgo.Wdt = int(float(ViewWdt)/gui_zoom);
        gui_cgo.Hgt = int(float(ViewHgt)/gui_zoom);
        gui_cgo.TargetX = GetViewX();
        gui_cgo.TargetY = GetViewY();
 
        last_gui_draw_cgo = gui_cgo;
 
        // draw custom GUI objects
        ::Objects.ForeObjects.DrawIfCategory(gui_cgo, Player, C4D_Foreground, false);
 
        // Draw overlay
        C4ST_STARTNEW(OvrStat, "C4Viewport::Draw: Overlay")
 
        if (Application.isEditor)
        {
            ::Console.EditCursor.Draw(cgo);
        }
 
        // Game messages
        C4ST_STARTNEW(MsgStat, "C4Viewport::DrawOverlay: Messages")
        pDraw->SetZoom(0, 0, 1.0);
        ::Messages.Draw(gui_cgo, cgo, Player);
        C4ST_STOP(MsgStat)
 
        // ingame menus
        C4ST_STARTNEW(GuiWindowStat, "C4Viewport::DrawOverlay: Menus")
        pDraw->SetZoom(0, 0, 1.0);
        ::Game.ScriptGuiRoot->DrawAll(gui_cgo, Player);
        C4ST_STOP(GuiWindowStat)
 
        DrawOverlay(gui_cgo, GameZoom);
 
        // Netstats
        if (::GraphicsSystem.ShowNetstatus)
        {
            ::Network.DrawStatus(gui_cgo);
        }
 
        C4ST_STOP(OvrStat)
 
    }
 
    // Remove zoom n clippers
    pDraw->SetZoom(0, 0, 1.0);
    pDraw->NoPrimaryClipper();
 
}

References Application, C4Draw::BlitSurfaceTile(), BorderBottom, BorderLeft, BorderRight, BorderTop, C4D_Foreground, C4Game::C4S, C4ST_STARTNEW, C4ST_STOP, Console, C4EditCursor::Draw(), C4PathFinder::Draw(), C4PXSSystem::Draw(), C4Sky::Draw(), C4Landscape::Draw(), C4ObjectList::Draw(), C4GameMessageList::Draw(), C4Draw::DrawBoxDw(), C4Game::DrawCrewOverheadText(), C4ParticleSystem::DrawGlobalParticles(), C4ObjectList::DrawIfCategory(), DrawOverlay(), C4Network2::DrawStatus(), DrawX, DrawY, C4Console::EditCursor, C4GraphicsResource::fctBackground, C4SHead::Film, C4GameObjects::ForeObjects, Game, C4PlayerList::Get(), GetGUIZoom(), C4Landscape::GetSky(), GetViewX(), GetViewY(), GraphicsResource, GraphicsSystem, C4Scenario::Head, C4Facet::Hgt, C4Rect::Hgt, C4Application::isEditor, Landscape, last_game_draw_cgo, last_gui_draw_cgo, Messages, Network, C4Draw::NoPrimaryClipper(), Objects, Particles, C4Game::PathFinder, pDraw, pFoW, Player, C4ScriptGuiWindowPropertyName::player, Players, PXS, C4FoWRegion::Render(), C4SHead::Replay, C4Game::ScriptGuiRoot, C4TargetFacet::Set(), C4Draw::SetFoW(), C4Draw::SetPrimaryClipper(), C4Draw::SetZoom(), C4GraphicsSystem::ShowLights, C4GraphicsSystem::ShowNetstatus, C4GraphicsSystem::ShowPathfinder, C4Facet::Surface, C4TargetFacet::TargetX, C4TargetFacet::TargetY, C4FoWRegion::Update(), ViewHgt, ViewWdt, C4Facet::Wdt, C4Rect::Wdt, ZoomData::X, C4Facet::X, C4Rect::x, ZoomData::Y, C4Facet::Y, C4Rect::y, Zoom, ZoomData::Zoom, and C4TargetFacet::Zoom.

Referenced by C4GraphicsSystem::DoSaveScreenshot(), and Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

DrawMenu()

void C4Viewport::DrawMenu ( C4TargetFacet &  cgo )

protected

Definition at line 163 of file C4Viewport.cpp.

{
    // Get player
    C4Player *player = ::Players.Get(Player);
 
    // for menus, cgo is using GUI-syntax: TargetX/Y marks the drawing offset; x/y/Wdt/Hgt marks the offset rect
    C4TargetFacet cgo; cgo.Set(cgo0);
    cgo.X = 0;
    cgo.Y = 0;
    cgo.Wdt = cgo0.Wdt * cgo0.Zoom;
    cgo.Hgt = cgo0.Hgt * cgo0.Zoom;
    cgo.TargetX = float(cgo0.X);
    cgo.TargetY = float(cgo0.Y);
    cgo.Zoom = 1;
    pDraw->SetZoom(cgo.X, cgo.Y, cgo.Zoom);
 
    // Player eliminated
    if (player && player->Eliminated)
    {
        pDraw->TextOut(FormatString(LoadResStr(player->Surrendered ? "IDS_PLR_SURRENDERED" :  "IDS_PLR_ELIMINATED"),player->GetName()).getData(),
                                   ::GraphicsResource.FontRegular, 1.0, cgo.Surface,cgo.TargetX+cgo.Wdt/2,cgo.TargetY+2*cgo.Hgt/3,0xfaFF0000,ACenter);
        return;
    }
 
    // Player cursor object menu
    if (player && player->Cursor && player->Cursor->Menu)
    {
        if (ResetMenuPositions)
        {
            player->Cursor->Menu->ResetLocation();
        }
        // if mouse is dragging, make it transparent to easy construction site drag+drop
        bool mouse_dragging = false;
        if (::MouseControl.IsDragging() && ::MouseControl.IsViewport(this))
        {
            mouse_dragging = true;
            pDraw->ActivateBlitModulation(0x4fffffff);
        }
        // draw menu
        player->Cursor->Menu->Draw(cgo);
        // reset modulation for dragging
        if (mouse_dragging)
        {
            pDraw->DeactivateBlitModulation();
        }
    }
    // Player menu
    if (player && player->Menu.IsActive())
    {
        if (ResetMenuPositions)
        {
            player->Menu.ResetLocation();
        }
        player->Menu.Draw(cgo);
    }
    // Fullscreen menu
    if (FullScreen.MainMenu && FullScreen.MainMenu->IsActive())
    {
        if (ResetMenuPositions)
        {
            FullScreen.MainMenu->ResetLocation();
        }
        FullScreen.MainMenu->Draw(cgo);
    }
 
    // Flag done
    ResetMenuPositions = false;
 
    // restore Zoom
    pDraw->SetZoom(cgo0.X, cgo0.Y, cgo0.Zoom);
}

References ACenter, C4Draw::ActivateBlitModulation(), C4Draw::DeactivateBlitModulation(), C4Menu::Draw(), C4GraphicsResource::FontRegular, FormatString(), FullScreen, C4PlayerList::Get(), StdStrBuf::getData(), GraphicsResource, C4Facet::Hgt, C4Menu::IsActive(), C4MouseControl::IsDragging(), C4MouseControl::IsViewport(), LoadResStr(), C4FullScreen::MainMenu, MouseControl, pDraw, Player, C4ScriptGuiWindowPropertyName::player, Players, C4Menu::ResetLocation(), ResetMenuPositions, C4TargetFacet::Set(), C4Draw::SetZoom(), C4Facet::Surface, C4TargetFacet::TargetX, C4TargetFacet::TargetY, C4Draw::TextOut(), C4Facet::Wdt, C4Facet::X, C4Facet::Y, and C4TargetFacet::Zoom.

Referenced by DrawOverlay().

Here is the call graph for this function:

Here is the caller graph for this function:

DrawOverlay()

void C4Viewport::DrawOverlay ( C4TargetFacet &  cgo, const ZoomData &  GameZoom  )

protected

Definition at line 132 of file C4Viewport.cpp.

{
    if (!Game.C4S.Head.Film || !Game.C4S.Head.Replay)
    {
        // Player info
        C4ST_STARTNEW(PInfoStat, "C4Viewport::DrawOverlay: Player Info")
        DrawPlayerInfo(cgo);
        C4ST_STOP(PInfoStat)
        C4ST_STARTNEW(MenuStat, "C4Viewport::DrawOverlay: Menu")
        DrawMenu(cgo);
        C4ST_STOP(MenuStat)
    }
 
    // Control overlays (if not film/replay)
    if (!Game.C4S.Head.Film || !Game.C4S.Head.Replay)
    {
        // Mouse control
        if (::MouseControl.IsViewport(this))
        {
            C4ST_STARTNEW(MouseStat, "C4Viewport::DrawOverlay: Mouse")
            ::MouseControl.Draw(cgo, GameZoom);
            // Draw GUI-mouse in EM if active
            if (pWindow)
            {
                ::pGUI->RenderMouse(cgo);
            }
            C4ST_STOP(MouseStat)
        }
    }
}

References C4Game::C4S, C4ST_STARTNEW, C4ST_STOP, C4MouseControl::Draw(), DrawMenu(), DrawPlayerInfo(), C4SHead::Film, Game, C4Scenario::Head, C4MouseControl::IsViewport(), MouseControl, pGUI, pWindow, C4GUI::Screen::RenderMouse(), and C4SHead::Replay.

Referenced by Draw().

Here is the call graph for this function:

Here is the caller graph for this function:

DrawPlayerInfo()

void C4Viewport::DrawPlayerInfo ( C4TargetFacet &  cgo )

protected

Definition at line 775 of file C4Viewport.cpp.

{
    C4Facet ccgo;
    if (!ValidPlr(Player))
    {
        return;
    }
    // Controls
    DrawPlayerStartup(cgo);
}

References DrawPlayerStartup(), Player, and ValidPlr().

Referenced by DrawOverlay().

Here is the call graph for this function:

Here is the caller graph for this function:

DrawPlayerStartup()

void C4Viewport::DrawPlayerStartup ( C4TargetFacet &  cgo )

protected

Definition at line 848 of file C4Viewport.cpp.

{
    C4Player *player;
    if (!(player = ::Players.Get(Player)))
    {
        return;
    }
    if (!player->LocalControl || !player->ShowStartup)
    {
        return;
    }
    int32_t name_height_offset = 0;
 
    // Control
    // unnecessary with the current control sets
    if (player && player->ControlSet)
    {
        C4Facet controlset_facet = player->ControlSet->GetPicture();
        if (controlset_facet.Wdt)
        {
            controlset_facet.Draw(cgo.Surface,
                cgo.X + (cgo.Wdt - controlset_facet.Wdt)/2,
                cgo.Y + cgo.Hgt * 2/3 + DrawMessageOffset,
                0, 0);
        }
        name_height_offset = GfxR->fctKeyboard.Hgt;
    }
 
    // Name
    pDraw->TextOut(player->GetName(), ::GraphicsResource.FontRegular, 1.0, cgo.Surface,
                               cgo.X+cgo.Wdt/2, cgo.Y+cgo.Hgt*2/3+name_height_offset + DrawMessageOffset,
                               player->ColorDw | 0xff000000, ACenter);
}

References ACenter, C4Facet::Draw(), DrawMessageOffset, C4GraphicsResource::FontRegular, C4PlayerList::Get(), GfxR, GraphicsResource, C4Facet::Hgt, pDraw, Player, C4ScriptGuiWindowPropertyName::player, Players, C4Facet::Surface, C4Draw::TextOut(), C4Facet::Wdt, C4Facet::X, and C4Facet::Y.

Referenced by DrawPlayerInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

DropFile()

void C4Viewport::DropFile	(	const char *	filename,
		float	x,
		float	y
	)

Definition at line 47 of file C4Viewport.cpp.

{
    Game.DropFile(filename, GetViewX()+x/Zoom, GetViewY()+y/Zoom);
}

References C4Game::DropFile(), Game, GetViewX(), GetViewY(), and Zoom.

Here is the call graph for this function:

EnableFoW()

void C4Viewport::EnableFoW

(

)

Definition at line 834 of file C4Viewport.cpp.

{
    if (::Landscape.HasFoW() && Player != NO_OWNER)
    {
        pFoW = std::make_unique<C4FoWRegion>(::Landscape.GetFoW(), ::Players.Get(Player));
    }
    else
    {
        DisableFoW();
    }
}

References DisableFoW(), C4PlayerList::Get(), C4Landscape::GetFoW(), C4Landscape::HasFoW(), Landscape, NO_OWNER, pFoW, Player, and Players.

Referenced by Init().

Here is the call graph for this function:

Here is the caller graph for this function:

Execute()

void C4Viewport::Execute

(

)

Definition at line 443 of file C4Viewport.cpp.

{
    // Adjust position
    AdjustZoomAndPosition();
    // Current graphics output
    C4TargetFacet cgo;
    C4Surface *target = pWindow ? pWindow->pSurface : FullScreen.pSurface;
    cgo.Set(target,DrawX,DrawY,float(ViewWdt)/Zoom,float(ViewHgt)/Zoom,GetViewX(),GetViewY(),Zoom);
    pDraw->PrepareRendering(target);
    // Load script uniforms from Global.Uniforms
    auto uniform_pop = pDraw->scriptUniform.Push(::GameScript.ScenPropList.getPropList());
    // Do not spoil game contents on owner-less viewport
    bool draw_game = true;
    if (Player == NO_OWNER)
    {
        if (!::Application.isEditor && !::Game.DebugMode)
        {
            if (!::Network.isEnabled() || !::Network.Clients.GetLocal() || !::Network.Clients.GetLocal()->isObserver())
            {
                if (::Game.PlayerInfos.GetJoinIssuedPlayerCount() > 0) // free scrolling allowed if the scenario was started explicitely without players to inspect the landscape
                {
                    if (Game.C4S.Landscape.Secret)
                    {
                        draw_game = false;
                    }
                }
            }
        }
    }
    // Draw
    Draw(cgo, draw_game, true);
    // Blit output
    BlitOutput();
}

References AdjustZoomAndPosition(), Application, BlitOutput(), C4Game::C4S, C4Network2::Clients, C4Game::DebugMode, Draw(), DrawX, DrawY, FullScreen, Game, GameScript, C4PlayerInfoList::GetJoinIssuedPlayerCount(), C4Network2ClientList::GetLocal(), C4Value::getPropList(), GetViewX(), GetViewY(), C4Application::isEditor, C4Network2::isEnabled(), C4Network2Client::isObserver(), C4Scenario::Landscape, Network, NO_OWNER, pDraw, Player, C4Game::PlayerInfos, C4Draw::PrepareRendering(), C4Window::pSurface, C4ScriptUniform::Push(), pWindow, C4GameScriptHost::ScenPropList, C4Draw::scriptUniform, C4SLandscape::Secret, C4TargetFacet::Set(), ViewHgt, ViewWdt, and Zoom.

Referenced by C4ViewportWindow::PerformUpdate().

Here is the call graph for this function:

Here is the caller graph for this function:

GetGUIZoom()

float C4Viewport::GetGUIZoom ( ) const

inline

Definition at line 50 of file C4Viewport.h.

{ return Clamp<float>(float(ViewWdt)/1280, 0.5f, 1.0f); }

References ViewWdt.

Referenced by Draw(), C4MouseControl::Move(), and C4ScriptGuiWindow::OnMouseIn().

Here is the caller graph for this function:

GetNext()

C4Viewport* C4Viewport::GetNext ( )

inline

Definition at line 69 of file C4Viewport.h.

{ return Next; }

References Next.

Referenced by C4Menu::GetViewport().

Here is the caller graph for this function:

GetOutputRect()

C4Rect C4Viewport::GetOutputRect ( )

inline

Definition at line 67 of file C4Viewport.h.

{ return C4Rect(OutX, OutY, ViewWdt, ViewHgt); }

References OutX, OutY, ViewHgt, and ViewWdt.

Referenced by C4GUI::Dialog::ApplyElementOffset(), C4GUI::Dialog::ApplyInvElementOffset(), C4GUI::Screen::MouseInput(), and C4MouseControl::Move().

Here is the caller graph for this function:

GetPlayer()

int32_t C4Viewport::GetPlayer ( )

inline

Definition at line 70 of file C4Viewport.h.

{ return Player; }

References Player.

Referenced by C4MainMenu::DoRefillInternal().

Here is the caller graph for this function:

GetPlayerLock()

bool C4Viewport::GetPlayerLock ( )

inline

Definition at line 65 of file C4Viewport.h.

{ return PlayerLock; }

References PlayerLock.

GetViewCenterX()

float C4Viewport::GetViewCenterX ( )

inline

Return x-position of the center of viewport in landscape coordinates

Definition at line 80 of file C4Viewport.h.

{ return viewX + ViewWdt/Zoom/2; }

References ViewWdt, and Zoom.

GetViewCenterY()

float C4Viewport::GetViewCenterY ( )

inline

Return y-position of the center of viewport in landscape coordinates

Definition at line 82 of file C4Viewport.h.

{ return viewY + ViewHgt/Zoom/2; }

References ViewHgt, and Zoom.

GetViewX()

float C4Viewport::GetViewX ( )

inline

Return x-position of upper left corner of viewport in landscape coordinates

Definition at line 76 of file C4Viewport.h.

{ return viewX; }

Referenced by Draw(), DropFile(), Execute(), C4MouseControl::Move(), and WindowToGameX().

Here is the caller graph for this function:

GetViewY()

float C4Viewport::GetViewY ( )

inline

Return y-position of upper left corner of viewport in landscape coordinates

Definition at line 78 of file C4Viewport.h.

{ return viewY; }

Referenced by Draw(), DropFile(), Execute(), C4MouseControl::Move(), and WindowToGameY().

Here is the caller graph for this function:

GetWindow()

C4ViewportWindow* C4Viewport::GetWindow ( )

inline

Definition at line 126 of file C4Viewport.h.

{return pWindow.get();}

References pWindow.

GetZoom() [1/2]

float C4Viewport::GetZoom ( )

inline

Definition at line 48 of file C4Viewport.h.

{ return Zoom; }

References Zoom.

Referenced by C4ViewportWindow::EditCursorMove().

Here is the caller graph for this function:

GetZoom() [2/2]

float C4Viewport::GetZoom ( ) const

inline

Definition at line 124 of file C4Viewport.h.

{ return Zoom; }

References Zoom.

GetZoomByViewRange()

float C4Viewport::GetZoomByViewRange	(	int32_t	size_x,
		int32_t	size_y
	)		const

Definition at line 558 of file C4Viewport.cpp.

{
    // set zoom such that both size_x and size_y are guarantueed to fit into the viewport range
    // determine whether zoom is to be calculated by x or by y
    bool zoom_by_y = false;
    if (size_x && size_y)
    {
        zoom_by_y = (size_y * ViewWdt > size_x * ViewHgt);
    }
    else if (size_y)
    {
        // no x size passed - zoom by y
        zoom_by_y = true;
    }
    else
    {
        // 0/0 size passed - zoom to default
        if (!size_x)
        {
            size_x = C4VP_DefViewRangeX * 2;
        }
        zoom_by_y = false;
    }
    // zoom calculation
    if (zoom_by_y)
    {
        return float(ViewHgt) / size_y;
    }
    else
    {
        return float(ViewWdt) / size_x;
    }
}

References ViewHgt, and ViewWdt.

Referenced by C4Player::ZoomLimitsToViewport(), and C4Player::ZoomToViewport().

Here is the caller graph for this function:

GetZoomLimitMax()

float C4Viewport::GetZoomLimitMax ( ) const

inline

Definition at line 60 of file C4Viewport.h.

{ return ZoomLimitMax; }

References ZoomLimitMax.

GetZoomLimitMin()

float C4Viewport::GetZoomLimitMin ( ) const

inline

Definition at line 59 of file C4Viewport.h.

{ return ZoomLimitMin; }

References ZoomLimitMin.

GetZoomTarget()

float C4Viewport::GetZoomTarget ( ) const

inline

Definition at line 61 of file C4Viewport.h.

{ return ZoomTarget; }

References ZoomTarget.

Init()

bool C4Viewport::Init	(	int32_t	for_player,
		bool	set_temporary_only
	)

Definition at line 786 of file C4Viewport.cpp.

{
    // Fullscreen viewport initialization
    // Set Player
    if (!ValidPlr(for_player))
    {
        for_player = NO_OWNER;
    }
    Player = for_player;
    ViewportOpenFrame = Game.FrameCounter;
    if (!set_temporary_only) fIsNoOwnerViewport = (for_player == NO_OWNER);
    if (Application.isEditor)
    {
        // Console viewport initialization
        // Create window
        pWindow = std::make_unique<C4ViewportWindow>(this);
        if (!pWindow->Init(Player))
        {
            return false;
        }
        UpdateOutputSize();
        // Disable player lock on unowned viewports
        if (!ValidPlr(Player))
        {
            TogglePlayerLock();
        }
        // Don't call Execute right away since it is not yet guaranteed that
        // the Player has set this as its Viewport, and the drawing routines rely
        // on that.
    }
    else
    {
        // Owned viewport: clear any flash message explaining observer menu
        if (ValidPlr(for_player))
        {
            ::GraphicsSystem.FlashMessage("");
        }
    }
 
    EnableFoW();
    return true;
}

References Application, EnableFoW(), fIsNoOwnerViewport, C4GraphicsSystem::FlashMessage(), C4Game::FrameCounter, Game, GraphicsSystem, C4Application::isEditor, NO_OWNER, Player, pWindow, TogglePlayerLock(), UpdateOutputSize(), ValidPlr(), and ViewportOpenFrame.

Referenced by C4ViewportList::CreateViewport(), C4MainMenu::MenuCommand(), NextPlayer(), and C4FullScreen::ViewportCheck().

Here is the call graph for this function:

Here is the caller graph for this function:

InitZoom()

void C4Viewport::InitZoom ( )

protected

Definition at line 505 of file C4Viewport.cpp.

{
    C4Player *player = Players.Get(Player);
    if (player)
    {
        player->ZoomToViewport(this, true);
    }
    else
    {
        ZoomTarget = std::max<float>(float(ViewWdt)/::Landscape.GetWidth(), 1.0f);
        Zoom = ZoomTarget;
    }
}

References C4PlayerList::Get(), C4Landscape::GetWidth(), Landscape, Player, C4ScriptGuiWindowPropertyName::player, Players, ViewWdt, Zoom, and ZoomTarget.

Referenced by CalculateZoom().

Here is the call graph for this function:

Here is the caller graph for this function:

IsViewportMenu()

bool C4Viewport::IsViewportMenu

(

class C4Menu *

menu

)

Definition at line 994 of file C4Viewport.cpp.

{
    // check all associated menus
    // Get player
    C4Player *player = ::Players.Get(Player);
    // Player eliminated: No menu
    if (player && player->Eliminated)
    {
        return false;
    }
    // Player cursor object menu
    if (player && player->Cursor && player->Cursor->Menu == menu)
    {
        return true;
    }
    // Player menu
    if (player && player->Menu.IsActive() && &(player->Menu) == menu)
    {
        return true;
    }
    // Fullscreen menu (if active, only one viewport can exist)
    if (FullScreen.MainMenu && FullScreen.MainMenu->IsActive() && FullScreen.MainMenu == menu)
    {
        return true;
    }
    // no match
    return false;
}

References FullScreen, C4PlayerList::Get(), C4Menu::IsActive(), C4FullScreen::MainMenu, Player, C4ScriptGuiWindowPropertyName::player, and Players.

Here is the call graph for this function:

NextPlayer()

void C4Viewport::NextPlayer

(

)

Definition at line 962 of file C4Viewport.cpp.

{
    C4Player *player;
    int32_t player_nr;
    if (!(player = ::Players.Get(Player)))
    {
        if (!(player = ::Players.First))
        {
            return;
        }
    }
    else if (!(player = player->Next))
    {
        if (Game.C4S.Head.Film && Game.C4S.Head.Replay)
        {
            player = ::Players.First; // cycle to first in film mode only; in network obs mode allow NO_OWNER-view
        }
    }
    if (player)
    {
        player_nr = player->Number;
    }
    else
    {
        player_nr = NO_OWNER;
    }
    if (player_nr != Player)
    {
        Init(player_nr, true);
    }
}

References C4Game::C4S, C4SHead::Film, C4PlayerList::First, Game, C4PlayerList::Get(), C4Scenario::Head, Init(), NO_OWNER, Player, C4ScriptGuiWindowPropertyName::player, Players, and C4SHead::Replay.

Referenced by C4ViewportList::ViewportNextPlayer().

Here is the call graph for this function:

Here is the caller graph for this function:

ScrollBarsByViewPosition()

bool C4Viewport::ScrollBarsByViewPosition

(

)

Definition at line 710 of file C4Console.cpp.

{return false;}

Referenced by UpdateOutputSize().

Here is the caller graph for this function:

ScrollView()

void C4Viewport::ScrollView	(	float	by_x,
		float	by_y
	)

Scroll the viewport by x,y

Definition at line 882 of file C4Viewport.cpp.

{
    SetViewX(viewX + by_x);
    SetViewY(viewY + by_y);
}

References SetViewX(), and SetViewY().

Referenced by AdjustPosition(), C4ViewportList::FreeScroll(), C4MouseControl::ScrollView(), SetOutputSize(), and UpdateOutputSize().

Here is the call graph for this function:

Here is the caller graph for this function:

SetOutputSize()

void C4Viewport::SetOutputSize	(	int32_t	draw_x,
		int32_t	draw_y,
		int32_t	out_x,
		int32_t	out_y,
		int32_t	out_wdt,
		int32_t	out_hgt
	)

Definition at line 926 of file C4Viewport.cpp.

{
    int32_t deltaWidth = ViewWdt - out_wdt;
    int32_t deltaHeight = ViewHgt - out_hgt;
 
    // update output parameters
    DrawX = draw_x;
    DrawY = draw_y;
    OutX = out_x;
    OutY = out_y;
    ViewWdt = out_wdt;
    ViewHgt = out_hgt;
    // update view position: Remain centered at previous position
    // scrolling the view must be done after setting the new view width and height
    ScrollView(deltaWidth/2, deltaHeight/2);
    CalculateZoom();
    // Reset menus
    ResetMenuPositions = true;
    // player uses mouse control? then clip the cursor
    C4Player *player;
    if ((player = ::Players.Get(Player)))
    {
        if (player->MouseControl)
        {
            ::MouseControl.UpdateClip();
            // and inform GUI
            ::pGUI->SetPreferredDlgRect(C4Rect(out_x, out_y, out_wdt, out_hgt));
        }
    }
}

References CalculateZoom(), DrawX, DrawY, C4PlayerList::Get(), MouseControl, OutX, OutY, pGUI, Player, C4ScriptGuiWindowPropertyName::player, Players, ResetMenuPositions, ScrollView(), C4GUI::Screen::SetPreferredDlgRect(), C4MouseControl::UpdateClip(), ViewHgt, and ViewWdt.

Referenced by C4GraphicsSystem::DoSaveScreenshot(), and C4ViewportList::RecalculateViewports().

Here is the call graph for this function:

Here is the caller graph for this function:

SetViewOffset()

void C4Viewport::SetViewOffset ( int32_t  x, int32_t  y  )

inline

Set the view offset of the normal viewport center. Used by C4Script function SetViewOffset.

Definition at line 94 of file C4Viewport.h.

{ viewOffsX = x; viewOffsY = y; }

SetViewX()

void C4Viewport::SetViewX

(

float

x

)

Set the view position.

Definition at line 888 of file C4Viewport.cpp.

{
    viewX = x;
 
    if (fIsNoOwnerViewport)
    {
        if(::Landscape.GetWidth() < ViewWdt / Zoom)
        {
            viewX = ::Landscape.GetWidth()/2 - ViewWdt / Zoom / 2;
        }
        else
        {
            viewX = Clamp(x, 0.0f, ::Landscape.GetWidth() - ViewWdt / Zoom);
        }
    }
 
    UpdateBordersX();
}

References Clamp(), fIsNoOwnerViewport, C4Landscape::GetWidth(), Landscape, ViewWdt, and Zoom.

Referenced by AdjustPosition(), CenterPosition(), and ScrollView().

Here is the call graph for this function:

Here is the caller graph for this function:

SetViewY()

void C4Viewport::SetViewY

(

float

y

)

Definition at line 907 of file C4Viewport.cpp.

{
    viewY = y;
 
    if (fIsNoOwnerViewport)
    {
        if(::Landscape.GetHeight() < ViewHgt / Zoom)
        {
            viewY = ::Landscape.GetHeight()/2 - ViewHgt / Zoom / 2;
        }
        else
        {
            viewY = Clamp(y, 0.0f, ::Landscape.GetHeight() - ViewHgt / Zoom);
        }
    }
 
    UpdateBordersY();
}

References Clamp(), fIsNoOwnerViewport, C4Landscape::GetHeight(), Landscape, ViewHgt, and Zoom.

Referenced by AdjustPosition(), CenterPosition(), and ScrollView().

Here is the call graph for this function:

Here is the caller graph for this function:

SetZoom() [1/2]

void C4Viewport::SetZoom	(	float	to_zoom,
		bool	direct = false
	)

Definition at line 526 of file C4Viewport.cpp.

{
    ZoomTarget = to_value;
    if (Player != NO_OWNER || !::Application.isEditor)
    {
        if (ZoomLimitMin && ZoomTarget < ZoomLimitMin)
        {
            ZoomTarget = ZoomLimitMin;
        }
        if (ZoomLimitMax && ZoomTarget > ZoomLimitMax)
        {
            ZoomTarget = ZoomLimitMax;
        }
    }
    // direct: Set zoom without scrolling to it
    if (direct)
    {
        Zoom = ZoomTarget;
    }
}

References Application, C4Application::isEditor, NO_OWNER, Player, Zoom, ZoomLimitMax, ZoomLimitMin, and ZoomTarget.

SetZoom() [2/2]

void C4Viewport::SetZoom

(

float

zoom_value

)

Definition at line 592 of file C4Viewport.cpp.

{
    Zoom = zoom_value;
    // also set target to prevent zoom from changing back
    ZoomTarget = zoom_value;
}

References Zoom, and ZoomTarget.

SetZoomLimits()

void C4Viewport::SetZoomLimits	(	float	to_min_zoom,
		float	to_max_zoom
	)

Definition at line 547 of file C4Viewport.cpp.

{
    ZoomLimitMin = to_min_zoom;
    ZoomLimitMax = to_max_zoom;
    if (ZoomLimitMax && ZoomLimitMax < ZoomLimitMin)
    {
        ZoomLimitMax = ZoomLimitMin;
    }
    ChangeZoom(1); // Constrains zoom to limit.
}

References ChangeZoom(), ZoomLimitMax, and ZoomLimitMin.

Referenced by CalculateZoom().

Here is the call graph for this function:

Here is the caller graph for this function:

TogglePlayerLock()

bool C4Viewport::TogglePlayerLock

(

)

Definition at line 711 of file C4Console.cpp.

{return false;}

Referenced by Init().

Here is the caller graph for this function:

UpdateOutputSize()

bool C4Viewport::UpdateOutputSize	(	int32_t	new_width = 0,
		int32_t	new_height = 0
	)

Definition at line 52 of file C4Viewport.cpp.

{
    if (!pWindow)
    {
        return false;
    }
    // Output size
    C4Rect rect;
    if (new_width)
    {
        rect.x = rect.y = 0;
        rect.Wdt = new_width;
        rect.Hgt = new_height;
    }
    else
    {
#if defined(WITH_QT_EDITOR)
        // Never query the window - size is always passed from Qt.
        return false;
#else
        if (!pWindow->GetSize(&rect))
        {
            return false;
        }
#endif
    }
    OutX = rect.x;
    OutY = rect.y;
    ViewWdt = rect.Wdt;
    ViewHgt = rect.Hgt;
    ScrollView(0,0);
    // Scroll bars
    ScrollBarsByViewPosition();
    // Reset menus
    ResetMenuPositions = true;
    // update internal GL size
    if (pWindow && pWindow->pSurface)
    {
        pWindow->pSurface->UpdateSize(ViewWdt, ViewHgt);
    }
    // Update zoom limits based on new size
    C4Player *player = ::Players.Get(Player);
    if (player)
    {
        player->ZoomLimitsToViewport(this);
    }
    // Done
    return true;
}

References C4PlayerList::Get(), C4Rect::Hgt, OutX, OutY, Player, C4ScriptGuiWindowPropertyName::player, Players, pWindow, ResetMenuPositions, ScrollBarsByViewPosition(), ScrollView(), ViewHgt, ViewWdt, C4Rect::Wdt, C4Rect::x, and C4Rect::y.

Referenced by Init(), and C4ViewportWindow::PerformUpdate().

Here is the call graph for this function:

Here is the caller graph for this function:

ViewPositionByScrollBars()

bool C4Viewport::ViewPositionByScrollBars

(

)

WindowToGameX()

float C4Viewport::WindowToGameX ( int32_t  win_x )

inline

Definition at line 85 of file C4Viewport.h.

{ return GetViewX() + float(win_x) / Zoom; }

References GetViewX(), and Zoom.

Referenced by C4ViewportWindow::EditCursorMove().

Here is the call graph for this function:

Here is the caller graph for this function:

WindowToGameY()

float C4Viewport::WindowToGameY ( int32_t  win_y )

inline

Definition at line 86 of file C4Viewport.h.

{ return GetViewY() + float(win_y) / Zoom; }

References GetViewY(), and Zoom.

Referenced by C4ViewportWindow::EditCursorMove().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

C4ConsoleQtViewportView

friend class C4ConsoleQtViewportView

friend

Definition at line 141 of file C4Viewport.h.

C4GraphicsSystem

friend class C4GraphicsSystem

friend

Definition at line 140 of file C4Viewport.h.

C4MouseControl

friend class C4MouseControl

friend

Definition at line 31 of file C4Viewport.h.

C4ViewportList

friend class C4ViewportList

friend

Definition at line 139 of file C4Viewport.h.

C4ViewportWindow

friend class C4ViewportWindow

friend

Definition at line 138 of file C4Viewport.h.

Member Data Documentation

BorderBottom

float C4Viewport::BorderBottom

Definition at line 39 of file C4Viewport.h.

Referenced by C4Viewport(), C4GraphicsSystem::DoSaveScreenshot(), and Draw().

BorderLeft

float C4Viewport::BorderLeft

Definition at line 39 of file C4Viewport.h.

Referenced by C4Viewport(), C4GraphicsSystem::DoSaveScreenshot(), and Draw().

BorderRight

float C4Viewport::BorderRight

Definition at line 39 of file C4Viewport.h.

Referenced by C4Viewport(), C4GraphicsSystem::DoSaveScreenshot(), and Draw().

BorderTop

float C4Viewport::BorderTop

Definition at line 39 of file C4Viewport.h.

Referenced by C4Viewport(), C4GraphicsSystem::DoSaveScreenshot(), and Draw().

DrawX

int32_t C4Viewport::DrawX

Definition at line 40 of file C4Viewport.h.

Referenced by BlitOutput(), C4Viewport(), Draw(), Execute(), and SetOutputSize().

DrawY

int32_t C4Viewport::DrawY

Definition at line 41 of file C4Viewport.h.

Referenced by BlitOutput(), C4Viewport(), Draw(), Execute(), and SetOutputSize().

fIsNoOwnerViewport

bool C4Viewport::fIsNoOwnerViewport

Definition at line 46 of file C4Viewport.h.

Referenced by AdjustPosition(), C4Viewport(), Init(), C4ObjectMenu::IsReadOnly(), SetViewX(), and SetViewY().

last_game_draw_cgo

C4TargetFacet C4Viewport::last_game_draw_cgo

Definition at line 43 of file C4Viewport.h.

Referenced by Draw(), and C4MouseControl::Move().

last_gui_draw_cgo

C4TargetFacet C4Viewport::last_gui_draw_cgo

Definition at line 44 of file C4Viewport.h.

Referenced by Draw(), and C4MouseControl::Move().

Next

C4Viewport* C4Viewport::Next

protected

Definition at line 112 of file C4Viewport.h.

Referenced by C4Viewport(), C4ViewportList::Clear(), C4ViewportList::ClearPointers(), C4ViewportList::CloseViewport(), C4ViewportList::CreateViewport(), C4ViewportList::DisableFoW(), C4ViewportList::EnableFoW(), C4ViewportList::Execute(), C4ViewportList::GetAudibility(), GetNext(), C4ViewportList::GetViewport(), C4ViewportList::GetViewportCount(), C4ViewportList::MouseMoveToViewport(), C4ViewportList::RecalculateViewports(), C4ViewportList::SortViewportsByPlayerControl(), C4ViewportList::ViewportZoomIn(), and C4ViewportList::ViewportZoomOut().

OutX

int32_t C4Viewport::OutX

protected

Definition at line 110 of file C4Viewport.h.

Referenced by BlitOutput(), C4Viewport(), GetOutputRect(), C4MouseControl::Move(), SetOutputSize(), C4MouseControl::UpdateClip(), and UpdateOutputSize().

OutY

int32_t C4Viewport::OutY

protected

Definition at line 110 of file C4Viewport.h.

Referenced by BlitOutput(), C4Viewport(), GetOutputRect(), C4MouseControl::Move(), SetOutputSize(), C4MouseControl::UpdateClip(), and UpdateOutputSize().

pFoW

std::unique_ptr<C4FoWRegion> C4Viewport::pFoW

protected

Definition at line 114 of file C4Viewport.h.

Referenced by DisableFoW(), Draw(), and EnableFoW().

Player

int32_t C4Viewport::Player

protected

Definition at line 108 of file C4Viewport.h.

Referenced by AdjustPosition(), C4Viewport(), CalculateZoom(), C4GraphicsSystem::DoSaveScreenshot(), Draw(), DrawMenu(), DrawPlayerInfo(), DrawPlayerStartup(), EnableFoW(), Execute(), GetPlayer(), Init(), InitZoom(), IsViewportMenu(), NextPlayer(), SetOutputSize(), SetZoom(), and UpdateOutputSize().

PlayerLock

bool C4Viewport::PlayerLock

protected

Definition at line 109 of file C4Viewport.h.

Referenced by AdjustPosition(), C4Viewport(), and GetPlayerLock().

pWindow

std::unique_ptr<C4ViewportWindow> C4Viewport::pWindow

protected

Definition at line 113 of file C4Viewport.h.

Referenced by BlitOutput(), DrawOverlay(), Execute(), GetWindow(), Init(), UpdateOutputSize(), and ~C4Viewport().

ResetMenuPositions

bool C4Viewport::ResetMenuPositions

protected

Definition at line 111 of file C4Viewport.h.

Referenced by C4Viewport(), DrawMenu(), SetOutputSize(), and UpdateOutputSize().

ViewHgt

int32_t C4Viewport::ViewHgt

Definition at line 37 of file C4Viewport.h.

Referenced by AdjustPosition(), AdjustZoomAndPosition(), BlitOutput(), C4Viewport(), CalculateZoom(), CenterPosition(), Draw(), Execute(), GetOutputRect(), GetViewCenterY(), GetZoomByViewRange(), C4MouseControl::Move(), SetOutputSize(), SetViewY(), C4MouseControl::UpdateClip(), UpdateOutputSize(), and C4MouseControl::UpdateScrolling().

ViewportOpenFrame

int32_t C4Viewport::ViewportOpenFrame

protected

Definition at line 107 of file C4Viewport.h.

Referenced by C4Viewport(), CalculateZoom(), and Init().

ViewWdt

int32_t C4Viewport::ViewWdt

Definition at line 36 of file C4Viewport.h.

Referenced by AdjustPosition(), AdjustZoomAndPosition(), BlitOutput(), C4Viewport(), CalculateZoom(), CenterPosition(), Draw(), Execute(), GetGUIZoom(), GetOutputRect(), GetViewCenterX(), GetZoomByViewRange(), InitZoom(), C4MouseControl::Move(), SetOutputSize(), SetViewX(), C4MouseControl::UpdateClip(), UpdateOutputSize(), and C4MouseControl::UpdateScrolling().

Zoom

float C4Viewport::Zoom

protected

Definition at line 104 of file C4Viewport.h.

Referenced by AdjustPosition(), AdjustZoomAndPosition(), C4Viewport(), CenterPosition(), Draw(), DropFile(), Execute(), GetViewCenterX(), GetViewCenterY(), GetZoom(), InitZoom(), C4MouseControl::Move(), SetViewX(), SetViewY(), SetZoom(), C4MouseControl::UpdateScrolling(), WindowToGameX(), and WindowToGameY().

ZoomLimitMax

float C4Viewport::ZoomLimitMax

protected

Definition at line 106 of file C4Viewport.h.

Referenced by C4Viewport(), ChangeZoom(), GetZoomLimitMax(), SetZoom(), and SetZoomLimits().

ZoomLimitMin

float C4Viewport::ZoomLimitMin

protected

Definition at line 106 of file C4Viewport.h.

Referenced by C4Viewport(), ChangeZoom(), GetZoomLimitMin(), SetZoom(), and SetZoomLimits().

ZoomTarget

float C4Viewport::ZoomTarget

protected

Definition at line 105 of file C4Viewport.h.

Referenced by AdjustPosition(), AdjustZoomAndPosition(), C4Viewport(), ChangeZoom(), GetZoomTarget(), InitZoom(), and SetZoom().

---

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

• C4Viewport.h
• C4Console.cpp
• C4Viewport.cpp