mirror of https://github.com/AxioDL/metaforce.git
311 lines
11 KiB
C++
311 lines
11 KiB
C++
#include "CMappableObject.hpp"
|
|
#include "GameGlobalObjects.hpp"
|
|
#include "CMapWorldInfo.hpp"
|
|
#include "CSimplePool.hpp"
|
|
#include "CToken.hpp"
|
|
#include "Graphics/CTexture.hpp"
|
|
|
|
namespace urde
|
|
{
|
|
const zeus::CVector3f CMappableObject::skDoorVerts[8] = {};
|
|
|
|
static const u32 DoorIndices[] =
|
|
{
|
|
6, 4, 2, 0,
|
|
3, 1, 7, 5,
|
|
1, 0, 5, 4,
|
|
7, 6, 3, 2,
|
|
3, 2, 1, 0,
|
|
5, 4, 7, 6
|
|
};
|
|
|
|
CMappableObject::CMappableObject(const void* buf)
|
|
{
|
|
athena::io::MemoryReader r(buf, 64);
|
|
x0_type = EMappableObjectType(r.readUint32Big());
|
|
x4_visibilityMode = EVisMode(r.readUint32Big());
|
|
x8_objId = r.readUint32Big();
|
|
xc_ = r.readUint32Big();
|
|
x10_transform.read34RowMajor(r);
|
|
}
|
|
|
|
zeus::CTransform CMappableObject::AdjustTransformForType()
|
|
{
|
|
const float doorCenterX = g_tweakAutoMapper->GetDoorCenter().x;
|
|
const float doorCenterZ = g_tweakAutoMapper->GetDoorCenter().z;
|
|
if (x0_type == EMappableObjectType::BigDoor1)
|
|
{
|
|
zeus::CTransform orientation;
|
|
orientation.origin = {-1.4f*doorCenterX, 0.0f, 0.0f};
|
|
orientation.rotateLocalZ(zeus::degToRad(90.0f));
|
|
return (x10_transform * orientation) * zeus::CTransform::Scale(zeus::CVector3f{1.5f});
|
|
}
|
|
else if (x0_type == EMappableObjectType::BigDoor2)
|
|
{
|
|
zeus::CTransform orientation;
|
|
orientation.origin = {0.f, -2.0f * doorCenterZ, -1.4f * doorCenterX};
|
|
orientation.rotateLocalZ(zeus::degToRad(-90.f));
|
|
return (x10_transform * orientation) * zeus::CTransform::Scale(zeus::CVector3f{1.5f});
|
|
}
|
|
else if (x0_type == EMappableObjectType::IceDoorCeiling || x0_type == EMappableObjectType::WaveDoorCeiling
|
|
|| x0_type == EMappableObjectType::PlasmaDoorCeiling)
|
|
{
|
|
zeus::CTransform orientation;
|
|
orientation.origin = {-1.65f * doorCenterX, 0.f, -1.5f * doorCenterZ};
|
|
orientation.rotateLocalY(zeus::degToRad(90.f));
|
|
return x10_transform * orientation;
|
|
}
|
|
else if (x0_type == EMappableObjectType::IceDoorFloor || x0_type == EMappableObjectType::WaveDoorFloor
|
|
|| x0_type == EMappableObjectType::PlasmaDoorFloor)
|
|
{
|
|
zeus::CTransform orientation;
|
|
orientation.origin = {-1.65f * doorCenterX, 0.f, -1.f * doorCenterZ};
|
|
orientation.rotateLocalY(zeus::degToRad(90.f));
|
|
return x10_transform * orientation;
|
|
}
|
|
else if ((u32(x0_type) - u32(EMappableObjectType::IceDoorFloor2)) <= u32(EMappableObjectType::ShieldDoor)
|
|
|| x0_type == EMappableObjectType::PlasmaDoorFloor2)
|
|
{
|
|
zeus::CTransform orientation;
|
|
orientation.origin = {-0.49f * doorCenterX, 0.f, -1.f * doorCenterZ};
|
|
orientation.rotateLocalY(zeus::degToRad(90.f));
|
|
return x10_transform * orientation;
|
|
}
|
|
else if (x0_type >= EMappableObjectType::BlueDoor || x0_type <= EMappableObjectType::PlasmaDoorFloor2)
|
|
{
|
|
return x10_transform;
|
|
}
|
|
return zeus::CTransform::Translate(x10_transform.origin);
|
|
}
|
|
|
|
std::pair<zeus::CColor, zeus::CColor>
|
|
CMappableObject::GetDoorColors(int curAreaId, const CMapWorldInfo& mwInfo, float alpha) const
|
|
{
|
|
zeus::CColor color = {1.f, 0.f, 1.f, 1.f};
|
|
if (x8_objId.AreaNum() == curAreaId)
|
|
{
|
|
if (mwInfo.IsDoorVisited(x8_objId) && x0_type == EMappableObjectType::ShieldDoor)
|
|
{
|
|
color = g_tweakAutoMapper->GetDoorColor(0);
|
|
}
|
|
else
|
|
{
|
|
int colorIdx = 0;
|
|
switch (x0_type)
|
|
{
|
|
case EMappableObjectType::ShieldDoor:
|
|
colorIdx = 1;
|
|
break;
|
|
case EMappableObjectType::IceDoor:
|
|
case EMappableObjectType::IceDoorCeiling:
|
|
case EMappableObjectType::IceDoorFloor:
|
|
case EMappableObjectType::IceDoorFloor2:
|
|
colorIdx = 2;
|
|
break;
|
|
case EMappableObjectType::WaveDoor:
|
|
case EMappableObjectType::WaveDoorCeiling:
|
|
case EMappableObjectType::WaveDoorFloor:
|
|
case EMappableObjectType::WaveDoorFloor2:
|
|
colorIdx = 3;
|
|
break;
|
|
case EMappableObjectType::PlasmaDoor:
|
|
case EMappableObjectType::PlasmaDoorCeiling:
|
|
case EMappableObjectType::PlasmaDoorFloor:
|
|
case EMappableObjectType::PlasmaDoorFloor2:
|
|
colorIdx = 4;
|
|
default: break;
|
|
}
|
|
color = g_tweakAutoMapper->GetDoorColor(colorIdx);
|
|
}
|
|
}
|
|
else if (mwInfo.IsDoorVisited(x8_objId))
|
|
{
|
|
color = g_tweakAutoMapper->GetOpenDoorColor();
|
|
}
|
|
else
|
|
{
|
|
color = zeus::CColor::skClear;
|
|
}
|
|
|
|
color.a *= alpha;
|
|
return {color, zeus::CColor(std::min(1.4f * color.r, 1.f),
|
|
std::min(1.4f * color.g, 1.f),
|
|
std::min(1.4f * color.b, 1.f),
|
|
std::min(1.4f * color.a, 1.f))};
|
|
}
|
|
|
|
void CMappableObject::PostConstruct(const void *)
|
|
{
|
|
x10_transform = AdjustTransformForType();
|
|
}
|
|
|
|
void CMappableObject::Draw(int curArea, const CMapWorldInfo& mwInfo,
|
|
float alpha, bool needsVtxLoad) const
|
|
{
|
|
if (IsDoorType(x0_type))
|
|
{
|
|
std::pair<zeus::CColor, zeus::CColor> colors = GetDoorColors(curArea, mwInfo, alpha);
|
|
for (int s=0 ; s<6 ; ++s)
|
|
{
|
|
DoorSurface& ds = const_cast<DoorSurface&>(*m_doorSurface);
|
|
ds.m_surface.draw(colors.first, s * 4, 4);
|
|
CLineRenderer& line = ds.m_outline;
|
|
const u32* baseIdx = &DoorIndices[s * 4];
|
|
line.Reset();
|
|
line.AddVertex(skDoorVerts[baseIdx[0]], colors.second, 1.f);
|
|
line.AddVertex(skDoorVerts[baseIdx[1]], colors.second, 1.f);
|
|
line.AddVertex(skDoorVerts[baseIdx[3]], colors.second, 1.f);
|
|
line.AddVertex(skDoorVerts[baseIdx[2]], colors.second, 1.f);
|
|
line.Render();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CAssetId iconRes;
|
|
zeus::CColor iconColor = zeus::CColor::skWhite;
|
|
switch (x0_type)
|
|
{
|
|
case EMappableObjectType::DownArrowYellow:
|
|
iconRes = g_tweakPlayerRes->x10_minesBreakFirstTopIcon;
|
|
iconColor = zeus::CColor{1.f, 1.f, 0.588f, 1.f};
|
|
break;
|
|
case EMappableObjectType::UpArrowYellow:
|
|
iconRes = g_tweakPlayerRes->x14_minesBreakFirstBottomIcon;
|
|
iconColor = zeus::CColor{1.f, 1.f, 0.588f, 1.f};
|
|
break;
|
|
case EMappableObjectType::DownArrowGreen:
|
|
iconRes = g_tweakPlayerRes->x10_minesBreakFirstTopIcon;
|
|
iconColor = zeus::CColor{0.392f, 1.f, 0.588f, 1.f};
|
|
break;
|
|
case EMappableObjectType::UpArrowGreen:
|
|
iconRes = g_tweakPlayerRes->x14_minesBreakFirstBottomIcon;
|
|
iconColor = zeus::CColor{0.392f, 1.f, 0.588f, 1.f};
|
|
break;
|
|
case EMappableObjectType::DownArrowRed:
|
|
iconRes = g_tweakPlayerRes->x10_minesBreakFirstTopIcon;
|
|
iconColor = zeus::CColor{1.f, 0.392f, 0.588f, 1.f};
|
|
break;
|
|
case EMappableObjectType::UpArrowRed:
|
|
iconRes = g_tweakPlayerRes->x14_minesBreakFirstBottomIcon;
|
|
iconColor = zeus::CColor{1.f, 0.392f, 0.588f, 1.f};
|
|
break;
|
|
case EMappableObjectType::SaveStation:
|
|
iconRes = g_tweakPlayerRes->x4_saveStationIcon;
|
|
break;
|
|
case EMappableObjectType::MissileStation:
|
|
iconRes = g_tweakPlayerRes->x8_missileStationIcon;
|
|
break;
|
|
default:
|
|
iconRes = g_tweakPlayerRes->xc_elevatorIcon;
|
|
break;
|
|
}
|
|
|
|
iconColor.a *= alpha;
|
|
|
|
TLockedToken<CTexture> tex = g_SimplePool->GetObj(SObjectTag{FOURCC('TXTR'), iconRes});
|
|
if (!m_texQuadFilter || m_texQuadFilter->GetTex().GetObj() != tex.GetObj())
|
|
const_cast<CMappableObject*>(this)->m_texQuadFilter.emplace(EFilterType::Add, tex);
|
|
|
|
CTexturedQuadFilter::Vert verts[4] =
|
|
{
|
|
{{-2.6f, 0.f, 2.6f}, {0.f, 1.f}},
|
|
{{-2.6f, 0.f, -2.6f}, {0.f, 0.f}},
|
|
{{2.6f, 0.f, 2.6f}, {1.f, 1.f}},
|
|
{{2.6f, 0.f, -2.6f}, {1.f, 0.f}}
|
|
};
|
|
const_cast<CMappableObject*>(this)->m_texQuadFilter->drawVerts(iconColor, verts);
|
|
}
|
|
}
|
|
|
|
void CMappableObject::DrawDoorSurface(int curArea, const CMapWorldInfo& mwInfo,
|
|
float alpha, int surfIdx, bool needsVtxLoad) const
|
|
{
|
|
std::pair<zeus::CColor, zeus::CColor> colors = GetDoorColors(curArea, mwInfo, alpha);
|
|
DoorSurface& ds = const_cast<DoorSurface&>(*m_doorSurface);
|
|
ds.m_surface.draw(colors.first, surfIdx * 4, 4);
|
|
CLineRenderer& line = ds.m_outline;
|
|
const u32* baseIdx = &DoorIndices[surfIdx * 4];
|
|
line.Reset();
|
|
line.AddVertex(skDoorVerts[baseIdx[0]], colors.second, 1.f);
|
|
line.AddVertex(skDoorVerts[baseIdx[1]], colors.second, 1.f);
|
|
line.AddVertex(skDoorVerts[baseIdx[3]], colors.second, 1.f);
|
|
line.AddVertex(skDoorVerts[baseIdx[2]], colors.second, 1.f);
|
|
line.Render();
|
|
}
|
|
|
|
zeus::CVector3f CMappableObject::BuildSurfaceCenterPoint(int surfIdx) const
|
|
{
|
|
const zeus::CVector3f& doorCenter = g_tweakAutoMapper->GetDoorCenter();
|
|
|
|
switch (surfIdx)
|
|
{
|
|
case 0:
|
|
return x10_transform * zeus::CVector3f::skZero;
|
|
case 1:
|
|
return x10_transform * zeus::CVector3f{0.f, 0.f, 2.f * doorCenter.x};
|
|
case 2:
|
|
return x10_transform * zeus::CVector3f{0.f, -doorCenter.y, 0.f};
|
|
case 3:
|
|
return x10_transform * zeus::CVector3f{0.f, doorCenter.y, 0.f};
|
|
case 4:
|
|
return x10_transform * zeus::CVector3f{-doorCenter.x, 0.f, 0.f};
|
|
case 5:
|
|
return x10_transform * zeus::CVector3f{doorCenter.x, 0.f, 0.f};
|
|
default: break;
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
bool CMappableObject::IsVisibleToAutoMapper(bool worldVis, const CMapWorldInfo& mwInfo) const
|
|
{
|
|
bool areaVis = mwInfo.IsAreaVisible(x8_objId.AreaNum());
|
|
switch (x4_visibilityMode)
|
|
{
|
|
case EVisMode::Always:
|
|
default:
|
|
return true;
|
|
case EVisMode::MapStationOrVisit:
|
|
case EVisMode::MapStationOrVisit2:
|
|
return worldVis || areaVis;
|
|
case EVisMode::Visit:
|
|
if (IsDoorType(x0_type))
|
|
return mwInfo.IsDoorVisited(x8_objId);
|
|
return areaVis;
|
|
case EVisMode::Never:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
boo::ObjToken<boo::IGraphicsBufferS> CMappableObject::g_doorVbo;
|
|
boo::ObjToken<boo::IGraphicsBufferS> CMappableObject::g_doorIbo;
|
|
|
|
void CMappableObject::ReadAutoMapperTweaks(const ITweakAutoMapper& tweaks)
|
|
{
|
|
const zeus::CVector3f& center = tweaks.GetDoorCenter();
|
|
zeus::CVector3f* doorVerts = const_cast<zeus::CVector3f*>(&CMappableObject::skDoorVerts[0]);
|
|
/* Wrap door verts around -Z to build surface */
|
|
doorVerts[0].assign( -center.z, -center.y, 0.f);
|
|
doorVerts[1].assign( -center.z, -center.y, 2.f * center.x);
|
|
doorVerts[2].assign( -center.z, center.y, 0.f);
|
|
doorVerts[3].assign( -center.z, center.y, 2.f * center.x);
|
|
doorVerts[4].assign(.2f * -center.z, -center.y, 0.f);
|
|
doorVerts[5].assign(.2f * -center.z, -center.y, 2.f * center.x);
|
|
doorVerts[6].assign(.2f * -center.z, center.y, 0.f);
|
|
doorVerts[7].assign(.2f * -center.z, center.y, 2.f * center.x);
|
|
|
|
CGraphics::CommitResources([](boo::IGraphicsDataFactory::Context& ctx)
|
|
{
|
|
g_doorVbo = ctx.newStaticBuffer(boo::BufferUse::Vertex, skDoorVerts, 16, 8);
|
|
g_doorIbo = ctx.newStaticBuffer(boo::BufferUse::Index, DoorIndices, 4, 24);
|
|
return true;
|
|
} BooTrace);
|
|
}
|
|
|
|
void CMappableObject::Shutdown()
|
|
{
|
|
g_doorVbo.reset();
|
|
g_doorIbo.reset();
|
|
}
|
|
}
|