mirror of https://github.com/AxioDL/metaforce.git
Work on CStateManager rendering functions
This commit is contained in:
parent
39040b5ab3
commit
5c884fec0c
|
@ -0,0 +1,19 @@
|
|||
#include "CFluidPlaneManager.hpp"
|
||||
|
||||
namespace urde
|
||||
{
|
||||
|
||||
CFluidPlaneManager::CFluidProfile CFluidPlaneManager::sProfile = {};
|
||||
|
||||
void CFluidPlaneManager::CFluidProfile::Clear()
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
void CFluidPlaneManager::StartFrame(bool b)
|
||||
{
|
||||
x121_ = b;
|
||||
sProfile.Clear();
|
||||
}
|
||||
|
||||
}
|
|
@ -6,6 +6,15 @@ namespace urde
|
|||
|
||||
class CFluidPlaneManager
|
||||
{
|
||||
bool x121_;
|
||||
class CFluidProfile
|
||||
{
|
||||
public:
|
||||
void Clear();
|
||||
};
|
||||
static CFluidProfile sProfile;
|
||||
public:
|
||||
void StartFrame(bool);
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
@ -61,6 +61,7 @@ public:
|
|||
TUniqueId GetFirstObjectIndex() const { return x2008_firstId; }
|
||||
TUniqueId GetNextObjectIndex(TUniqueId prev) const { return x0_list[prev & 0x3ff].next; }
|
||||
virtual bool IsQualified(const CEntity&);
|
||||
u16 size() const { return x200a_count; }
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
@ -2,6 +2,7 @@
|
|||
#include "Camera/CCameraShakeData.hpp"
|
||||
#include "Camera/CGameCamera.hpp"
|
||||
#include "Graphics/CBooRenderer.hpp"
|
||||
#include "World/CGameLight.hpp"
|
||||
#include "CSortedLists.hpp"
|
||||
#include "Weapon/CWeaponMgr.hpp"
|
||||
#include "CFluidPlaneManager.hpp"
|
||||
|
@ -25,6 +26,10 @@
|
|||
#include "CMemoryCardSys.hpp"
|
||||
#include "TCastTo.hpp"
|
||||
#include "World/CScriptSpecialFunction.hpp"
|
||||
#include "CTimeProvider.hpp"
|
||||
#include "Camera/CBallCamera.hpp"
|
||||
#include "Collision/CMaterialFilter.hpp"
|
||||
#include "World/CScriptDock.hpp"
|
||||
|
||||
#include <cmath>
|
||||
|
||||
|
@ -288,7 +293,27 @@ bool CStateManager::SpecialSkipCinematic()
|
|||
return true;
|
||||
}
|
||||
|
||||
void CStateManager::GetVisAreaId() const {}
|
||||
TAreaId CStateManager::GetVisAreaId() const
|
||||
{
|
||||
const CGameCamera* cam = static_cast<const CGameCamera*>(x870_cameraManager->GetCurrentCamera(*this));
|
||||
const CBallCamera* ballCam = x870_cameraManager->GetBallCamera();
|
||||
TAreaId curArea = x850_world->x68_curAreaId;
|
||||
if (cam != ballCam)
|
||||
return curArea;
|
||||
|
||||
const zeus::CVector3f& camTranslation = ballCam->GetTranslation();
|
||||
zeus::CAABox camAABB(camTranslation, camTranslation);
|
||||
camAABB.accumulateBounds(x84c_player->GetTranslation());
|
||||
rstl::reserved_vector<TUniqueId, 1024> nearList;
|
||||
BuildNearList(nearList, camAABB, CMaterialFilter(EMaterialTypes::AIBlock, CMaterialList(),
|
||||
CMaterialFilter::EFilterType::One), nullptr);
|
||||
for (TUniqueId id : nearList)
|
||||
if (TCastToConstPtr<CScriptDock> dock = GetObjectById(id))
|
||||
if (dock->GetDestinationAreaId() == curArea && dock->HasPointCrossedDock(*this, camTranslation))
|
||||
return dock->GetCurrentConnectedAreaId(*this);
|
||||
|
||||
return curArea;
|
||||
}
|
||||
|
||||
void CStateManager::GetWeaponIdCount(TUniqueId, EWeaponType) {}
|
||||
|
||||
|
@ -351,7 +376,29 @@ bool CStateManager::CanCreateProjectile(TUniqueId, EWeaponType, int) const { ret
|
|||
|
||||
const CGameLightList* CStateManager::GetDynamicLightList() const { return nullptr; }
|
||||
|
||||
void CStateManager::BuildDynamicLightListForWorld(std::vector<CLight>& listOut) const {}
|
||||
void CStateManager::BuildDynamicLightListForWorld()
|
||||
{
|
||||
if (x8b8_playerState->GetActiveVisor(*this) == CPlayerState::EPlayerVisor::Thermal)
|
||||
{
|
||||
x8e0_dynamicLights.clear();
|
||||
return;
|
||||
}
|
||||
|
||||
if (x82c_lightObjs->size() == 0)
|
||||
return;
|
||||
|
||||
x8e0_dynamicLights.clear();
|
||||
for (CEntity* ent : *x82c_lightObjs)
|
||||
{
|
||||
CGameLight& light = static_cast<CGameLight&>(*ent);
|
||||
if (light.GetActive())
|
||||
{
|
||||
CLight l = light.GetLight();
|
||||
if (l.GetIntensity() > FLT_EPSILON && l.GetRadius() > FLT_EPSILON)
|
||||
x8e0_dynamicLights.push_back(l);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void CStateManager::DrawDebugStuff() const {}
|
||||
|
||||
|
@ -361,11 +408,87 @@ void CStateManager::DrawE3DeathEffect() const {}
|
|||
|
||||
void CStateManager::DrawAdditionalFilters() const {}
|
||||
|
||||
void CStateManager::DrawWorld() const {}
|
||||
zeus::CFrustum CStateManager::SetupViewForDraw(const SViewport& vp) const
|
||||
{
|
||||
const CGameCamera* cam = static_cast<const CGameCamera*>(x870_cameraManager->GetCurrentCamera(*this));
|
||||
zeus::CTransform camXf = x870_cameraManager->GetCurrentCameraTransform(*this);
|
||||
g_Renderer->SetWorldViewpoint(camXf);
|
||||
CBooModel::SetNewPlayerPositionAndTime(x84c_player->GetTranslation());
|
||||
int vpWidth = xf2c_viewportScale.x * vp.x8_width;
|
||||
int vpHeight = xf2c_viewportScale.y * vp.xc_height;
|
||||
int vpLeft = (vp.x8_width - vpWidth) / 2 + vp.x0_left;
|
||||
int vpTop = (vp.xc_height - vpHeight) / 2 + vp.x4_top;
|
||||
g_Renderer->SetViewport(vpLeft, vpTop, vpWidth, vpHeight);
|
||||
CGraphics::SetDepthRange(0.125f, 1.f);
|
||||
float fov = std::atan(std::tan(zeus::degToRad(cam->GetFov()) * 0.5f) * xf2c_viewportScale.y * 2.f);
|
||||
float width = xf2c_viewportScale.x * vp.x8_width;
|
||||
float height = xf2c_viewportScale.y * vp.xc_height;
|
||||
g_Renderer->SetPerspective(zeus::radToDeg(fov), width, height,
|
||||
cam->GetNearClipDistance(), cam->GetFarClipDistance());
|
||||
zeus::CFrustum frustum;
|
||||
zeus::CProjection proj;
|
||||
proj.setPersp(zeus::SProjPersp{fov, width / height, cam->GetNearClipDistance(), cam->GetFarClipDistance()});
|
||||
frustum.updatePlanes(camXf, proj);
|
||||
g_Renderer->SetClippingPlanes(frustum);
|
||||
//g_Renderer->PrimColor(zeus::CColor::skWhite);
|
||||
CGraphics::SetModelMatrix(zeus::CTransform::Identity());
|
||||
x87c_fluidPlaneManager->StartFrame(false);
|
||||
g_Renderer->SetDebugOption(IRenderer::EDebugOption::One, 1);
|
||||
return frustum;
|
||||
}
|
||||
|
||||
void CStateManager::DrawWorld() const
|
||||
{
|
||||
CTimeProvider timeProvider(xf14_);
|
||||
zeus::CFrustum frustum = SetupViewForDraw(g_Viewport);
|
||||
|
||||
GetVisAreaId();
|
||||
}
|
||||
|
||||
void CStateManager::SetupFogForArea(const CGameArea& area) const {}
|
||||
|
||||
void CStateManager::PreRender() {}
|
||||
void CStateManager::PreRender()
|
||||
{
|
||||
if (xf94_24_)
|
||||
{
|
||||
x86c_stateManagerContainer->xf370_.clear();
|
||||
x86c_stateManagerContainer->xf39c_.clear();
|
||||
xf7c_ = 0;
|
||||
x850_world->PreRender();
|
||||
BuildDynamicLightListForWorld();
|
||||
CGameCamera* cam = static_cast<CGameCamera*>(x870_cameraManager->GetCurrentCamera(*this));
|
||||
zeus::CFrustum frustum;
|
||||
zeus::CProjection proj;
|
||||
proj.setPersp(zeus::SProjPersp{zeus::degToRad(cam->GetFov()),
|
||||
cam->GetAspectRatio(), cam->GetNearClipDistance(), cam->GetFarClipDistance()});
|
||||
frustum.updatePlanes(x870_cameraManager->GetCurrentCameraTransform(*this), proj);
|
||||
for (CGameArea* area = x850_world->x4c_chainHeads[3];
|
||||
area != CWorld::AliveAreasEnd();
|
||||
area = area->x130_next)
|
||||
{
|
||||
CGameArea::EOcclusionState occState = CGameArea::EOcclusionState::NotOccluded;
|
||||
if (area->IsPostConstructed())
|
||||
occState = area->GetOcclusionState();
|
||||
if (occState == CGameArea::EOcclusionState::Occluded)
|
||||
{
|
||||
for (CEntity* ent : *area->GetPostConstructed()->x10c0_areaObjs)
|
||||
{
|
||||
if (TCastToPtr<CActor> act = ent)
|
||||
{
|
||||
if (act->GetE7_29())
|
||||
{
|
||||
act->CalculateRenderBounds();
|
||||
act->PreRender(*this, frustum);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
CacheReflection();
|
||||
g_Renderer->PrepareDynamicLights(x8e0_dynamicLights);
|
||||
}
|
||||
}
|
||||
|
||||
bool CStateManager::GetVisSetForArea(TAreaId a, TAreaId b, CPVSVisSet& setOut) const
|
||||
{
|
||||
|
|
|
@ -107,8 +107,8 @@ class CStateManager
|
|||
CActorModelParticles xf168_actorModelParticles;
|
||||
CRumbleManager xf250_rumbleManager;
|
||||
u32 xf344_ = 0;
|
||||
u32 xf370_ = 0;
|
||||
u32 xf39c_ = 0;
|
||||
rstl::reserved_vector<TUniqueId, 20> xf370_;
|
||||
rstl::reserved_vector<TUniqueId, 20> xf39c_;
|
||||
};
|
||||
std::unique_ptr<CStateManagerContainer> x86c_stateManagerContainer;
|
||||
CCameraManager* x870_cameraManager = nullptr;
|
||||
|
@ -134,7 +134,7 @@ class CStateManager
|
|||
//u32 x8d4_updateFrameIdx = 0;
|
||||
//u32 x8d8_drawFrameIdx = 0;
|
||||
|
||||
std::vector<CLight> x8dc_dynamicLights;
|
||||
std::vector<CLight> x8e0_dynamicLights;
|
||||
|
||||
TLockedToken<CTexture> x8f0_shadowTex; /* DefaultShadow in MiscData */
|
||||
CRandom16 x8fc_random;
|
||||
|
@ -191,8 +191,7 @@ class CStateManager
|
|||
u32 xf20_ = 0;
|
||||
float xf24_thermColdScale1 = 0.f;
|
||||
float xf28_thermColdScale2 = 0.f;
|
||||
float xf2c_ = 1.f;
|
||||
float xf30_ = 1.f;
|
||||
zeus::CVector2f xf2c_viewportScale = {1.f, 1.f};
|
||||
u32 xf34_ = 2;
|
||||
TUniqueId xf38_skipCineSpecialFunc = kInvalidUniqueId;
|
||||
std::list<u32> xf3c_;
|
||||
|
@ -243,7 +242,7 @@ public:
|
|||
void AddDrawableActorPlane(const CActor& actor, const zeus::CPlane&, const zeus::CAABox& aabb) const;
|
||||
void AddDrawableActor(const CActor& actor, const zeus::CVector3f& vec, const zeus::CAABox& aabb) const;
|
||||
bool SpecialSkipCinematic();
|
||||
void GetVisAreaId() const;
|
||||
TAreaId GetVisAreaId() const;
|
||||
void GetWeaponIdCount(TUniqueId, EWeaponType);
|
||||
void RemoveWeaponId(TUniqueId, EWeaponType);
|
||||
void AddWeaponId(TUniqueId, EWeaponType);
|
||||
|
@ -261,11 +260,12 @@ public:
|
|||
void CacheReflection();
|
||||
bool CanCreateProjectile(TUniqueId, EWeaponType, int) const;
|
||||
const CGameLightList* GetDynamicLightList() const;
|
||||
void BuildDynamicLightListForWorld(std::vector<CLight>& listOut) const;
|
||||
void BuildDynamicLightListForWorld();
|
||||
void DrawDebugStuff() const;
|
||||
void RenderCamerasAndAreaLights() const;
|
||||
void DrawE3DeathEffect() const;
|
||||
void DrawAdditionalFilters() const;
|
||||
zeus::CFrustum SetupViewForDraw(const SViewport& vp) const;
|
||||
void DrawWorld() const;
|
||||
void SetupFogForArea(const CGameArea& area) const;
|
||||
void PreRender();
|
||||
|
|
|
@ -37,8 +37,8 @@ void CCameraBlurPass::Draw()
|
|||
return;
|
||||
|
||||
SClipScreenRect rect = {};
|
||||
rect.xc_width = CGraphics::g_ViewportResolution.x;
|
||||
rect.x10_height = CGraphics::g_ViewportResolution.y;
|
||||
rect.xc_width = g_Viewport.x8_width;
|
||||
rect.x10_height = g_Viewport.xc_height;
|
||||
CGraphics::ResolveSpareTexture(rect);
|
||||
|
||||
if (x10_curType == EBlurType::Xray)
|
||||
|
|
|
@ -28,7 +28,7 @@ CCameraManager::CCameraManager(TUniqueId curCameraId) : x0_curCameraId(curCamera
|
|||
{
|
||||
CSfxManager::AddListener(CSfxManager::ESfxChannels::Game, zeus::CVector3f::skZero, zeus::CVector3f::skZero,
|
||||
{1.f, 0.f, 0.f}, {0.f, 0.f, 1.f}, 50.f, 50.f, 1000.f, 1, 0x7f);
|
||||
sAspect = float(gViewport.x8_width / gViewport.xc_height);
|
||||
sAspect = float(g_Viewport.x8_width / g_Viewport.xc_height);
|
||||
sFirstPersonFOV = g_tweakGame->GetFirstPersonFOV();
|
||||
}
|
||||
|
||||
|
|
|
@ -101,16 +101,6 @@ zeus::CTransform CGameCamera::ValidateCameraTransform(const zeus::CTransform& a,
|
|||
return xfCpy;
|
||||
}
|
||||
|
||||
float CGameCamera::GetNearClipDistance() const { return x160_znear; }
|
||||
|
||||
float CGameCamera::GetFarClipDistance() const { return x164_zfar; }
|
||||
|
||||
float CGameCamera::GetAspectRatio() const { return x168_aspect; }
|
||||
|
||||
TUniqueId CGameCamera::GetWatchedObject() const { return xe8_watchedObject; }
|
||||
|
||||
float CGameCamera::GetFov() const { return x15c_currentFov; }
|
||||
|
||||
void CGameCamera::UpdatePerspective(float dt)
|
||||
{
|
||||
if (x174_ > 0.f)
|
||||
|
|
|
@ -38,11 +38,11 @@ public:
|
|||
zeus::CMatrix4f GetPerspectiveMatrix() const;
|
||||
zeus::CVector3f ConvertToScreenSpace(const zeus::CVector3f&) const;
|
||||
zeus::CTransform ValidateCameraTransform(const zeus::CTransform&, const zeus::CTransform&);
|
||||
float GetNearClipDistance() const;
|
||||
float GetFarClipDistance() const;
|
||||
float GetAspectRatio() const;
|
||||
TUniqueId GetWatchedObject() const;
|
||||
float GetFov() const;
|
||||
float GetNearClipDistance() const { return x160_znear; }
|
||||
float GetFarClipDistance() const { return x164_zfar; }
|
||||
float GetAspectRatio() const { return x168_aspect; }
|
||||
TUniqueId GetWatchedObject() const { return xe8_watchedObject; }
|
||||
float GetFov() const { return x15c_currentFov; }
|
||||
void GetControllerNumber() const;
|
||||
bool DisablesInput() const;
|
||||
void UpdatePerspective(float);
|
||||
|
|
|
@ -141,9 +141,12 @@ void Buckets::Init()
|
|||
}
|
||||
|
||||
CBooRenderer::CAreaListItem::CAreaListItem
|
||||
(const std::vector<CMetroidModelInstance>* geom, const CAreaRenderOctTree* octTree,
|
||||
(const std::vector<CMetroidModelInstance>* geom,
|
||||
const CAreaRenderOctTree* octTree,
|
||||
std::vector<TCachedToken<CTexture>>&& textures,
|
||||
std::vector<CBooModel*>&& models, int areaIdx)
|
||||
: x0_geometry(geom), x4_octTree(octTree), x10_models(std::move(models)), x18_areaIdx(areaIdx) {}
|
||||
: x0_geometry(geom), x4_octTree(octTree), x8_textures(std::move(textures)),
|
||||
x10_models(std::move(models)), x18_areaIdx(areaIdx) {}
|
||||
|
||||
CBooRenderer::CAreaListItem::~CAreaListItem() {}
|
||||
|
||||
|
@ -152,7 +155,7 @@ void CBooRenderer::ActivateLightsForModel(CAreaListItem* item, CBooModel& model)
|
|||
std::vector<CLight> thisLights;
|
||||
thisLights.reserve(4);
|
||||
|
||||
if (x304_lights.size())
|
||||
if (x300_dynamicLights.size())
|
||||
{
|
||||
/*
|
||||
void* unk3 = nullptr;
|
||||
|
@ -168,7 +171,7 @@ void CBooRenderer::ActivateLightsForModel(CAreaListItem* item, CBooModel& model)
|
|||
float lightRads[] = {-1.f, -1.f, -1.f, -1.f};
|
||||
for (int i=0 ; i<4 ; ++i)
|
||||
{
|
||||
for (CLight& light : x304_lights)
|
||||
for (CLight& light : x300_dynamicLights)
|
||||
{
|
||||
/*
|
||||
if (unk3)
|
||||
|
@ -337,14 +340,16 @@ void CBooRenderer::AddStaticGeometry(const std::vector<CMetroidModelInstance>* g
|
|||
auto search = FindStaticGeometry(geometry);
|
||||
if (search == x1c_areaListItems.end())
|
||||
{
|
||||
std::vector<TCachedToken<CTexture>> textures;
|
||||
std::vector<CBooModel*> models;
|
||||
if (geometry->size())
|
||||
{
|
||||
(*geometry)[0].m_instance->MakeTexturesFromMats(textures, xc_store);
|
||||
models.reserve(geometry->size());
|
||||
for (const CMetroidModelInstance& inst : *geometry)
|
||||
models.push_back(inst.m_instance);
|
||||
}
|
||||
x1c_areaListItems.emplace_back(geometry, octTree, std::move(models), areaIdx);
|
||||
x1c_areaListItems.emplace_back(geometry, octTree, std::move(textures), std::move(models), areaIdx);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -532,10 +537,10 @@ void CBooRenderer::SetPerspective(float fovy, float aspect, float znear, float z
|
|||
|
||||
zeus::CRectangle CBooRenderer::SetViewportOrtho(bool centered, float znear, float zfar)
|
||||
{
|
||||
float left = centered ? CGraphics::g_ViewportResolutionHalf.x : 0;
|
||||
float bottom = centered ? CGraphics::g_ViewportResolutionHalf.y : 0;
|
||||
float top = centered ? CGraphics::g_ViewportResolutionHalf.y : CGraphics::g_ViewportResolution.y;
|
||||
float right = centered ? CGraphics::g_ViewportResolutionHalf.x : CGraphics::g_ViewportResolution.x;
|
||||
float left = centered ? g_Viewport.x10_halfWidth : 0;
|
||||
float bottom = centered ? g_Viewport.x14_halfHeight : 0;
|
||||
float top = centered ? g_Viewport.x14_halfHeight : g_Viewport.xc_height;
|
||||
float right = centered ? g_Viewport.x10_halfWidth : g_Viewport.x8_width;
|
||||
|
||||
CGraphics::SetOrtho(left, right, top, bottom, znear, zfar);
|
||||
CGraphics::SetViewPointMatrix(zeus::CTransform::Identity());
|
||||
|
@ -561,7 +566,7 @@ void CBooRenderer::SetDebugOption(EDebugOption, int)
|
|||
|
||||
void CBooRenderer::BeginScene()
|
||||
{
|
||||
CGraphics::SetViewport(0, 0, CGraphics::g_ViewportResolution.x, CGraphics::g_ViewportResolution.y);
|
||||
CGraphics::SetViewport(0, 0, g_Viewport.x8_width, g_Viewport.xc_height);
|
||||
CGraphics::SetPerspective(75.f, CGraphics::g_ProjAspect, 1.f, 4096.f);
|
||||
CGraphics::SetModelMatrix(zeus::CTransform::Identity());
|
||||
CGraphics::BeginScene();
|
||||
|
@ -699,4 +704,27 @@ u32 CBooRenderer::GetStaticWorldDataSize()
|
|||
return 0;
|
||||
}
|
||||
|
||||
void CBooRenderer::PrepareDynamicLights(const std::vector<CLight>& lights)
|
||||
{
|
||||
x300_dynamicLights = lights;
|
||||
for (CAreaListItem& area : x1c_areaListItems)
|
||||
{
|
||||
if (const CAreaRenderOctTree* arot = area.x4_octTree)
|
||||
{
|
||||
area.x1c_lightOctreeWords.clear();
|
||||
area.x1c_lightOctreeWords.resize(arot->x14_bitmapWordCount * lights.size());
|
||||
u32* wordPtr = area.x1c_lightOctreeWords.data();
|
||||
for (const CLight& light : lights)
|
||||
{
|
||||
float radius = light.GetRadius();
|
||||
zeus::CVector3f vMin = light.GetPosition() - radius;
|
||||
zeus::CVector3f vMax = light.GetPosition() + radius;
|
||||
zeus::CAABox aabb(vMin, vMax);
|
||||
arot->FindOverlappingModels(wordPtr, aabb);
|
||||
wordPtr += arot->x14_bitmapWordCount;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
@ -54,12 +54,16 @@ class CBooRenderer : public IRenderer
|
|||
{
|
||||
const std::vector<CMetroidModelInstance>* x0_geometry;
|
||||
const CAreaRenderOctTree* x4_octTree;
|
||||
//std::vector<TCachedToken<CTexture>> x8_textures;
|
||||
/* originally auto_ptrs of vectors */
|
||||
std::vector<TCachedToken<CTexture>> x8_textures;
|
||||
std::vector<CBooModel*> x10_models;
|
||||
int x18_areaIdx;
|
||||
std::vector<u32> x20_;
|
||||
/* Per-area octree-word major, light bits minor */
|
||||
std::vector<u32> x1c_lightOctreeWords;
|
||||
|
||||
CAreaListItem(const std::vector<CMetroidModelInstance>* geom, const CAreaRenderOctTree* octTree,
|
||||
CAreaListItem(const std::vector<CMetroidModelInstance>* geom,
|
||||
const CAreaRenderOctTree* octTree,
|
||||
std::vector<TCachedToken<CTexture>>&& textures,
|
||||
std::vector<CBooModel*>&& models, int areaIdx);
|
||||
~CAreaListItem();
|
||||
};
|
||||
|
@ -110,7 +114,7 @@ class CBooRenderer : public IRenderer
|
|||
CThermalColdFilter m_thermColdFilter;
|
||||
std::experimental::optional<CThermalHotFilter> m_thermHotFilter;
|
||||
|
||||
std::vector<CLight> x304_lights;
|
||||
std::vector<CLight> x300_dynamicLights;
|
||||
|
||||
union
|
||||
{
|
||||
|
@ -198,6 +202,7 @@ public:
|
|||
void DoThermalBlendCold();
|
||||
void DoThermalBlendHot();
|
||||
u32 GetStaticWorldDataSize();
|
||||
void PrepareDynamicLights(const std::vector<CLight>& lights);
|
||||
|
||||
boo::ITexture* GetThermoPalette() {return x288_thermoPalette;}
|
||||
|
||||
|
|
|
@ -25,12 +25,10 @@ zeus::CTransform CGraphics::g_ViewMatrix;
|
|||
zeus::CVector3f CGraphics::g_ViewPoint;
|
||||
zeus::CTransform CGraphics::g_GXViewPointMatrix;
|
||||
zeus::CTransform CGraphics::g_CameraMatrix;
|
||||
zeus::CVector2i CGraphics::g_ViewportResolution;
|
||||
zeus::CVector2i CGraphics::g_ViewportResolutionHalf;
|
||||
SClipScreenRect CGraphics::g_CroppedViewport;
|
||||
int CGraphics::g_ViewportSamples = 1;
|
||||
bool CGraphics::g_IsGXModelMatrixIdentity = true;
|
||||
SViewport gViewport = {0, 0, 640, 480, 640 / 2.f, 480 / 2.f};
|
||||
SViewport g_Viewport = {0, 0, 640, 480, 640 / 2.f, 480 / 2.f};
|
||||
|
||||
void CGraphics::DisableAllLights()
|
||||
{
|
||||
|
@ -380,8 +378,8 @@ void CGraphics::FlushProjection()
|
|||
zeus::CVector2i CGraphics::ProjectPoint(const zeus::CVector3f& point)
|
||||
{
|
||||
zeus::CVector3f projPt = GetPerspectiveProjectionMatrix(false).multiplyOneOverW(point);
|
||||
return {int(projPt.x * g_ViewportResolutionHalf.x) + g_ViewportResolutionHalf.x,
|
||||
g_ViewportResolution.y - (int(projPt.y * g_ViewportResolutionHalf.y) + g_ViewportResolutionHalf.y)};
|
||||
return {int(projPt.x * g_Viewport.x10_halfWidth) + g_Viewport.x10_halfWidth,
|
||||
g_Viewport.x14_halfHeight - (int(projPt.y * g_Viewport.x14_halfHeight) + g_Viewport.x14_halfHeight)};
|
||||
}
|
||||
|
||||
SClipScreenRect CGraphics::ClipScreenRectFromMS(const zeus::CVector3f& p1,
|
||||
|
@ -413,7 +411,7 @@ SClipScreenRect CGraphics::ClipScreenRectFromVS(const zeus::CVector3f& p1,
|
|||
int minY2 = minY & 0xfffffffe;
|
||||
|
||||
|
||||
if (minX2 >= g_ViewportResolution.x)
|
||||
if (minX2 >= g_Viewport.x8_width)
|
||||
return {};
|
||||
|
||||
int maxX = abs(sp1.x - sp2.x) + minX;
|
||||
|
@ -422,10 +420,10 @@ SClipScreenRect CGraphics::ClipScreenRectFromVS(const zeus::CVector3f& p1,
|
|||
return {};
|
||||
|
||||
int finalMinX = std::max(minX, 0 /* ViewportX origin */);
|
||||
int finalMaxX = std::min(maxX, g_ViewportResolution.x);
|
||||
int finalMaxX = std::min(maxX, int(g_Viewport.x8_width));
|
||||
|
||||
|
||||
if (minY2 >= g_ViewportResolution.y)
|
||||
if (minY2 >= g_Viewport.xc_height)
|
||||
return {};
|
||||
|
||||
int maxY = abs(sp1.y - sp2.y) + minY;
|
||||
|
@ -434,13 +432,13 @@ SClipScreenRect CGraphics::ClipScreenRectFromVS(const zeus::CVector3f& p1,
|
|||
return {};
|
||||
|
||||
int finalMinY = std::max(minY, 0 /* ViewportY origin */);
|
||||
int finalMaxY = std::min(maxY, g_ViewportResolution.y);
|
||||
int finalMaxY = std::min(maxY, int(g_Viewport.xc_height));
|
||||
|
||||
int width = maxX2 - minX2;
|
||||
int height = maxY2 - minY2;
|
||||
return {true, minX2, minY2, width, height, width,
|
||||
minX2 / float(g_ViewportResolution.x), maxX2 / float(g_ViewportResolution.x),
|
||||
1.f - maxY2 / float(g_ViewportResolution.y), 1.f - minY2 / float(g_ViewportResolution.y)};
|
||||
minX2 / float(g_Viewport.x8_width), maxX2 / float(g_Viewport.x8_width),
|
||||
1.f - maxY2 / float(g_Viewport.xc_height), 1.f - minY2 / float(g_Viewport.xc_height)};
|
||||
|
||||
}
|
||||
|
||||
|
@ -452,11 +450,13 @@ zeus::CVector3f CGraphics::ProjectModelPointToViewportSpace(const zeus::CVector3
|
|||
|
||||
void CGraphics::SetViewportResolution(const zeus::CVector2i& res)
|
||||
{
|
||||
g_ViewportResolution = res;
|
||||
g_Viewport.x8_width = res.x;
|
||||
g_Viewport.xc_height = res.y;
|
||||
g_CroppedViewport = SClipScreenRect();
|
||||
g_CroppedViewport.xc_width = res.x;
|
||||
g_CroppedViewport.x10_height = res.y;
|
||||
g_ViewportResolutionHalf = {res.x / 2, res.y / 2};
|
||||
g_Viewport.x10_halfWidth = res.x / 2.f;
|
||||
g_Viewport.x14_halfHeight = res.y / 2.f;
|
||||
if (g_GuiSys)
|
||||
g_GuiSys->OnViewportResize();
|
||||
}
|
||||
|
|
|
@ -149,7 +149,7 @@ struct SViewport
|
|||
float x14_halfHeight;
|
||||
};
|
||||
|
||||
extern SViewport gViewport;
|
||||
extern SViewport g_Viewport;
|
||||
|
||||
struct SClipScreenRect
|
||||
{
|
||||
|
@ -236,8 +236,6 @@ public:
|
|||
static zeus::CVector3f g_ViewPoint;
|
||||
static zeus::CTransform g_GXViewPointMatrix;
|
||||
static zeus::CTransform g_CameraMatrix;
|
||||
static zeus::CVector2i g_ViewportResolution;
|
||||
static zeus::CVector2i g_ViewportResolutionHalf;
|
||||
static SClipScreenRect g_CroppedViewport;
|
||||
static int g_ViewportSamples;
|
||||
static bool g_IsGXModelMatrixIdentity;
|
||||
|
|
|
@ -128,15 +128,23 @@ private:
|
|||
|
||||
void VerifyCurrentShader(int shaderIdx);
|
||||
|
||||
static zeus::CVector3f g_PlayerPosition;
|
||||
static float g_ModSeconds;
|
||||
static float g_TransformedTime;
|
||||
static float g_TransformedTime2;
|
||||
static CBooModel* g_LastModelCached;
|
||||
|
||||
public:
|
||||
~CBooModel();
|
||||
CBooModel(TToken<CModel>& token, std::vector<CBooSurface>* surfaces, SShader& shader,
|
||||
boo::IVertexFormat* vtxFmt, boo::IGraphicsBufferS* vbo, boo::IGraphicsBufferS* ibo,
|
||||
size_t weightVecCount, size_t skinBankCount, const zeus::CAABox& aabb, int numInsts);
|
||||
|
||||
static void MakeTexuresFromMats(const MaterialSet& matSet,
|
||||
std::vector<TCachedToken<CTexture>>& toksOut,
|
||||
IObjectStore& store);
|
||||
static void MakeTexturesFromMats(const MaterialSet& matSet,
|
||||
std::vector<TCachedToken<CTexture>>& toksOut,
|
||||
IObjectStore& store);
|
||||
void MakeTexturesFromMats(std::vector<TCachedToken<CTexture>>& toksOut,
|
||||
IObjectStore& store);
|
||||
|
||||
bool IsOpaque() const {return x3c_firstSortedSurface == nullptr;}
|
||||
void ActivateLights(const std::vector<CLight>& lights);
|
||||
|
@ -167,6 +175,9 @@ public:
|
|||
|
||||
static bool g_DrawingOccluders;
|
||||
static void SetDrawingOccluders(bool occ) {g_DrawingOccluders = occ;}
|
||||
|
||||
static void SetNewPlayerPositionAndTime(const zeus::CVector3f& pos);
|
||||
static void KillCachedViewDepState();
|
||||
};
|
||||
|
||||
class CModel
|
||||
|
|
|
@ -25,6 +25,27 @@ void CBooModel::ClearModelUniformCounters()
|
|||
model->ClearUniformCounter();
|
||||
}
|
||||
|
||||
zeus::CVector3f CBooModel::g_PlayerPosition = {};
|
||||
float CBooModel::g_ModSeconds = 0.f;
|
||||
float CBooModel::g_TransformedTime = 0.f;
|
||||
float CBooModel::g_TransformedTime2 = 0.f;
|
||||
void CBooModel::SetNewPlayerPositionAndTime(const zeus::CVector3f& pos)
|
||||
{
|
||||
g_PlayerPosition = pos;
|
||||
KillCachedViewDepState();
|
||||
u32 modMillis = std::chrono::duration_cast<std::chrono::milliseconds>(
|
||||
std::chrono::steady_clock::now().time_since_epoch()).count() % u64(100000.f * 4.f * M_PIF / 3.f);
|
||||
g_ModSeconds = modMillis / 1000.f;
|
||||
g_TransformedTime = 1.f / -(0.05f * std::sin(g_ModSeconds * 1.5f) - 1.f);
|
||||
g_TransformedTime2 = 1.f / -(0.015f * std::sin(g_ModSeconds * 1.5f + 1.f) - 1.f);
|
||||
}
|
||||
|
||||
CBooModel* CBooModel::g_LastModelCached = nullptr;
|
||||
void CBooModel::KillCachedViewDepState()
|
||||
{
|
||||
g_LastModelCached = nullptr;
|
||||
}
|
||||
|
||||
CBooModel::~CBooModel()
|
||||
{
|
||||
if (m_prev)
|
||||
|
@ -213,15 +234,21 @@ CBooModel::ModelInstance* CBooModel::PushNewModelInstance()
|
|||
return &newInst;
|
||||
}
|
||||
|
||||
void CBooModel::MakeTexuresFromMats(const MaterialSet& matSet,
|
||||
std::vector<TCachedToken<CTexture>>& toksOut,
|
||||
IObjectStore& store)
|
||||
void CBooModel::MakeTexturesFromMats(const MaterialSet& matSet,
|
||||
std::vector<TCachedToken<CTexture>>& toksOut,
|
||||
IObjectStore& store)
|
||||
{
|
||||
toksOut.reserve(matSet.head.textureIDs.size());
|
||||
for (const DataSpec::UniqueID32& id : matSet.head.textureIDs)
|
||||
toksOut.emplace_back(store.GetObj({SBIG('TXTR'), id.toUint32()}));
|
||||
}
|
||||
|
||||
void CBooModel::MakeTexturesFromMats(std::vector<TCachedToken<CTexture>>& toksOut,
|
||||
IObjectStore& store)
|
||||
{
|
||||
MakeTexturesFromMats(*x4_matSet, toksOut, store);
|
||||
}
|
||||
|
||||
void CBooModel::ActivateLights(const std::vector<CLight>& lights)
|
||||
{
|
||||
m_lightingData.ambient = zeus::CColor::skBlack;
|
||||
|
@ -694,7 +721,7 @@ CModel::CModel(std::unique_ptr<u8[]>&& in, u32 /* dataLen */, IObjectStore* stor
|
|||
CBooModel::SShader& shader = x18_matSets.back();
|
||||
athena::io::MemoryReader r(sec, matSetSz);
|
||||
shader.m_matSet.read(r);
|
||||
CBooModel::MakeTexuresFromMats(shader.m_matSet, shader.x0_textures, *store);
|
||||
CBooModel::MakeTexturesFromMats(shader.m_matSet, shader.x0_textures, *store);
|
||||
}
|
||||
|
||||
hecl::HMDLMeta hmdlMeta;
|
||||
|
|
|
@ -35,6 +35,8 @@ public:
|
|||
};
|
||||
enum class EDebugOption
|
||||
{
|
||||
Zero,
|
||||
One
|
||||
};
|
||||
enum class EPrimitiveType
|
||||
{
|
||||
|
@ -97,6 +99,7 @@ public:
|
|||
virtual void DoThermalBlendCold()=0;
|
||||
virtual void DoThermalBlendHot()=0;
|
||||
virtual u32 GetStaticWorldDataSize()=0;
|
||||
virtual void PrepareDynamicLights(const std::vector<CLight>& lights)=0;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
@ -21,15 +21,15 @@ void CCameraBlurFilter::draw(float amount)
|
|||
return;
|
||||
|
||||
SClipScreenRect clipRect = {};
|
||||
clipRect.xc_width = CGraphics::g_ViewportResolution.x;
|
||||
clipRect.x10_height = CGraphics::g_ViewportResolution.y;
|
||||
clipRect.xc_width = g_Viewport.x8_width;
|
||||
clipRect.x10_height = g_Viewport.xc_height;
|
||||
CGraphics::ResolveSpareTexture(clipRect);
|
||||
float aspect = CGraphics::g_CroppedViewport.xc_width / float(CGraphics::g_CroppedViewport.x10_height);
|
||||
|
||||
float xFac = CGraphics::g_CroppedViewport.xc_width / float(CGraphics::g_ViewportResolution.x);
|
||||
float yFac = CGraphics::g_CroppedViewport.x10_height / float(CGraphics::g_ViewportResolution.y);
|
||||
float xBias = CGraphics::g_CroppedViewport.x4_left / float(CGraphics::g_ViewportResolution.x);
|
||||
float yBias = CGraphics::g_CroppedViewport.x8_top / float(CGraphics::g_ViewportResolution.y);
|
||||
float xFac = CGraphics::g_CroppedViewport.xc_width / float(g_Viewport.x8_width);
|
||||
float yFac = CGraphics::g_CroppedViewport.x10_height / float(g_Viewport.xc_height);
|
||||
float xBias = CGraphics::g_CroppedViewport.x4_left / float(g_Viewport.x8_width);
|
||||
float yBias = CGraphics::g_CroppedViewport.x8_top / float(g_Viewport.xc_height);
|
||||
|
||||
Vert verts[4] =
|
||||
{
|
||||
|
|
|
@ -39,12 +39,12 @@ void CColoredQuadFilter::draw(const zeus::CColor& color, const zeus::CRectangle&
|
|||
|
||||
void CWideScreenFilter::draw(const zeus::CColor& color, float t)
|
||||
{
|
||||
float aspect = CGraphics::g_ViewportResolution.x / float(CGraphics::g_ViewportResolution.y);
|
||||
float aspect = g_Viewport.x8_width / float(g_Viewport.xc_height);
|
||||
if (aspect < 1.7777f)
|
||||
{
|
||||
float targetHeight = CGraphics::g_ViewportResolution.x / 1.7777f;
|
||||
float delta = (CGraphics::g_ViewportResolution.y - targetHeight) * t / 2.f;
|
||||
delta /= float(CGraphics::g_ViewportResolution.y);
|
||||
float targetHeight = g_Viewport.x8_width / 1.7777f;
|
||||
float delta = (g_Viewport.xc_height - targetHeight) * t / 2.f;
|
||||
delta /= float(g_Viewport.xc_height);
|
||||
zeus::CRectangle rect(0.f, 0.f, 1.f, delta);
|
||||
m_bottom.draw(color, rect);
|
||||
rect.position.y = 1.f - delta;
|
||||
|
@ -54,14 +54,14 @@ void CWideScreenFilter::draw(const zeus::CColor& color, float t)
|
|||
|
||||
float CWideScreenFilter::SetViewportToMatch(float t)
|
||||
{
|
||||
float aspect = CGraphics::g_ViewportResolution.x / float(CGraphics::g_ViewportResolution.y);
|
||||
float aspect = g_Viewport.x8_width / float(g_Viewport.xc_height);
|
||||
if (aspect < 1.7777f)
|
||||
{
|
||||
float targetHeight = CGraphics::g_ViewportResolution.x / 1.7777f;
|
||||
float delta = (CGraphics::g_ViewportResolution.y - targetHeight) * t / 2.f;
|
||||
float targetHeight = g_Viewport.x8_width / 1.7777f;
|
||||
float delta = (g_Viewport.xc_height - targetHeight) * t / 2.f;
|
||||
boo::SWindowRect rect = {};
|
||||
rect.size[0] = CGraphics::g_ViewportResolution.x;
|
||||
rect.size[1] = CGraphics::g_ViewportResolution.y - delta * 2.f;
|
||||
rect.size[0] = g_Viewport.x8_width;
|
||||
rect.size[1] = g_Viewport.xc_height - delta * 2.f;
|
||||
rect.location[1] = delta;
|
||||
CGraphics::g_CroppedViewport = rect;
|
||||
CGraphics::g_BooMainCommandQueue->setViewport(rect);
|
||||
|
@ -77,8 +77,8 @@ float CWideScreenFilter::SetViewportToMatch(float t)
|
|||
void CWideScreenFilter::SetViewportToFull()
|
||||
{
|
||||
boo::SWindowRect rect = {};
|
||||
rect.size[0] = CGraphics::g_ViewportResolution.x;
|
||||
rect.size[1] = CGraphics::g_ViewportResolution.y;
|
||||
rect.size[0] = g_Viewport.x8_width;
|
||||
rect.size[1] = g_Viewport.xc_height;
|
||||
CGraphics::g_CroppedViewport = rect;
|
||||
CGraphics::g_BooMainCommandQueue->setViewport(rect);
|
||||
}
|
||||
|
|
|
@ -53,10 +53,10 @@ void CTexturedQuadFilter::draw(const zeus::CColor& color, float uvScale, const z
|
|||
|
||||
void CTexturedQuadFilter::drawCropped(const zeus::CColor& color, float uvScale)
|
||||
{
|
||||
float xFac = CGraphics::g_CroppedViewport.xc_width / float(CGraphics::g_ViewportResolution.x);
|
||||
float yFac = CGraphics::g_CroppedViewport.x10_height / float(CGraphics::g_ViewportResolution.y);
|
||||
float xBias = CGraphics::g_CroppedViewport.x4_left / float(CGraphics::g_ViewportResolution.x);
|
||||
float yBias = CGraphics::g_CroppedViewport.x8_top / float(CGraphics::g_ViewportResolution.y);
|
||||
float xFac = CGraphics::g_CroppedViewport.xc_width / float(g_Viewport.x8_width);
|
||||
float yFac = CGraphics::g_CroppedViewport.x10_height / float(g_Viewport.xc_height);
|
||||
float xBias = CGraphics::g_CroppedViewport.x4_left / float(g_Viewport.x8_width);
|
||||
float yBias = CGraphics::g_CroppedViewport.x8_top / float(g_Viewport.xc_height);
|
||||
|
||||
Vert verts[4] =
|
||||
{
|
||||
|
|
|
@ -77,7 +77,7 @@ void CGuiSys::OnViewportResize()
|
|||
|
||||
void CGuiSys::ViewportResizeFrame(CGuiFrame* frame)
|
||||
{
|
||||
float vpAspectRatio = CGraphics::g_ViewportResolution.x / float(CGraphics::g_ViewportResolution.y);
|
||||
float vpAspectRatio = g_Viewport.x8_width / float(g_Viewport.xc_height);
|
||||
if (frame->m_aspectConstraint > 0.f)
|
||||
{
|
||||
float hPad, vPad;
|
||||
|
|
|
@ -66,7 +66,7 @@ void CSplashScreen::Draw() const
|
|||
color.a = x18_splashTimeout * 2.f;
|
||||
|
||||
zeus::CRectangle rect;
|
||||
float aspect = CGraphics::g_ViewportResolution.x / float(CGraphics::g_ViewportResolution.y);
|
||||
float aspect = g_Viewport.x8_width / float(g_Viewport.xc_height);
|
||||
rect.size.x = m_quad.GetTex()->GetWidth() / (480.f * aspect);
|
||||
rect.size.y = m_quad.GetTex()->GetHeight() / 480.f;
|
||||
rect.position.x = 0.5f - rect.size.x / 2.f;
|
||||
|
|
|
@ -2187,7 +2187,7 @@ void CFrontEndUI::Draw() const
|
|||
g_Renderer->SetViewportOrtho(false, -4096.f, 4096.f);
|
||||
|
||||
/* Correct movie aspect ratio */
|
||||
float vpAspectRatio = CGraphics::g_ViewportResolution.x / float(CGraphics::g_ViewportResolution.y);
|
||||
float vpAspectRatio = g_Viewport.x8_width / float(g_Viewport.xc_height);
|
||||
float hPad, vPad;
|
||||
if (vpAspectRatio >= 1.78f)
|
||||
{
|
||||
|
|
|
@ -160,6 +160,7 @@ public:
|
|||
void EnsureRendered(const CStateManager&, const zeus::CVector3f&, const zeus::CVector3f&);
|
||||
SAdvancementDeltas UpdateAnimation(float, CStateManager&, bool);
|
||||
void SetActorLights(std::unique_ptr<CActorLights>);
|
||||
bool GetE7_29() const { return xe7_29_; }
|
||||
};
|
||||
}
|
||||
|
||||
|
|
|
@ -176,6 +176,12 @@ void CAreaRenderOctTree::FindOverlappingModels(std::vector<u32>& out, const zeus
|
|||
RecursiveBuildOverlaps(out.data(), *this, x18_aabb, testAABB);
|
||||
}
|
||||
|
||||
void CAreaRenderOctTree::FindOverlappingModels(u32* out, const zeus::CAABox& testAABB) const
|
||||
{
|
||||
reinterpret_cast<Node*>(x38_entries[x34_indirectionTable[0]])->
|
||||
RecursiveBuildOverlaps(out, *this, x18_aabb, testAABB);
|
||||
}
|
||||
|
||||
void CGameArea::CAreaFog::SetCurrent() const
|
||||
{
|
||||
g_Renderer->SetWorldFog(x0_fogMode, x4_rangeCur[0], x4_rangeCur[1], x1c_colorCur);
|
||||
|
|
|
@ -74,11 +74,13 @@ struct CAreaRenderOctTree
|
|||
CAreaRenderOctTree(const u8* buf);
|
||||
|
||||
void FindOverlappingModels(std::vector<u32>& out, const zeus::CAABox& testAABB) const;
|
||||
void FindOverlappingModels(u32* out, const zeus::CAABox& testAABB) const;
|
||||
};
|
||||
|
||||
class CGameArea : public IGameArea
|
||||
{
|
||||
friend class CWorld;
|
||||
friend class CStateManager;
|
||||
|
||||
int x4_selfIdx;
|
||||
ResId x8_nameSTRG;
|
||||
|
|
|
@ -573,4 +573,12 @@ void CWorld::PropogateAreaChain(CGameArea::EOcclusionState occlusionState, CGame
|
|||
if (occlusionState == CGameArea::EOcclusionState::NotOccluded)
|
||||
area->SetOcclusionState(CGameArea::EOcclusionState::NotOccluded);
|
||||
}
|
||||
|
||||
void CWorld::PreRender()
|
||||
{
|
||||
for (CGameArea* head = x4c_chainHeads[3] ; head != skGlobalNonConstEnd ; head = head->x130_next)
|
||||
{
|
||||
head->PreRender();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -184,6 +184,8 @@ public:
|
|||
static void PropogateAreaChain(CGameArea::EOcclusionState, CGameArea*, CWorld*);
|
||||
static const CGameArea* GetAliveAreasEnd() { return skGlobalEnd; }
|
||||
static CGameArea* AliveAreasEnd() { return skGlobalNonConstEnd; }
|
||||
|
||||
void PreRender();
|
||||
};
|
||||
|
||||
struct CWorldLayers
|
||||
|
|
|
@ -279,8 +279,8 @@ void CWorldTransManager::DrawEnabled()
|
|||
float t = zeus::clamp(0.f, (x0_curTime - x4_modelData->x1d0_dissolveStartTime) / 2.f, 1.f);
|
||||
DrawFirstPass();
|
||||
SClipScreenRect rect = {};
|
||||
rect.xc_width = CGraphics::g_ViewportResolution.x;
|
||||
rect.x10_height = CGraphics::g_ViewportResolution.y;
|
||||
rect.xc_width = g_Viewport.x8_width;
|
||||
rect.x10_height = g_Viewport.xc_height;
|
||||
CGraphics::ResolveSpareTexture(rect);
|
||||
CGraphics::g_BooMainCommandQueue->clearTarget(true, true);
|
||||
DrawSecondPass();
|
||||
|
@ -308,7 +308,7 @@ void CWorldTransManager::DrawDisabled()
|
|||
|
||||
void CWorldTransManager::DrawText()
|
||||
{
|
||||
float vpAspectRatio = CGraphics::g_ViewportResolution.x / float(CGraphics::g_ViewportResolution.y);
|
||||
float vpAspectRatio = g_Viewport.x8_width / float(g_Viewport.xc_height);
|
||||
float width = 448.f * vpAspectRatio;
|
||||
CGraphics::SetOrtho(0.f, width, 448.f, 0.f, -4096.f, 4096.f);
|
||||
CGraphics::SetViewPointMatrix(zeus::CTransform::Identity());
|
||||
|
|
Loading…
Reference in New Issue