2019-09-29 00:30:53 +00:00
|
|
|
#include "Runtime/GuiSys/CAuiImagePane.hpp"
|
|
|
|
|
|
|
|
#include "Runtime/CSimplePool.hpp"
|
|
|
|
#include "Runtime/Camera/CCameraFilter.hpp"
|
|
|
|
#include "Runtime/Graphics/CTexture.hpp"
|
|
|
|
#include "Runtime/GuiSys/CGuiWidgetDrawParms.hpp"
|
2017-01-22 01:40:12 +00:00
|
|
|
|
2021-04-10 08:42:06 +00:00
|
|
|
namespace metaforce {
|
2017-01-22 01:40:12 +00:00
|
|
|
|
2017-08-13 05:26:14 +00:00
|
|
|
CAuiImagePane::CAuiImagePane(const CGuiWidgetParms& parms, CSimplePool* sp, CAssetId tex0, CAssetId tex1,
|
2017-01-22 01:40:12 +00:00
|
|
|
rstl::reserved_vector<zeus::CVector3f, 4>&& coords,
|
2017-05-14 19:58:44 +00:00
|
|
|
rstl::reserved_vector<zeus::CVector2f, 4>&& uvs, bool initTex)
|
2018-12-08 05:30:43 +00:00
|
|
|
: CGuiWidget(parms), xc8_tex0(tex0), xcc_tex1(tex1), xe0_coords(std::move(coords)), x114_uvs(std::move(uvs)) {
|
|
|
|
if (initTex)
|
|
|
|
SetTextureID0(tex0, sp);
|
2017-01-22 01:40:12 +00:00
|
|
|
}
|
|
|
|
|
2018-12-08 05:30:43 +00:00
|
|
|
std::shared_ptr<CGuiWidget> CAuiImagePane::Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp) {
|
|
|
|
CGuiWidgetParms parms = ReadWidgetHeader(frame, in);
|
|
|
|
in.readUint32Big();
|
|
|
|
in.readUint32Big();
|
|
|
|
in.readUint32Big();
|
|
|
|
u32 coordCount = in.readUint32Big();
|
|
|
|
rstl::reserved_vector<zeus::CVector3f, 4> coords;
|
2019-06-12 02:05:17 +00:00
|
|
|
for (u32 i = 0; i < coordCount; ++i)
|
2018-12-08 05:30:43 +00:00
|
|
|
coords.push_back(zeus::CVector3f::ReadBig(in));
|
|
|
|
u32 uvCount = in.readUint32Big();
|
|
|
|
rstl::reserved_vector<zeus::CVector2f, 4> uvs;
|
2019-06-12 02:05:17 +00:00
|
|
|
for (u32 i = 0; i < uvCount; ++i)
|
2018-12-08 05:30:43 +00:00
|
|
|
uvs.push_back(zeus::CVector2f::ReadBig(in));
|
|
|
|
std::shared_ptr<CGuiWidget> ret =
|
|
|
|
std::make_shared<CAuiImagePane>(parms, sp, -1, -1, std::move(coords), std::move(uvs), true);
|
|
|
|
ret->ParseBaseInfo(frame, in, parms);
|
|
|
|
return ret;
|
2017-01-22 01:40:12 +00:00
|
|
|
}
|
|
|
|
|
2019-03-10 09:37:36 +00:00
|
|
|
void CAuiImagePane::Reset(ETraversalMode mode) {
|
|
|
|
xc8_tex0 = CAssetId();
|
|
|
|
xb8_tex0Tok = TLockedToken<CTexture>();
|
|
|
|
CGuiWidget::Reset(mode);
|
|
|
|
}
|
|
|
|
|
2018-12-08 05:30:43 +00:00
|
|
|
void CAuiImagePane::Update(float dt) {
|
|
|
|
xd0_uvBias0.x() = std::fmod(xd0_uvBias0.x(), 1.f);
|
|
|
|
xd0_uvBias0.y() = std::fmod(xd0_uvBias0.y(), 1.f);
|
2019-02-24 07:15:54 +00:00
|
|
|
if (x138_tileSize != zeus::skZero2f && xb8_tex0Tok.IsLoaded()) {
|
2018-12-08 05:30:43 +00:00
|
|
|
zeus::CVector2f tmp = zeus::CVector2f(xb8_tex0Tok->GetWidth(), xb8_tex0Tok->GetHeight()) / x138_tileSize;
|
|
|
|
x144_frameTimer = std::fmod(x144_frameTimer + dt * x140_interval, std::floor(tmp.x()) * std::floor(tmp.y()));
|
|
|
|
}
|
|
|
|
|
|
|
|
CGuiWidget::Update(dt);
|
2017-05-18 07:07:49 +00:00
|
|
|
}
|
|
|
|
|
2018-12-08 05:30:43 +00:00
|
|
|
void CAuiImagePane::DoDrawImagePane(const zeus::CColor& color, const CTexture& tex, int frame, float alpha, bool noBlur,
|
2022-02-07 12:22:51 +00:00
|
|
|
EFilterType filter) const {
|
2018-12-08 05:30:43 +00:00
|
|
|
zeus::CColor useColor = color;
|
|
|
|
useColor.a() *= alpha;
|
|
|
|
|
|
|
|
rstl::reserved_vector<zeus::CVector2f, 4> vec;
|
|
|
|
const rstl::reserved_vector<zeus::CVector2f, 4>* useUVs;
|
2019-02-24 07:15:54 +00:00
|
|
|
if (x138_tileSize != zeus::skZero2f) {
|
2021-06-04 09:53:12 +00:00
|
|
|
const zeus::CVector2f res(xb8_tex0Tok->GetWidth(), -xb8_tex0Tok->GetHeight());
|
|
|
|
const zeus::CVector2f tmp = res / x138_tileSize;
|
2020-03-18 01:18:52 +00:00
|
|
|
const zeus::CVector2f tmpRecip = x138_tileSize / res;
|
2021-06-04 09:53:12 +00:00
|
|
|
const float x0 = tmpRecip.x() * static_cast<float>(frame % static_cast<int>(tmp.x()));
|
2020-03-18 01:18:52 +00:00
|
|
|
const float x1 = x0 + tmpRecip.x();
|
2021-06-04 09:53:12 +00:00
|
|
|
const float y0 = tmpRecip.y() * static_cast<float>(frame % static_cast<int>(tmp.y()));
|
2020-03-18 01:18:52 +00:00
|
|
|
const float y1 = y0 + tmpRecip.y();
|
2018-12-08 05:30:43 +00:00
|
|
|
vec.push_back(zeus::CVector2f(x0, y0));
|
|
|
|
vec.push_back(zeus::CVector2f(x0, y1));
|
|
|
|
vec.push_back(zeus::CVector2f(x1, y1));
|
2021-06-04 09:06:24 +00:00
|
|
|
vec.push_back(zeus::CVector2f(x1, y0));
|
2018-12-08 05:30:43 +00:00
|
|
|
useUVs = &vec;
|
|
|
|
} else {
|
|
|
|
useUVs = &x114_uvs;
|
|
|
|
}
|
|
|
|
|
2022-02-07 12:22:51 +00:00
|
|
|
std::vector<zeus::CVector2f> realUseUvs;
|
|
|
|
realUseUvs.reserve(4);
|
|
|
|
for (auto v : *useUVs) {
|
|
|
|
realUseUvs.push_back(v + xd0_uvBias0);
|
|
|
|
}
|
|
|
|
|
2022-02-08 19:18:12 +00:00
|
|
|
bool zTest = xac_drawFlags == EGuiModelDrawFlags::Shadeless || xac_drawFlags == EGuiModelDrawFlags::Opaque;
|
2018-12-08 05:30:43 +00:00
|
|
|
if (noBlur) {
|
2022-02-07 12:22:51 +00:00
|
|
|
aurora::shaders::queue_textured_quad_verts(
|
2022-02-08 19:18:12 +00:00
|
|
|
aurora::shaders::CameraFilterType(filter), tex.GetTexture()->ref, aurora::shaders::ZTest::LEqual, zTest, useColor,
|
2022-02-07 12:22:51 +00:00
|
|
|
{xe0_coords.data(), xe0_coords.size()}, {realUseUvs.data(), xe0_coords.size()}, 0);
|
|
|
|
// quad.drawVerts(useColor, verts);
|
2018-12-08 05:30:43 +00:00
|
|
|
} else if ((x14c_deResFactor == 0.f && alpha == 1.f) || tex.GetNumMips() == 1) {
|
2022-02-07 12:22:51 +00:00
|
|
|
aurora::shaders::queue_textured_quad_verts(
|
2022-02-08 19:18:12 +00:00
|
|
|
aurora::shaders::CameraFilterType(filter), tex.GetTexture()->ref, aurora::shaders::ZTest::LEqual, zTest,
|
|
|
|
useColor, {xe0_coords.data(), xe0_coords.size()}, {realUseUvs.data(), xe0_coords.size()}, 0);
|
2018-12-08 05:30:43 +00:00
|
|
|
} else {
|
2020-03-18 01:18:52 +00:00
|
|
|
const float tmp = (1.f - x14c_deResFactor) * alpha;
|
|
|
|
const float tmp3 = 1.f - tmp * tmp * tmp;
|
2020-04-20 02:06:11 +00:00
|
|
|
const float mip = tmp3 * static_cast<float>(tex.GetNumMips() - 1);
|
2022-02-07 12:22:51 +00:00
|
|
|
aurora::shaders::queue_textured_quad_verts(
|
2022-02-08 19:18:12 +00:00
|
|
|
aurora::shaders::CameraFilterType(filter), tex.GetTexture()->ref, aurora::shaders::ZTest::LEqual, zTest,
|
|
|
|
useColor, {xe0_coords.data(), xe0_coords.size()}, {realUseUvs.data(), xe0_coords.size()}, mip);
|
2018-12-08 05:30:43 +00:00
|
|
|
}
|
2017-05-18 07:07:49 +00:00
|
|
|
}
|
|
|
|
|
2020-03-18 05:14:36 +00:00
|
|
|
void CAuiImagePane::Draw(const CGuiWidgetDrawParms& params) {
|
2018-12-08 05:30:43 +00:00
|
|
|
CGraphics::SetModelMatrix(x34_worldXF);
|
2020-03-18 05:14:36 +00:00
|
|
|
if (!GetIsVisible() || !xb8_tex0Tok.IsLoaded()) {
|
2018-12-08 05:30:43 +00:00
|
|
|
return;
|
2020-03-18 05:14:36 +00:00
|
|
|
}
|
2020-04-11 22:51:39 +00:00
|
|
|
SCOPED_GRAPHICS_DEBUG_GROUP(fmt::format(FMT_STRING("CAuiImagePane::Draw {}"), m_name).c_str(), zeus::skCyan);
|
2018-12-08 05:30:43 +00:00
|
|
|
GetIsFinishedLoadingWidgetSpecific();
|
|
|
|
zeus::CColor color = xa8_color2;
|
|
|
|
color.a() *= params.x0_alphaMod;
|
|
|
|
// SetZUpdate(xac_drawFlags == EGuiModelDrawFlags::Shadeless || xac_drawFlags == EGuiModelDrawFlags::Opaque);
|
|
|
|
float blur0 = 1.f;
|
|
|
|
float blur1 = 0.f;
|
2020-04-20 02:06:11 +00:00
|
|
|
const int frame0 = static_cast<int>(x144_frameTimer);
|
2018-12-08 05:30:43 +00:00
|
|
|
int frame1 = 0;
|
|
|
|
if (x140_interval < 1.f && x140_interval > 0.f) {
|
|
|
|
zeus::CVector2f tmp = zeus::CVector2f(xb8_tex0Tok->GetWidth(), xb8_tex0Tok->GetHeight()) / x138_tileSize;
|
2020-04-20 02:06:11 +00:00
|
|
|
frame1 = (frame0 + 1) % static_cast<int>(tmp.x() * tmp.y());
|
2018-12-08 05:30:43 +00:00
|
|
|
if (x148_fadeDuration == 0.f)
|
|
|
|
blur1 = 1.f;
|
2017-05-18 07:07:49 +00:00
|
|
|
else
|
2018-12-08 05:30:43 +00:00
|
|
|
blur1 = std::min(std::fmod(x144_frameTimer, 1.f) / x148_fadeDuration, 1.f);
|
|
|
|
blur0 = 1.f - blur1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Alpha blend
|
2022-02-07 12:22:51 +00:00
|
|
|
DoDrawImagePane(color * zeus::CColor(0.f, 0.5f), *xb8_tex0Tok, frame0, 1.f, true, EFilterType::Blend);
|
2018-12-08 05:30:43 +00:00
|
|
|
|
|
|
|
if (x150_flashFactor > 0.f) {
|
|
|
|
// Additive blend
|
|
|
|
zeus::CColor color2 = xa8_color2;
|
|
|
|
color2.a() = x150_flashFactor;
|
2022-02-07 12:22:51 +00:00
|
|
|
DoDrawImagePane(color2, *xb8_tex0Tok, frame0, blur0, false, EFilterType::Blend);
|
2018-12-08 05:30:43 +00:00
|
|
|
if (blur1 > 0.f)
|
2022-02-07 12:22:51 +00:00
|
|
|
DoDrawImagePane(color2, *xb8_tex0Tok, frame1, blur1, false, EFilterType::Blend);
|
2018-12-08 05:30:43 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
switch (xac_drawFlags) {
|
|
|
|
case EGuiModelDrawFlags::Shadeless:
|
|
|
|
case EGuiModelDrawFlags::Opaque:
|
|
|
|
// Opaque blend
|
2022-02-07 12:22:51 +00:00
|
|
|
DoDrawImagePane(color, *xb8_tex0Tok, frame0, blur0, false, EFilterType::Blend);
|
2018-12-08 05:30:43 +00:00
|
|
|
if (blur1 > 0.f)
|
2022-02-07 12:22:51 +00:00
|
|
|
DoDrawImagePane(color, *xb8_tex0Tok, frame1, blur1, false, EFilterType::Blend);
|
2018-12-08 05:30:43 +00:00
|
|
|
break;
|
|
|
|
case EGuiModelDrawFlags::Alpha:
|
2017-05-18 07:07:49 +00:00
|
|
|
// Alpha blend
|
2022-02-07 12:22:51 +00:00
|
|
|
DoDrawImagePane(color, *xb8_tex0Tok, frame0, blur0, false, EFilterType::Blend);
|
2018-12-08 05:30:43 +00:00
|
|
|
if (blur1 > 0.f)
|
2022-02-07 12:22:51 +00:00
|
|
|
DoDrawImagePane(color, *xb8_tex0Tok, frame1, blur1, false, EFilterType::Blend);
|
2018-12-08 05:30:43 +00:00
|
|
|
break;
|
|
|
|
case EGuiModelDrawFlags::Additive:
|
|
|
|
// Additive blend
|
2022-02-07 12:22:51 +00:00
|
|
|
DoDrawImagePane(color, *xb8_tex0Tok, frame0, blur0, false, EFilterType::Add);
|
2018-12-08 05:30:43 +00:00
|
|
|
if (blur1 > 0.f)
|
2022-02-07 12:22:51 +00:00
|
|
|
DoDrawImagePane(color, *xb8_tex0Tok, frame1, blur1, false, EFilterType::Add);
|
2018-12-08 05:30:43 +00:00
|
|
|
break;
|
|
|
|
case EGuiModelDrawFlags::AlphaAdditiveOverdraw:
|
|
|
|
// Alpha blend
|
2022-02-07 12:22:51 +00:00
|
|
|
DoDrawImagePane(color, *xb8_tex0Tok, frame0, blur0, false, EFilterType::Blend);
|
2018-12-08 05:30:43 +00:00
|
|
|
if (blur1 > 0.f)
|
2022-02-07 12:22:51 +00:00
|
|
|
DoDrawImagePane(color, *xb8_tex0Tok, frame1, blur1, false, EFilterType::Blend);
|
2018-12-08 05:30:43 +00:00
|
|
|
// Full additive blend
|
2022-02-07 12:22:51 +00:00
|
|
|
DoDrawImagePane(color, *xb8_tex0Tok, frame0, blur0, false, EFilterType::Add);
|
2018-12-08 05:30:43 +00:00
|
|
|
if (blur1 > 0.f)
|
2022-02-07 12:22:51 +00:00
|
|
|
DoDrawImagePane(color, *xb8_tex0Tok, frame1, blur1, false, EFilterType::Add);
|
2018-12-08 05:30:43 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2017-05-18 07:07:49 +00:00
|
|
|
}
|
|
|
|
|
2020-03-18 05:14:36 +00:00
|
|
|
bool CAuiImagePane::GetIsFinishedLoadingWidgetSpecific() { return !xb8_tex0Tok || xb8_tex0Tok.IsLoaded(); }
|
2017-05-18 07:07:49 +00:00
|
|
|
|
2018-12-08 05:30:43 +00:00
|
|
|
void CAuiImagePane::SetTextureID0(CAssetId tex, CSimplePool* sp) {
|
|
|
|
xc8_tex0 = tex;
|
|
|
|
if (!sp)
|
|
|
|
return;
|
|
|
|
if (xc8_tex0.IsValid())
|
|
|
|
xb8_tex0Tok = sp->GetObj({FOURCC('TXTR'), xc8_tex0});
|
|
|
|
else
|
|
|
|
xb8_tex0Tok = TLockedToken<CTexture>();
|
2017-05-14 19:58:44 +00:00
|
|
|
}
|
|
|
|
|
2018-12-08 05:30:43 +00:00
|
|
|
void CAuiImagePane::SetAnimationParms(const zeus::CVector2f& tileSize, float interval, float fadeDuration) {
|
|
|
|
x138_tileSize = tileSize;
|
|
|
|
x140_interval = interval;
|
|
|
|
x144_frameTimer = 0.f;
|
|
|
|
x148_fadeDuration = fadeDuration;
|
2017-05-14 19:58:44 +00:00
|
|
|
}
|
|
|
|
|
2021-04-10 08:42:06 +00:00
|
|
|
} // namespace metaforce
|