AxioDL
/
metaforce
mirror of https://github.com/AxioDL/metaforce.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

CGraphics: Viewport fixes

This commit is contained in:
Phillip Stephens 2022-02-27 14:46:15 -08:00
parent fb69d3fdba
commit 44f9d6648a
Signed by: Antidote
GPG Key ID: F8BEE4C83DACA60D
30 changed files with 340 additions and 333 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
NESEmulator/CNESEmulator.cpp
View File

@ -767,7 +767,7 @@ void CNESEmulator::Draw(const zeus::CColor& mulColor, bool filtering) {
if (!EmulatorInst)
return;
float widthFac = NESAspect / g_Viewport.aspect;
float widthFac = NESAspect / CGraphics::GetViewportAspect();
Uniform uniform = {zeus::CMatrix4f{}, mulColor};
uniform.m_matrix[0][0] = widthFac;

10
Runtime/AutoMapper/CAutoMapper.cpp
View File

@ -821,7 +821,7 @@ void CAutoMapper::ProcessMapScreenInput(const CFinalInput& input, CStateManager&
} else {
m_mouseDelta = mouseCoord - *m_lastMouseCoord;
m_lastMouseCoord.emplace(mouseCoord);
m_mouseDelta.x() *= g_Viewport.aspect;
m_mouseDelta.x() *= CGraphics::GetViewportAspect();
m_mouseDelta *= 100.f;
}
}
@ -902,14 +902,14 @@ std::pair<int, int> CAutoMapper::FindClosestVisibleWorld(const zeus::CVector3f&
}
zeus::CVector2i CAutoMapper::GetMiniMapViewportSize() {
float scaleX = g_Viewport.x8_width / 640.f;
float scaleY = g_Viewport.xc_height / 480.f;
float scaleX = CGraphics::GetViewportWidth() / 640.f;
float scaleY = CGraphics::GetViewportHeight() / 480.f;
return {int(scaleX * g_tweakAutoMapper->GetMiniMapViewportWidth()),
int(scaleY * g_tweakAutoMapper->GetMiniMapViewportHeight())};
}
zeus::CVector2i CAutoMapper::GetMapScreenViewportSize() {
return {int(g_Viewport.x8_width), int(g_Viewport.xc_height)};
return {int(CGraphics::GetViewportWidth()), int(CGraphics::GetViewportHeight())};
}
float CAutoMapper::GetMapAreaMaxDrawDepth(const CStateManager&, TAreaId aid) const {
@ -1170,7 +1170,7 @@ void CAutoMapper::Update(float dt, CStateManager& mgr) {
x320_bottomPanePos = std::max(0.f, std::min(x320_bottomPanePos, 1.f));
if (x30c_basewidget_leftPane) {
float vpAspectRatio = std::max(1.78f, g_Viewport.aspect);
float vpAspectRatio = std::max(1.78f, CGraphics::GetViewportAspect());
x30c_basewidget_leftPane->SetLocalTransform(
zeus::CTransform::Translate(x318_leftPanePos * vpAspectRatio * -9.f, 0.f, 0.f) *
x30c_basewidget_leftPane->GetTransform());

16
Runtime/CStateManager.cpp
View File

@ -504,8 +504,8 @@ void CStateManager::DrawReflection(const zeus::CVector3f& reflectPoint) {
CGraphics::SetViewPointMatrix(look);
const CGraphics::CProjectionState backupProj = CGraphics::GetProjectionState();
const CGameCamera* cam = x870_cameraManager->GetCurrentCamera(*this);
g_Renderer->SetPerspective(cam->GetFov(), g_Viewport.x8_width, g_Viewport.xc_height, cam->GetNearClipDistance(),
cam->GetFarClipDistance());
g_Renderer->SetPerspective(cam->GetFov(), CGraphics::GetViewportWidth(), CGraphics::GetViewportHeight(),
cam->GetNearClipDistance(), cam->GetFarClipDistance());
x84c_player->RenderReflectedPlayer(*this);
@ -707,18 +707,18 @@ void CStateManager::ResetViewAfterDraw(const SViewport& backupViewport,
const CGameCamera* cam = x870_cameraManager->GetCurrentCamera(*this);
zeus::CFrustum frustum;
frustum.updatePlanes(backupViewMatrix, zeus::SProjPersp(zeus::degToRad(cam->GetFov()), g_Viewport.aspect,
frustum.updatePlanes(backupViewMatrix, zeus::SProjPersp(zeus::degToRad(cam->GetFov()), CGraphics::GetViewportAspect(),
cam->GetNearClipDistance(), cam->GetFarClipDistance()));
g_Renderer->SetClippingPlanes(frustum);
g_Renderer->SetPerspective(cam->GetFov(), g_Viewport.x8_width, g_Viewport.xc_height, cam->GetNearClipDistance(),
cam->GetFarClipDistance());
g_Renderer->SetPerspective(cam->GetFov(), CGraphics::GetViewportWidth(), CGraphics::GetViewportHeight(),
cam->GetNearClipDistance(), cam->GetFarClipDistance());
}
void CStateManager::DrawWorld() {
SCOPED_GRAPHICS_DEBUG_GROUP("CStateManager::DrawWorld", zeus::skBlue);
const CTimeProvider timeProvider(xf14_curTimeMod900);
const SViewport backupViewport = g_Viewport;
const SViewport backupViewport = CGraphics::g_Viewport;
/* Area camera is in (not necessarily player) */
const TAreaId visAreaId = GetVisAreaId();
@ -727,7 +727,7 @@ void CStateManager::DrawWorld() {
DrawWorldCubeFaces();
const zeus::CFrustum frustum = SetupViewForDraw(g_Viewport);
const zeus::CFrustum frustum = SetupViewForDraw(CGraphics::g_Viewport);
const zeus::CTransform backupViewMatrix = CGraphics::g_ViewMatrix;
int areaCount = 0;
@ -1196,7 +1196,7 @@ void CStateManager::PreRender() {
}
SCOPED_GRAPHICS_DEBUG_GROUP("CStateManager::PreRender", zeus::skBlue);
const zeus::CFrustum frustum = SetupDrawFrustum(g_Viewport);
const zeus::CFrustum frustum = SetupDrawFrustum(CGraphics::g_Viewport);
x86c_stateManagerContainer->xf370_.clear();
x86c_stateManagerContainer->xf39c_renderLast.clear();
xf7c_projectedShadow = nullptr;

19
Runtime/Graphics/CGraphics.hpp
View File

@ -52,8 +52,6 @@ struct SViewport {
float aspect;
};
extern SViewport g_Viewport;
struct SClipScreenRect {
bool x0_valid = false;
int x4_left = 0;
@ -262,6 +260,23 @@ public:
static void SetClearColor(const zeus::CColor& color);
static void SetCopyClear(const zeus::CColor& color, float depth);
static void SetIsBeginSceneClearFb(bool clear);
static u32 GetViewportLeft() { return g_Viewport.x0_left; }
static u32 GetViewportTop() { return g_Viewport.x4_top; }
static u32 GetViewportWidth() { return g_Viewport.x8_width; }
static u32 GetViewportHeight() { return g_Viewport.xc_height; }
static float GetViewportHalfWidth() { return g_Viewport.x10_halfWidth; }
static float GetViewportHalfHeight() { return g_Viewport.x14_halfHeight; }
static float GetViewportAspect() { return g_Viewport.aspect; }
static bool IsCroppedViewportValid() { return g_CroppedViewport.x0_valid; }
static int GetCroppedViewportLeft() { return g_CroppedViewport.x4_left; }
static int GetCroppedViewportTop() { return g_CroppedViewport.x8_top; }
static int GetCroppedViewportWidth() { return g_CroppedViewport.xc_width; }
static int GetCroppedViewportHeight() { return g_CroppedViewport.x10_height; }
static float GetCroppedViewportDstWidth() { return g_CroppedViewport.x14_dstWidth; }
static float GetCroppedViewportUVXMin() { return g_CroppedViewport.x18_uvXMin; }
static float GetCroppedViewportUVXMax() { return g_CroppedViewport.x1c_uvXMax; }
static float GetCroppedViewportUVYMin() { return g_CroppedViewport.x20_uvYMin; }
static float GetCroppedViewportUVYMax() { return g_CroppedViewport.x24_uvYMax; }
// static boo::IGraphicsDataFactory::Platform g_BooPlatform;
// static const char* g_BooPlatformName;

82
Runtime/Graphics/GX.hpp
View File

@ -244,53 +244,39 @@ enum BlendFactor : uint16_t {
BL_INVDSTALPHA
};
//struct Color : athena::io::DNA<athena::Endian::Big> {
// union {
// uint8_t color[4];
// uint32_t num = 0;
// };
// Color() = default;
// Color& operator=(const atVec4f& vec) {
// athena::simd_floats f(vec.simd);
// color[0] = uint8_t(std::min(std::max(f[0] * 255.f, 0.f), 255.f));
// color[1] = uint8_t(std::min(std::max(f[1] * 255.f, 0.f), 255.f));
// color[2] = uint8_t(std::min(std::max(f[2] * 255.f, 0.f), 255.f));
// color[3] = uint8_t(std::min(std::max(f[3] * 255.f, 0.f), 255.f));
// return *this;
// }
// Color& operator=(const atVec3f& vec) {
// athena::simd_floats f(vec.simd);
// color[0] = uint8_t(std::min(std::max(f[0] * 255.f, 0.f), 255.f));
// color[1] = uint8_t(std::min(std::max(f[1] * 255.f, 0.f), 255.f));
// color[2] = uint8_t(std::min(std::max(f[2] * 255.f, 0.f), 255.f));
// color[3] = 0xff;
// return *this;
// }
// Color& operator=(uint8_t val) {
// color[0] = val;
// color[1] = val;
// color[2] = val;
// color[3] = val;
// return *this;
// }
// atVec4f toVec4f() const {
// atVec4f out;
// athena::simd_floats f;
// f[0] = color[0] / 255.f;
// f[1] = color[1] / 255.f;
// f[2] = color[2] / 255.f;
// f[3] = color[3] / 255.f;
// out.simd.copy_from(f);
// return out;
// }
// Color(const atVec4f& vec) { *this = vec; }
// Color(const atVec3f& vec) { *this = vec; }
// Color(uint8_t val) { *this = val; }
// bool operator==(const Color& other) const { return num == other.num; }
// bool operator!=(const Color& other) const { return num != other.num; }
// uint8_t operator[](size_t idx) const { return color[idx]; }
// uint8_t& operator[](size_t idx) { return color[idx]; }
// AT_DECL_EXPLICIT_DNA
//};
struct Color {
union {
uint8_t color[4];
uint32_t num = 0;
};
Color() = default;
Color(uint8_t r, uint8_t g, uint8_t b, uint8_t a = 255) {
color[0] = r;
color[1] = g;
color[2] = b;
color[3] = a;
}
Color(float r, float g, float b, float a = 1.f) {
color[0] = r * 255;
color[1] = g * 255;
color[2] = b * 255;
color[3] = a * 255;
}
Color& operator=(uint8_t val) {
color[0] = val;
color[1] = val;
color[2] = val;
color[3] = val;
return *this;
}
explicit Color(uint8_t val) { *this = val; }
bool operator==(const Color& other) const { return num == other.num; }
bool operator!=(const Color& other) const { return num != other.num; }
uint8_t operator[](size_t idx) const { return color[idx]; }
uint8_t& operator[](size_t idx) { return color[idx]; }
};
} // namespace GX

10
Runtime/Graphics/Shaders/CCameraBlurFilter.cpp
View File

@ -47,14 +47,14 @@ void CCameraBlurFilter::draw(float amount, bool clearDepth) {
SCOPED_GRAPHICS_DEBUG_GROUP("CCameraBlurFilter::draw", zeus::skMagenta);
const SClipScreenRect clipRect(g_Viewport);
const SClipScreenRect clipRect(CGraphics::g_Viewport);
CGraphics::ResolveSpareTexture(clipRect, 0, clearDepth);
const float aspect = float(CGraphics::g_CroppedViewport.xc_width) / float(CGraphics::g_CroppedViewport.x10_height);
const float xFac = float(CGraphics::g_CroppedViewport.xc_width) / float(g_Viewport.x8_width);
const float yFac = float(CGraphics::g_CroppedViewport.x10_height) / float(g_Viewport.xc_height);
const float xBias = float(CGraphics::g_CroppedViewport.x4_left) / float(g_Viewport.x8_width);
const float yBias = float(CGraphics::g_CroppedViewport.x8_top) / float(g_Viewport.xc_height);
const float xFac = float(CGraphics::GetCroppedViewportWidth()) / float(CGraphics::GetViewportWidth());
const float yFac = float(CGraphics::GetCroppedViewportHeight()) / float(CGraphics::GetViewportHeight());
const float xBias = float(CGraphics::GetCroppedViewportLeft()) / float(CGraphics::GetViewportWidth());
const float yBias = float(CGraphics::GetCroppedViewportTop()) / float(CGraphics::GetViewportHeight());
const std::array<Vert, 4> verts{{
{{-1.0, -1.0}, {xBias, yBias}},

23
Runtime/Graphics/Shaders/CColoredQuadFilter.cpp
View File

@ -56,7 +56,8 @@ CColoredQuadFilter::CColoredQuadFilter(EFilterType type) {
//
// const std::array<boo::ObjToken<boo::IGraphicsBuffer>, 1> bufs{m_uniBuf.get()};
// constexpr std::array<boo::PipelineStage, 1> stages{boo::PipelineStage::Vertex};
// m_dataBind = ctx.newShaderDataBinding(SelectPipeline(type), m_vbo.get(), nullptr, nullptr, bufs.size(), bufs.data(),
// m_dataBind = ctx.newShaderDataBinding(SelectPipeline(type), m_vbo.get(), nullptr, nullptr, bufs.size(),
// bufs.data(),
// stages.data(), nullptr, nullptr, 0, nullptr, nullptr, nullptr);
// return true;
// } BooTrace);
@ -77,10 +78,10 @@ void CColoredQuadFilter::draw(const zeus::CColor& color, const zeus::CRectangle&
}
void CWideScreenFilter::draw(const zeus::CColor& color, float t) {
if (g_Viewport.aspect < 1.7777f) {
float targetHeight = g_Viewport.x8_width / 1.7777f;
float delta = (g_Viewport.xc_height - targetHeight) * t / 2.f;
delta /= float(g_Viewport.xc_height);
if (CGraphics::GetViewportAspect() < 1.7777f) {
float targetHeight = CGraphics::GetViewportWidth() / 1.7777f;
float delta = (CGraphics::GetViewportHeight() - targetHeight) * t / 2.f;
delta /= float(CGraphics::GetViewportHeight());
zeus::CRectangle rect(0.f, 0.f, 1.f, delta);
m_bottom.draw(color, rect);
rect.position.y() = 1.f - delta;
@ -89,9 +90,9 @@ void CWideScreenFilter::draw(const zeus::CColor& color, float t) {
}
float CWideScreenFilter::SetViewportToMatch(float t) {
if (g_Viewport.aspect < 1.7777f) {
float targetHeight = g_Viewport.x8_width / 1.7777f;
float delta = (g_Viewport.xc_height - targetHeight) * t / 2.f;
if (CGraphics::GetViewportAspect() < 1.7777f) {
float targetHeight = CGraphics::GetViewportWidth() / 1.7777f;
float delta = (CGraphics::GetViewportHeight() - targetHeight) * t / 2.f;
// boo::SWindowRect rect = {};
// rect.size[0] = g_Viewport.x8_width;
// rect.size[1] = g_Viewport.xc_height - delta * 2.f;
@ -99,10 +100,10 @@ float CWideScreenFilter::SetViewportToMatch(float t) {
// CGraphics::g_CroppedViewport = rect;
// CGraphics::g_BooMainCommandQueue->setViewport(rect);
return 1.7777f;
} else {
SetViewportToFull();
return g_Viewport.aspect;
}
SetViewportToFull();
return CGraphics::GetViewportAspect();
}
void CWideScreenFilter::SetViewportToFull() {

11
Runtime/Graphics/Shaders/CPhazonSuitFilter.cpp
View File

@ -114,15 +114,16 @@ void CPhazonSuitFilter::drawBlurPasses(float radius, const CTexture* indTex) {
// }
SClipScreenRect rect;
rect.x4_left = g_Viewport.x0_left;
rect.x8_top = g_Viewport.x4_top;
rect.xc_width = g_Viewport.x8_width;
rect.x10_height = g_Viewport.xc_height;
rect.x4_left = CGraphics::GetViewportLeft();
rect.x8_top = CGraphics::GetViewportTop();
rect.xc_width = CGraphics::GetViewportWidth();
rect.x10_height = CGraphics::GetViewportTop();
constexpr float blurScale = 1.0f / 128.0f;
/* X Pass */
auto blurDir = zeus::CVector4f{g_Viewport.xc_height / float(g_Viewport.x8_width) * radius * blurScale, 0.f, 0.f, 0.f};
auto blurDir = zeus::CVector4f{
CGraphics::GetViewportHeight() / float(CGraphics::GetViewportWidth()) * radius * blurScale, 0.f, 0.f, 0.f};
// m_uniBufBlurX->load(&blurDir, sizeof(zeus::CVector4f));
// CGraphics::SetShaderDataBinding(m_dataBindBlurX);

2
Runtime/Graphics/Shaders/CSpaceWarpFilter.cpp
View File

@ -157,7 +157,7 @@ void CSpaceWarpFilter::draw(const zeus::CVector3f& pt) {
clipRect.x4_left += CGraphics::g_CroppedViewport.x4_left;
clipRect.x8_top += CGraphics::g_CroppedViewport.x8_top;
clipRect.x8_top = g_Viewport.xc_height - clipRect.x10_height - clipRect.x8_top;
clipRect.x8_top = CGraphics::GetViewportHeight() - clipRect.x10_height - clipRect.x8_top;
CGraphics::ResolveSpareTexture(clipRect);
m_uniform.m_strength.x() =

8
Runtime/Graphics/Shaders/CTexturedQuadFilter.cpp
View File

@ -238,10 +238,10 @@ void CTexturedQuadFilter::draw(const zeus::CColor& color, float uvScale, const z
void CTexturedQuadFilter::drawCropped(const zeus::CColor& color, float uvScale) {
SCOPED_GRAPHICS_DEBUG_GROUP("CTexturedQuadFilter::drawCropped", zeus::skMagenta);
const float xFac = CGraphics::g_CroppedViewport.xc_width / float(g_Viewport.x8_width);
const float yFac = CGraphics::g_CroppedViewport.x10_height / float(g_Viewport.xc_height);
const float xBias = CGraphics::g_CroppedViewport.x4_left / float(g_Viewport.x8_width);
const float yBias = CGraphics::g_CroppedViewport.x8_top / float(g_Viewport.xc_height);
const float xFac = CGraphics::GetCroppedViewportWidth() / float(CGraphics::GetViewportWidth());
const float yFac = CGraphics::GetCroppedViewportHeight() / float(CGraphics::GetViewportHeight());
const float xBias = CGraphics::GetCroppedViewportLeft() / float(CGraphics::GetViewportWidth());
const float yBias = CGraphics::GetCroppedViewportTop() / float(CGraphics::GetViewportHeight());
const std::array<Vert, 4> verts{{
{{-1.f, -1.f, 0.f}, {xBias * uvScale, yBias * uvScale}},

11
Runtime/GuiSys/CGuiSys.cpp
View File

@ -76,17 +76,18 @@ void CGuiSys::OnViewportResize() {
void CGuiSys::ViewportResizeFrame(CGuiFrame* frame) {
if (frame->m_aspectConstraint > 0.f) {
float hPad, vPad;
if (g_Viewport.aspect >= frame->m_aspectConstraint) {
hPad = frame->m_aspectConstraint / g_Viewport.aspect;
if (CGraphics::GetViewportAspect() >= frame->m_aspectConstraint) {
hPad = frame->m_aspectConstraint / CGraphics::GetViewportAspect();
vPad = frame->m_aspectConstraint / 1.38f;
} else {
hPad = 1.f;
vPad = g_Viewport.aspect / 1.38f;
vPad = CGraphics::GetViewportAspect() / 1.38f;
}
frame->m_aspectTransform = zeus::CTransform::Scale({hPad, 1.f, vPad});
} else if (frame->m_maxAspect > 0.f) {
if (g_Viewport.aspect > frame->m_maxAspect)
frame->m_aspectTransform = zeus::CTransform::Scale({frame->m_maxAspect / g_Viewport.aspect, 1.f, 1.f});
if (CGraphics::GetViewportAspect() > frame->m_maxAspect)
frame->m_aspectTransform =
zeus::CTransform::Scale({frame->m_maxAspect / CGraphics::GetViewportAspect(), 1.f, 1.f});
else
frame->m_aspectTransform = zeus::CTransform();
}

7
Runtime/GuiSys/COrbitPointMarker.cpp
View File

@ -73,10 +73,11 @@ void COrbitPointMarker::Draw(const CStateManager& mgr) const {
const CGameCamera* curCam = mgr.GetCameraManager()->GetCurrentCamera(mgr);
zeus::CTransform camXf = mgr.GetCameraManager()->GetCurrentCameraTransform(mgr);
CGraphics::SetViewPointMatrix(camXf);
zeus::CFrustum frustum = mgr.SetupDrawFrustum(g_Viewport);
frustum.updatePlanes(camXf, zeus::SProjPersp(zeus::degToRad(curCam->GetFov()), g_Viewport.aspect, 1.f, 100.f));
zeus::CFrustum frustum = mgr.SetupDrawFrustum(CGraphics::g_Viewport);
frustum.updatePlanes(
camXf, zeus::SProjPersp(zeus::degToRad(curCam->GetFov()), CGraphics::GetViewportAspect(), 1.f, 100.f));
g_Renderer->SetClippingPlanes(frustum);
g_Renderer->SetPerspective(curCam->GetFov(), g_Viewport.x8_width, g_Viewport.xc_height,
g_Renderer->SetPerspective(curCam->GetFov(), CGraphics::GetViewportWidth(), CGraphics::GetViewportHeight(),
curCam->GetNearClipDistance(), curCam->GetFarClipDistance());
float scale;
if (x1c_lastFreeOrbit)

8
Runtime/GuiSys/CScanDisplay.cpp
View File

@ -381,7 +381,7 @@ void CScanDisplay::Update(float dt, float scanningTime) {
case CDataDot::EDotState::Hold: {
float tmp = dot.GetTransitionFactor();
if (tmp == 0.f) {
float vpRatio = g_Viewport.xc_height / 480.f;
float vpRatio = CGraphics::GetViewportHeight() / 480.f;
float posRand = g_tweakGui->GetScanDataDotPosRandMagnitude() * vpRatio;
float durMin = dot.GetDotState() == CDataDot::EDotState::Hold ? g_tweakGui->GetScanDataDotHoldDurationMin()
: g_tweakGui->GetScanDataDotSeekDurationMin();
@ -403,8 +403,8 @@ void CScanDisplay::Update(float dt, float scanningTime) {
case CDataDot::EDotState::Done: {
const zeus::CVector3f& panePos = x170_paneStates[i].second->GetWorldPosition();
zeus::CVector3f screenPos = xa0_selHud.GetFrameCamera()->ConvertToScreenSpace(panePos);
zeus::CVector2f viewportCoords(screenPos.x() * g_Viewport.x8_width * 0.5f,
screenPos.y() * g_Viewport.xc_height * 0.5f);
zeus::CVector2f viewportCoords(screenPos.x() * CGraphics::GetViewportWidth() * 0.5f,
screenPos.y() * CGraphics::GetViewportHeight() * 0.5f);
dot.SetDestPosition(viewportCoords);
break;
}
@ -449,7 +449,7 @@ void CScanDisplay::Draw() {
g_Renderer->SetViewportOrtho(true, -4096.f, 4096.f);
// Additive alpha
const float vpRatio = g_Viewport.xc_height / 480.f;
const float vpRatio = CGraphics::GetViewportHeight() / 480.f;
for (CDataDot& dot : xbc_dataDots) {
dot.Draw(g_tweakGuiColors->GetScanDataDotColor(), g_tweakGui->GetScanDataDotRadius() * vpRatio);
}

2
Runtime/GuiSys/CSplashScreen.cpp
View File

@ -83,7 +83,7 @@ void CSplashScreen::Draw() {
}
zeus::CRectangle rect;
rect.size.x() = width / (480.f * g_Viewport.aspect);
rect.size.x() = width / (480.f * CGraphics::GetViewportAspect());
rect.size.y() = height / 480.f;
rect.position.x() = 0.5f - rect.size.x() / 2.f;
rect.position.y() = 0.5f - rect.size.y() / 2.f;

7
Runtime/GuiSys/CTargetingManager.cpp
View File

@ -26,10 +26,11 @@ void CTargetingManager::Draw(const CStateManager& mgr, bool hideLockon) {
zeus::CTransform camXf = mgr.GetCameraManager()->GetCurrentCameraTransform(mgr);
CGraphics::SetViewPointMatrix(camXf);
zeus::CFrustum frustum;
frustum.updatePlanes(camXf, zeus::SProjPersp(zeus::degToRad(curCam->GetFov()), g_Viewport.aspect, 1.f, 100.f));
frustum.updatePlanes(camXf,
zeus::SProjPersp(zeus::degToRad(curCam->GetFov()), CGraphics::GetViewportAspect(), 1.f, 100.f));
g_Renderer->SetClippingPlanes(frustum);
g_Renderer->SetPerspective(curCam->GetFov(), g_Viewport.x8_width, g_Viewport.xc_height, curCam->GetNearClipDistance(),
curCam->GetFarClipDistance());
g_Renderer->SetPerspective(curCam->GetFov(), CGraphics::GetViewportWidth(), CGraphics::GetViewportHeight(),
curCam->GetNearClipDistance(), curCam->GetFarClipDistance());
x0_targetReticule.Draw(mgr, hideLockon);
}

2
Runtime/MP1/CArtifactDoll.cpp
View File

@ -94,7 +94,7 @@ void CArtifactDoll::Draw(float alpha, const CStateManager& mgr, bool inArtifactC
SCOPED_GRAPHICS_DEBUG_GROUP("CArtifactDoll::Draw", zeus::skPurple);
alpha *= x24_fader;
g_Renderer->SetPerspective(55.f, g_Viewport.x8_width, g_Viewport.xc_height, 0.2f, 4096.f);
g_Renderer->SetPerspective(55.f, CGraphics::GetViewportWidth(), CGraphics::GetViewportHeight(), 0.2f, 4096.f);
CGraphics::SetViewPointMatrix(zeus::CTransform::Translate(0.f, -10.f, 0.f));
float angle = CGraphics::GetSecondsMod900() * 2.f * M_PIF * 0.25f;

14
Runtime/MP1/CCredits.cpp
View File

@ -60,7 +60,7 @@ CIOWin::EMessageReturn CCredits::Update(float dt, CArchitectureQueue& queue) {
g_ResFactory->GetResourceIdByName(g_tweakGui->GetCreditsFont())->id,
CGuiTextProperties(true, true, EJustification::Center, EVerticalJustification::Top),
g_tweakGui->GetCreditsTextFontColor(), g_tweakGui->GetCreditsTextBorderColor(),
zeus::skWhite, g_Viewport.x8_width - 64, 0, g_SimplePool,
zeus::skWhite, CGraphics::GetViewportWidth() - 64, 0, g_SimplePool,
CGuiWidget::EGuiModelDrawFlags::Alpha),
zeus::CVector2i(0, 0));
x30_text.back().first->SetText(x18_creditsTable->GetString(i));
@ -96,12 +96,12 @@ CIOWin::EMessageReturn CCredits::Update(float dt, CArchitectureQueue& queue) {
auto bounds = text->GetBounds();
offset.y = (bounds.second.y - bounds.first.y);
offset.x = scaleY;
text->SetExtentX(g_Viewport.x8_width - 1280);
text->SetExtentX(CGraphics::GetViewportWidth() - 1280);
text->SetExtentY((bounds.second.y - bounds.first.y));
scaleY += (bounds.second.y - bounds.first.y);
}
x4c_ = float(scaleY + g_Viewport.xc_height - 896); // * 0.5f;
x4c_ = float(scaleY + CGraphics::GetViewportHeight() - 896); // * 0.5f;
const float divVal = std::max(g_tweakGui->x310_, g_tweakGui->x30c_);
x50_ = x4c_ / (g_tweakGui->x308_ - divVal);
x14_ = 1;
@ -202,12 +202,12 @@ CIOWin::EMessageReturn CCredits::ProcessUserInput(const CFinalInput& input) {
void CCredits::DrawVideo() {
/* Correct movie aspect ratio */
float hPad, vPad;
if (g_Viewport.aspect >= 1.78f) {
hPad = 1.78f / g_Viewport.aspect;
if (CGraphics::GetViewportAspect() >= 1.78f) {
hPad = 1.78f / CGraphics::GetViewportAspect();
vPad = 1.78f / 1.33f;
} else {
hPad = 1.f;
vPad = g_Viewport.aspect / 1.33f;
vPad = CGraphics::GetViewportAspect() / 1.33f;
}
if (x28_ && x28_->GetIsFullyCached()) {
@ -230,7 +230,7 @@ void CCredits::DrawVideo() {
}
void CCredits::DrawText() {
float width = 896.f * g_Viewport.aspect;
float width = 896.f * CGraphics::GetViewportAspect();
CGraphics::SetOrtho(0.f, width, 896.f, 0.f, -4096.f, 4096.f);
auto region =
std::make_pair<zeus::CVector2f, zeus::CVector2f>(zeus::CVector2f{0.f, 0.f}, zeus::CVector2f{width, 896.f});

10
Runtime/MP1/CFrontEndUI.cpp
View File

@ -1481,7 +1481,7 @@ void CFrontEndUI::SNesEmulatorFrame::Draw(CSaveGameScreen* saveUi) const {
if (x10_remTime <= 0.f)
return;
if (xc_textSupport->GetIsTextSupportFinishedLoading()) {
float aspect = g_Viewport.aspect / 1.33f;
float aspect = CGraphics::GetViewportAspect() / 1.33f;
CGraphics::SetOrtho(-320.f * aspect, 320.f * aspect, 240.f, -240.f, -4096.f, 4096.f);
CGraphics::SetViewPointMatrix(zeus::CTransform());
CGraphics::SetModelMatrix(zeus::CTransform::Translate(-220.f, 0.f, -200.f));
@ -2013,15 +2013,15 @@ void CFrontEndUI::Draw() {
/* Correct movie aspect ratio */
float hPad, vPad;
if (g_Viewport.aspect >= 1.78f) {
hPad = 1.78f / g_Viewport.aspect;
if (CGraphics::GetViewportAspect() >= 1.78f) {
hPad = 1.78f / CGraphics::GetViewportAspect();
vPad = 1.78f / 1.33f;
} else {
hPad = 1.f;
vPad = g_Viewport.aspect / 1.33f;
vPad = CGraphics::GetViewportAspect() / 1.33f;
}
if (xcc_curMoviePtr && xcc_curMoviePtr->GetIsFullyCached()) {
if ((xcc_curMoviePtr != nullptr) && xcc_curMoviePtr->GetIsFullyCached()) {
/* Render movie */
xcc_curMoviePtr->SetFrame(hPad, vPad);
xcc_curMoviePtr->DrawFrame();

2
Runtime/MP1/CGameCubeDoll.cpp
View File

@ -31,7 +31,7 @@ void CGameCubeDoll::Draw(float alpha) {
return;
SCOPED_GRAPHICS_DEBUG_GROUP("CGameCubeDoll::Draw", zeus::skPurple);
g_Renderer->SetPerspective(55.f, g_Viewport.x8_width, g_Viewport.xc_height, 0.2f, 4096.f);
g_Renderer->SetPerspective(55.f, CGraphics::GetViewportWidth(), CGraphics::GetViewportHeight(), 0.2f, 4096.f);
CGraphics::SetViewPointMatrix(zeus::CTransform::Translate(0.f, -2.f, 0.f));
x18_actorLights->ActivateLights();
CGraphics::SetModelMatrix(zeus::CTransform::RotateZ(zeus::degToRad(360.f * CGraphics::GetSecondsMod900() * -0.25f)) *

22
Runtime/MP1/CInGameGuiManager.cpp
View File

@ -473,15 +473,15 @@ void CInGameGuiManager::Draw(CStateManager& stateMgr) {
// No depth read/write
// Alpha blend
int w =
(g_Viewport.x0_left + (x1c4_onScreenTex.x4_origin.x - g_Viewport.x8_width) / 2 + x1c4_onScreenTex.xc_extent.x) -
int w = (CGraphics::GetViewportLeft() + (x1c4_onScreenTex.x4_origin.x - CGraphics::GetViewportWidth()) / 2 +
x1c4_onScreenTex.xc_extent.x) -
x1c4_onScreenTex.x4_origin.x;
int h =
(g_Viewport.x4_top + (x1c4_onScreenTex.x4_origin.y - g_Viewport.xc_height) / 2 - x1c4_onScreenTex.xc_extent.y) -
int h = (CGraphics::GetViewportTop() + (x1c4_onScreenTex.x4_origin.y - CGraphics::GetViewportHeight()) / 2 -
x1c4_onScreenTex.xc_extent.y) -
x1c4_onScreenTex.x4_origin.y;
zeus::CRectangle rect(x1c4_onScreenTex.x4_origin.x / float(g_Viewport.x8_width),
x1c4_onScreenTex.x4_origin.y / float(g_Viewport.xc_height), w / float(g_Viewport.x8_width),
h / float(g_Viewport.xc_height));
zeus::CRectangle rect(x1c4_onScreenTex.x4_origin.x / float(CGraphics::GetViewportWidth()),
x1c4_onScreenTex.x4_origin.y / float(CGraphics::GetViewportHeight()),
w / float(CGraphics::GetViewportWidth()), h / float(CGraphics::GetViewportHeight()));
m_onScreenQuad->draw(zeus::CColor(1.f, x1d8_onScreenTexAlpha), 1.f, rect);
}
@ -501,7 +501,7 @@ void CInGameGuiManager::Draw(CStateManager& stateMgr) {
x34_samusHud->GetTargetingManager().Draw(stateMgr, true);
CGraphics::SetDepthRange(DEPTH_SCREEN_ACTORS, DEPTH_GUN);
bool scanVisor = stateMgr.GetPlayerState()->GetActiveVisor(stateMgr) == CPlayerState::EPlayerVisor::Scan;
if (drawVisor && x1f0_enablePlayerVisor) {
if (drawVisor && (x1f0_enablePlayerVisor != 0u)) {
if (stateMgr.GetPlayer().GetCameraState() == CPlayer::EPlayerCameraState::FirstPerson)
x20_faceplateDecor.Draw(stateMgr);
CTargetingManager* tgtMgr = nullptr;
@ -594,11 +594,11 @@ void CInGameGuiManager::Draw(CStateManager& stateMgr) {
float zT = 1.f - zeus::clamp(0.f, (stateMgr.GetPlayer().GetDeathTime() - zStart) / 0.5f, 1.f);
float xT = 1.f - zeus::clamp(0.f, (stateMgr.GetPlayer().GetDeathTime() - xStart) / 0.5f, 1.f);
float colT = 1.f - zeus::clamp(0.f, (stateMgr.GetPlayer().GetDeathTime() - colStart) / 0.5f, 1.f);
SClipScreenRect rect(g_Viewport);
SClipScreenRect rect(CGraphics::g_Viewport);
CGraphics::ResolveSpareTexture(rect);
m_deathBlackout.draw(zeus::skBlack);
float z = 0.5f * (zT * zT * zT * zT * zT * (g_Viewport.xc_height - 12.f) + 12.f);
float x = 0.5f * (xT * (g_Viewport.x8_width - 12.f) + 12.f);
float z = 0.5f * (zT * zT * zT * zT * zT * (CGraphics::GetViewportHeight()- 12.f) + 12.f);
float x = 0.5f * (xT * (CGraphics::GetViewportWidth() - 12.f) + 12.f);
const std::array<CTexturedQuadFilter::Vert, 4> verts{{
{{-x, 0.f, z}, {0.f, 0.f}},

2
Runtime/MP1/CInventoryScreen.cpp
View File

@ -165,7 +165,7 @@ void CInventoryScreen::ProcessControllerInput(const CFinalInput& input) {
zeus::CVector2f mouseCoord = zeus::CVector2f(kbm->m_mouseCoord.norm[0], kbm->m_mouseCoord.norm[1]);
zeus::CVector2f mouseDelta = mouseCoord - m_lastMouseCoord;
m_lastMouseCoord = mouseCoord;
mouseDelta.x() *= g_Viewport.aspect;
mouseDelta.x() *= CGraphics::GetViewportAspect();
mouseDelta *= 100.f;
if (kbm->m_mouseButtons[size_t(EMouseButton::Middle)] ||
kbm->m_mouseButtons[size_t(EMouseButton::Secondary)]) {

29
Runtime/MP1/CPlayerVisor.cpp
View File

@ -65,7 +65,7 @@ bool CPlayerVisor::DrawScanObjectIndicators(const CStateManager& mgr) const {
CGraphics::SetDepthRange(DEPTH_WORLD, DEPTH_FAR);
g_Renderer->SetViewportOrtho(true, 0.f, 4096.f);
float vpScale = g_Viewport.xc_height / 448.f;
float vpScale = CGraphics::GetViewportHeight() / 448.f;
CGraphics::SetModelMatrix(zeus::CTransform::Scale(x48_interpWindowDims.x() * 17.f * vpScale, 1.f,
x48_interpWindowDims.y() * 17.f * vpScale));
@ -75,11 +75,12 @@ bool CPlayerVisor::DrawScanObjectIndicators(const CStateManager& mgr) const {
zeus::CTransform camMtx = mgr.GetCameraManager()->GetCurrentCameraTransform(mgr);
CGraphics::SetViewPointMatrix(camMtx);
zeus::CFrustum frustum;
frustum.updatePlanes(camMtx, zeus::CProjection(zeus::SProjPersp(
cam->GetFov(), g_Viewport.x8_width / float(g_Viewport.xc_height), 1.f, 100.f)));
frustum.updatePlanes(
camMtx, zeus::CProjection(zeus::SProjPersp(
cam->GetFov(), CGraphics::GetViewportWidth() / float(CGraphics::GetViewportHeight()), 1.f, 100.f)));
g_Renderer->SetClippingPlanes(frustum);
g_Renderer->SetPerspective(cam->GetFov(), g_Viewport.x8_width, g_Viewport.xc_height, cam->GetNearClipDistance(),
cam->GetFarClipDistance());
g_Renderer->SetPerspective(cam->GetFov(), CGraphics::GetViewportWidth(), CGraphics::GetViewportHeight(),
cam->GetNearClipDistance(), cam->GetFarClipDistance());
for (const SScanTarget& tgt : x13c_scanTargets) {
if (tgt.x4_timer == 0.f)
@ -150,8 +151,8 @@ void CPlayerVisor::UpdateScanObjectIndicators(const CStateManager& mgr, float dt
const CGameCamera* cam = mgr.GetCameraManager()->GetCurrentCamera(mgr);
zeus::CVector3f orbitPos = act->GetOrbitPosition(mgr);
orbitPos = cam->ConvertToScreenSpace(orbitPos);
orbitPos.x() = orbitPos.x() * g_Viewport.x8_width / 2.f + g_Viewport.x8_width / 2.f;
orbitPos.y() = orbitPos.y() * g_Viewport.xc_height / 2.f + g_Viewport.xc_height / 2.f;
orbitPos.x() = orbitPos.x() * CGraphics::GetViewportWidth() / 2.f + CGraphics::GetViewportWidth() / 2.f;
orbitPos.y() = orbitPos.y() * CGraphics::GetViewportHeight() / 2.f + CGraphics::GetViewportHeight() / 2.f;
bool inBox = mgr.GetPlayer().WithinOrbitScreenBox(orbitPos, mgr.GetPlayer().GetOrbitZone(),
mgr.GetPlayer().GetOrbitType());
if (inBox != tgt.xc_inBox) {
@ -344,7 +345,7 @@ void CPlayerVisor::DrawScanEffect(const CStateManager& mgr, CTargetingManager* t
t = (x3c_windowInterpTimer > scanSidesStart) ? 1.f : x3c_windowInterpTimer / scanSidesStart;
}
const float vpScale = g_Viewport.xc_height / 448.f;
const float vpScale = CGraphics::GetViewportHeight() / 448.f;
float divisor = (transFactor * ((1.f - t) * x58_scanMagInterp + t * g_tweakGui->GetScanWindowScanningAspect()) +
(1.f - transFactor));
divisor = 1.f / divisor;
@ -354,8 +355,8 @@ void CPlayerVisor::DrawScanEffect(const CStateManager& mgr, CTargetingManager* t
vpH = zeus::clamp(0.f, vpH, 448.f) * vpScale;
SClipScreenRect rect;
rect.x4_left = int((g_Viewport.x8_width - vpW) / 2.f);
rect.x8_top = int((g_Viewport.xc_height - vpH) / 2.f);
rect.x4_left = int((CGraphics::GetViewportWidth() - vpW) / 2.f);
rect.x8_top = int((CGraphics::GetViewportHeight() - vpH) / 2.f);
rect.xc_width = int(vpW);
rect.x10_height = int(vpH);
CGraphics::ResolveSpareTexture(rect);
@ -368,10 +369,10 @@ void CPlayerVisor::DrawScanEffect(const CStateManager& mgr, CTargetingManager* t
const zeus::CTransform seventeenScale = zeus::CTransform::Scale(17.f * vpScale, 1.f, 17.f * vpScale);
CGraphics::SetModelMatrix(seventeenScale * windowScale);
const float uvX0 = float(rect.x4_left) / float(g_Viewport.x8_width);
const float uvX1 = float(rect.x4_left + rect.xc_width) / float(g_Viewport.x8_width);
const float uvY0 = float(rect.x8_top) / float(g_Viewport.xc_height);
const float uvY1 = float(rect.x8_top + rect.x10_height) / float(g_Viewport.xc_height);
const float uvX0 = float(rect.x4_left) / float(CGraphics::GetViewportWidth());
const float uvX1 = float(rect.x4_left + rect.xc_width) / float(CGraphics::GetViewportWidth());
const float uvY0 = float(rect.x8_top) / float(CGraphics::GetViewportHeight());
const float uvY1 = float(rect.x8_top + rect.x10_height) / float(CGraphics::GetViewportHeight());
std::array<CTexturedQuadFilter::Vert, 4> rttVerts{{
{{-5.f, 0.f, 4.45f}, {uvX0, uvY0}},
{{5.f, 0.f, 4.45f}, {uvX1, uvY0}},

2
Runtime/MP1/CSamusDoll.cpp
View File

@ -317,7 +317,7 @@ void CSamusDoll::Draw(const CStateManager& mgr, float alpha) {
float itemPulse = zeus::clamp(0.f, (std::sin(5.f * CGraphics::GetSecondsMod900()) + 1.f) * 0.5f, 1.f) *
(1.f - std::fabs(xc4_viewInterp));
g_Renderer->SetPerspective(55.f, g_Viewport.x8_width, g_Viewport.xc_height, 0.2f, 4096.f);
g_Renderer->SetPerspective(55.f, CGraphics::GetViewportWidth(), CGraphics::GetViewportHeight(), 0.2f, 4096.f);
CGraphics::SetViewPointMatrix(zeus::CTransform(xb0_userRot, xa4_offset) *
zeus::CTransform::Translate(0.f, xc0_userZoom, 0.f));

2
Runtime/MP1/CSamusHud.cpp
View File

@ -1136,7 +1136,7 @@ void CSamusHud::Update(float dt, const CStateManager& mgr, CInGameGuiManager::EH
break;
}
float scaleMul = 1.f - zeus::clamp(0.f, (g_Viewport.aspect - 1.33f) / (1.77f - 1.33f), 1.f);
float scaleMul = 1.f - zeus::clamp(0.f, (CGraphics::GetViewportAspect() - 1.33f) / (1.77f - 1.33f), 1.f);
x500_viewportScale.y() = 1.f - scaleMul * morphT * g_tweakGui->GetBallViewportYReduction() * 1.2f;
if (x2b0_ballIntf)
x2b0_ballIntf->SetBallModeFactor(morphT);

2
Runtime/Weapon/CPhazonBeam.cpp
View File

@ -184,7 +184,7 @@ void CPhazonBeam::Draw(bool drawSuitArm, const CStateManager& mgr, const zeus::C
bool drawIndirect = visor == CPlayerState::EPlayerVisor::Combat || visor == CPlayerState::EPlayerVisor::Scan;
if (drawIndirect) {
CGraphics::ResolveSpareTexture(g_Viewport);
CGraphics::ResolveSpareTexture(CGraphics::g_Viewport);
CModelFlags tmpFlags = flags;
// TODO tmpFlags.m_extendedShader = EExtendedShader::SolidColorBackfaceCullLEqualAlphaOnly;
CGunWeapon::Draw(drawSuitArm, mgr, xf, tmpFlags, lights);

2
Runtime/Weapon/CPlayerGun.cpp
View File

@ -2133,7 +2133,7 @@ zeus::CVector3f CPlayerGun::ConvertToScreenSpace(const zeus::CVector3f& pos, con
void CPlayerGun::CopyScreenTex() {
// Copy lower right quadrant to gpCopyTexBuf as RGBA8
CGraphics::ResolveSpareTexture(g_Viewport);
CGraphics::ResolveSpareTexture(CGraphics::g_Viewport);
}
void CPlayerGun::DrawScreenTex(float z) {

2
Runtime/World/CMorphBallShadow.cpp
View File

@ -34,7 +34,7 @@ void CMorphBallShadow::RenderIdBuffer(const zeus::CAABox& aabb, const CStateMana
GatherAreas(mgr);
SViewport backupVp = g_Viewport;
SViewport backupVp = CGraphics::g_Viewport;
// g_Renderer->BindBallShadowIdTarget();
// CGraphics::g_BooMainCommandQueue->clearTarget();

28
Runtime/World/CPlayer.cpp
View File

@ -191,27 +191,27 @@ CModelData MakePlayerAnimRes(CAssetId resId, const zeus::CVector3f& scale) {
}
uint32_t GetOrbitScreenBoxHalfExtentXScaled(int zone) {
return g_tweakPlayer->GetOrbitScreenBoxHalfExtentX(zone) * g_Viewport.x8_width / 640;
return g_tweakPlayer->GetOrbitScreenBoxHalfExtentX(zone) * CGraphics::GetViewportWidth() / 640;
}
uint32_t GetOrbitScreenBoxHalfExtentYScaled(int zone) {
return g_tweakPlayer->GetOrbitScreenBoxHalfExtentY(zone) * g_Viewport.xc_height / 448;
return g_tweakPlayer->GetOrbitScreenBoxHalfExtentY(zone) * CGraphics::GetViewportHeight() / 448;
}
uint32_t GetOrbitScreenBoxCenterXScaled(int zone) {
return g_tweakPlayer->GetOrbitScreenBoxCenterX(zone) * g_Viewport.x8_width / 640;
return g_tweakPlayer->GetOrbitScreenBoxCenterX(zone) * CGraphics::GetViewportWidth() / 640;
}
uint32_t GetOrbitScreenBoxCenterYScaled(int zone) {
return g_tweakPlayer->GetOrbitScreenBoxCenterY(zone) * g_Viewport.xc_height / 448;
return g_tweakPlayer->GetOrbitScreenBoxCenterY(zone) * CGraphics::GetViewportHeight() / 448;
}
uint32_t GetOrbitZoneIdealXScaled(int zone) {
return g_tweakPlayer->GetOrbitZoneIdealX(zone) * g_Viewport.x8_width / 640;
return g_tweakPlayer->GetOrbitZoneIdealX(zone) * CGraphics::GetViewportWidth() / 640;
}
uint32_t GetOrbitZoneIdealYScaled(int zone) {
return g_tweakPlayer->GetOrbitZoneIdealY(zone) * g_Viewport.xc_height / 448;
return g_tweakPlayer->GetOrbitZoneIdealY(zone) * CGraphics::GetViewportHeight() / 448;
}
} // Anonymous namespace
@ -4138,8 +4138,8 @@ bool CPlayer::ValidateAimTargetId(TUniqueId uid, CStateManager& mgr) {
if (act->GetMaterialList().HasMaterial(EMaterialTypes::Target) && uid != kInvalidUniqueId &&
ValidateObjectForMode(uid, mgr)) {
const float vpWHalf = g_Viewport.x8_width / 2;
const float vpHHalf = g_Viewport.xc_height / 2;
const float vpWHalf = CGraphics::GetViewportWidth() / 2;
const float vpHHalf = CGraphics::GetViewportHeight() / 2;
const zeus::CVector3f aimPos = act->GetAimPosition(mgr, 0.f);
const zeus::CVector3f eyePos = GetEyePosition();
zeus::CVector3f eyeToAim = aimPos - eyePos;
@ -4249,8 +4249,8 @@ TUniqueId CPlayer::CheckEnemiesAgainstOrbitZone(const EntityList& list, EPlayerZ
float minEyeToAimMag = 10000.f;
float minPosInBoxMagSq = 10000.f;
TUniqueId bestId = kInvalidUniqueId;
const float vpWHalf = g_Viewport.x8_width / 2;
const float vpHHalf = g_Viewport.xc_height / 2;
const float vpWHalf = CGraphics::GetViewportWidth() / 2;
const float vpHHalf = CGraphics::GetViewportHeight() / 2;
const float boxLeft = (GetOrbitZoneIdealXScaled(int(info)) - vpWHalf) / vpWHalf;
const float boxTop = (GetOrbitZoneIdealYScaled(int(info)) - vpHHalf) / vpHHalf;
const CFirstPersonCamera* fpCam = mgr.GetCameraManager()->GetFirstPersonCamera();
@ -4346,8 +4346,8 @@ TUniqueId CPlayer::FindBestOrbitableObject(const std::vector<TUniqueId>& ids, EP
float minEyeToOrbitMag = 10000.f;
float minPosInBoxMagSq = 10000.f;
TUniqueId bestId = kInvalidUniqueId;
const float vpWidthHalf = g_Viewport.x8_width / 2;
const float vpHeightHalf = g_Viewport.xc_height / 2;
const float vpWidthHalf = CGraphics::GetViewportWidth() / 2;
const float vpHeightHalf = CGraphics::GetViewportHeight() / 2;
const float boxLeft = (GetOrbitZoneIdealXScaled(int(info)) - vpWidthHalf) / vpWidthHalf;
const float boxTop = (GetOrbitZoneIdealYScaled(int(info)) - vpHeightHalf) / vpHeightHalf;
@ -4497,8 +4497,8 @@ void CPlayer::FindOrbitableObjects(const EntityList& nearObjects, std::vector<TU
}
const zeus::CVector3f orbitPos = act->GetOrbitPosition(mgr);
zeus::CVector3f screenPos = fpCam->ConvertToScreenSpace(orbitPos);
screenPos.x() = g_Viewport.x8_width * screenPos.x() / 2.f + g_Viewport.x8_width / 2.f;
screenPos.y() = g_Viewport.xc_height * screenPos.y() / 2.f + g_Viewport.xc_height / 2.f;
screenPos.x() = CGraphics::GetViewportWidth() * screenPos.x() / 2.f + CGraphics::GetViewportWidth() / 2.f;
screenPos.y() = CGraphics::GetViewportHeight() * screenPos.y() / 2.f + CGraphics::GetViewportHeight() / 2.f;
bool pass = false;
if (onScreenTest) {

2
Runtime/World/CWorldShadow.cpp
View File

@ -63,7 +63,7 @@ void CWorldShadow::BuildLightShadowTexture(const CStateManager& mgr, TAreaId aid
frustum.updatePlanes(x4_view, zeus::SProjPersp(zeus::degToRad(fov), 1.f, 0.1f, distance + x64_objHalfExtent));
g_Renderer->SetClippingPlanes(frustum);
g_Renderer->SetPerspective(fov, m_shader.GetWidth(), m_shader.GetHeight(), 0.1f, 1000.f);
SViewport backupVp = g_Viewport;
SViewport backupVp = CGraphics::g_Viewport;
zeus::CVector2f backupDepthRange = CGraphics::g_CachedDepthRange;
m_shader.bindRenderTarget();
g_Renderer->SetViewport(0, 0, m_shader.GetWidth(), m_shader.GetHeight());

4
Runtime/World/CWorldTransManager.cpp
View File

@ -289,7 +289,7 @@ void CWorldTransManager::DrawEnabled() {
else {
float t = zeus::clamp(0.f, (x0_curTime - x4_modelData->x1d0_dissolveStartTime) / 2.f, 1.f);
DrawFirstPass(&lights);
SClipScreenRect rect(g_Viewport);
SClipScreenRect rect(CGraphics::g_Viewport);
CGraphics::ResolveSpareTexture(rect);
// CGraphics::g_BooMainCommandQueue->clearTarget(true, true);
DrawSecondPass(&lights);
@ -317,7 +317,7 @@ void CWorldTransManager::DrawDisabled() {
void CWorldTransManager::DrawText() {
SCOPED_GRAPHICS_DEBUG_GROUP("CWorldTransManager::DrawText", zeus::skPurple);
float width = 448.f * g_Viewport.aspect;
float width = 448.f * CGraphics::GetViewportAspect();
CGraphics::SetOrtho(0.f, width, 448.f, 0.f, -4096.f, 4096.f);
CGraphics::SetViewPointMatrix(zeus::CTransform());
CGraphics::SetModelMatrix(zeus::CTransform::Translate((width - 640.f) / 2.f, 0.f, 448.f));