From 24a602c10f0e526fec789960bd6aa5eba2ae5023 Mon Sep 17 00:00:00 2001 From: Phillip Stephens Date: Sat, 5 Mar 2022 13:46:53 -0800 Subject: [PATCH] Cleanup and more migration to Stream --- Runtime/CMain.cpp | 11 - Runtime/Graphics/CGraphics.cpp | 11 + Runtime/Graphics/CGraphics.hpp | 2 + Runtime/Graphics/GX.hpp | 338 +++++++++++++++++++++++++++++-- Runtime/GuiSys/CAuiImagePane.cpp | 97 +++++---- Runtime/GuiSys/CAuiImagePane.hpp | 3 +- Runtime/GuiSys/CGuiPane.cpp | 5 + Runtime/GuiSys/CGuiPane.hpp | 1 + Runtime/Particle/CDecal.cpp | 39 ++-- Runtime/Particle/CDecal.hpp | 6 - aurora/include/aurora/gfx.hpp | 2 +- aurora/lib/gfx/stream.cpp | 8 +- 12 files changed, 422 insertions(+), 101 deletions(-) diff --git a/Runtime/CMain.cpp b/Runtime/CMain.cpp index 42f3fadf7..69aa4a1ab 100644 --- a/Runtime/CMain.cpp +++ b/Runtime/CMain.cpp @@ -610,18 +610,7 @@ int main(int argc, char** argv) { .width = icon.width, .height = icon.height, }; -#ifdef NDEBUG - /* Before we start running the app, lets get a thread going to detect any infinite loops */ - metaforce::CInfiniteLoopDetector infiniteLoopDetector; - std::thread infiniteLoopDetectorThread(&metaforce::CInfiniteLoopDetector::run, &infiniteLoopDetector); - infiniteLoopDetectorThread.detach(); aurora::app_run(std::move(app), std::move(data), argc, argv); - infiniteLoopDetector.stop(); -#else - /* Debuggers can interrupt the loop detector and make it unable to perform its job correctly, so lets not detect - * infinite loops in a debug build */ - aurora::app_run(std::move(app), std::move(data), argc, argv); -#endif return 0; } #endif diff --git a/Runtime/Graphics/CGraphics.cpp b/Runtime/Graphics/CGraphics.cpp index fe02b4ec6..c6705dfd4 100644 --- a/Runtime/Graphics/CGraphics.cpp +++ b/Runtime/Graphics/CGraphics.cpp @@ -576,4 +576,15 @@ void CGraphics::StreamVertex(const zeus::CVector3f& pos) { } void CGraphics::StreamEnd() { aurora::gfx::stream_end(); } + +void CGraphics::DrawPrimitive(GX::Primitive primitive, const zeus::CVector3f* pos, const zeus::CVector3f& normal, + const zeus::CColor& col, s32 numVerts) { + StreamBegin(primitive); + StreamColor(col); + StreamNormal(normal); + for (u32 i = 0; i < numVerts; ++i) { + StreamVertex(pos[i]); + } + StreamEnd(); +} } // namespace metaforce diff --git a/Runtime/Graphics/CGraphics.hpp b/Runtime/Graphics/CGraphics.hpp index a83bef3cd..be7b5712a 100644 --- a/Runtime/Graphics/CGraphics.hpp +++ b/Runtime/Graphics/CGraphics.hpp @@ -302,6 +302,8 @@ public: static void StreamVertex(float x, float y, float z); static void StreamVertex(const zeus::CVector3f& pos); static void StreamEnd(); + static void DrawPrimitive(GX::Primitive primitive, const zeus::CVector3f* pos, const zeus::CVector3f& normal, + const zeus::CColor& col, s32 numVerts); }; template diff --git a/Runtime/Graphics/GX.hpp b/Runtime/Graphics/GX.hpp index 6a3ee9cf7..d302b5e02 100644 --- a/Runtime/Graphics/GX.hpp +++ b/Runtime/Graphics/GX.hpp @@ -4,7 +4,60 @@ #include namespace GX { -enum AttrType { NONE, DIRECT, INDEX8, INDEX16 }; +enum Attr { + VA_PNMTXIDX = 0x0, + VA_TEX0MTXIDX = 0x1, + VA_TEX1MTXIDX = 0x2, + VA_TEX2MTXIDX = 0x3, + VA_TEX3MTXIDX = 0x4, + VA_TEX4MTXIDX = 0x5, + VA_TEX5MTXIDX = 0x6, + VA_TEX6MTXIDX = 0x7, + VA_TEX7MTXIDX = 0x8, + VA_POS = 0x9, + VA_NRM = 0xa, + VA_CLR0 = 0xb, + VA_CLR1 = 0xc, + VA_TEX0 = 0xd, + VA_TEX1 = 0xe, + VA_TEX2 = 0xf, + VA_TEX3 = 0x10, + VA_TEX4 = 0x11, + VA_TEX5 = 0x12, + VA_TEX6 = 0x13, + VA_TEX7 = 0x14, + POS_MTX_ARRAY = 0x15, + NRM_MTX_ARRAY = 0x16, + TEX_MTX_ARRAY = 0x17, + LIGHT_ARRAY = 0x18, + VA_NBT = 0x19, + VA_MAX_ATTR = 0x1a, + VA_NULL = 0xff, +}; + +enum AttrType { + NONE, + DIRECT, + INDEX8, + INDEX16, +}; + +struct VtxDescList { + Attr attr; + AttrType type; +}; + +enum VtxFmt { + VTXFMT0 = 0, + VTXFMT1, + VTXFMT2, + VTXFMT3, + VTXFMT4, + VTXFMT5, + VTXFMT6, + VTXFMT7, + MAX_VTXFMT, +}; enum TevColorArg { CC_CPREV = 0, @@ -36,7 +89,15 @@ enum TevAlphaArg { CA_ZERO = 7, }; -enum TevKColorSel { +enum TevKColorID { + KCOLOR0 = 0, + KCOLOR1, + KCOLOR2, + KCOLOR3, + MAX_KCOLOR, +}; + +enum TevKColorSel : uint8_t { TEV_KCSEL_8_8 = 0x00, TEV_KCSEL_7_8 = 0x01, TEV_KCSEL_6_8 = 0x02, @@ -70,7 +131,8 @@ enum TevKColorSel { TEV_KCSEL_K0_A = 0x1C, TEV_KCSEL_K1_A = 0x1D, TEV_KCSEL_K2_A = 0x1E, - TEV_KCSEL_K3_A = 0x1F + TEV_KCSEL_K3_A = 0x1F, + INVALID_KCSEL = 0xFF }; enum TevKAlphaSel { @@ -103,7 +165,8 @@ enum TevKAlphaSel { TEV_KASEL_K0_A = 0x1C, TEV_KASEL_K1_A = 0x1D, TEV_KASEL_K2_A = 0x1E, - TEV_KASEL_K3_A = 0x1F + TEV_KASEL_K3_A = 0x1F, + INVALID_KASEL = 0xFF }; enum TevOp { @@ -127,7 +190,22 @@ enum TevBias { TB_SUBHALF = 2, }; -enum TevScale { CS_SCALE_1 = 0, CS_SCALE_2 = 1, CS_SCALE_4 = 2, CS_DIVIDE_2 = 3 }; +enum TevScale { + CS_SCALE_1 = 0, + CS_SCALE_2 = 1, + CS_SCALE_4 = 2, + CS_DIVIDE_2 = 3, +}; + +enum TexOffset { + TO_ZERO, + TO_SIXTEENTH, + TO_EIGHTH, + TO_FOURTH, + TO_HALF, + TO_ONE, + MAX_TEXOFFSET, +}; enum TexGenType { TG_MTX3x4 = 0, @@ -205,11 +283,51 @@ enum PTTexMtx { PTIDENTITY = 125 }; -enum TevRegID { TEVPREV = 0, TEVREG0 = 1, TEVREG1 = 2, TEVREG2 = 3, TEVLAZY = 5 }; +enum TexCoordID { + TEXCOORD0 = 0x0, + TEXCOORD1, + TEXCOORD2, + TEXCOORD3, + TEXCOORD4, + TEXCOORD5, + TEXCOORD6, + TEXCOORD7, + MAX_TEXCOORD = 8, + TEXCOORD_NULL = 0xff +}; -enum DiffuseFn { DF_NONE = 0, DF_SIGN, DF_CLAMP }; +enum TevSwapSel { + TEV_SWAP0 = 0x0, + TEV_SWAP1 = 0x1, + TEV_SWAP2 = 0x2, + TEV_SWAP3 = 0x3, + MAX_TEVSWAP = 0x4, +}; +enum TevColorChan { + CH_RED = 0x0, + CH_GREEN = 0x1, + CH_BLUE = 0x2, + CH_ALPHA = 0x3, +}; +enum TevRegID { + TEVPREV = 0, + TEVREG0 = 1, + TEVREG1 = 2, + TEVREG2 = 3, + TEVLAZY = 5, +}; -enum AttnFn { AF_SPEC = 0, AF_SPOT = 1, AF_NONE }; +enum DiffuseFn { + DF_NONE = 0, + DF_SIGN, + DF_CLAMP, +}; + +enum AttnFn { + AF_SPEC = 0, + AF_SPOT = 1, + AF_NONE, +}; enum Primitive { POINTS = 0xb8, @@ -222,16 +340,69 @@ enum Primitive { }; enum ChannelID { - GX_COLOR0, - GX_COLOR1, - GX_ALPHA0, - GX_ALPHA1, - GX_COLOR0A0, - GX_COLOR1A1, - GX_COLOR_ZERO, - GX_ALPHA_BUMP, - GX_ALPHA_BUMPN, - GX_COLOR_NULL = 0xff + COLOR0, + COLOR1, + ALPHA0, + ALPHA1, + COLOR0A0, + COLOR1A1, + COLOR_ZERO, + ALPHA_BUMP, + ALPHA_BUMPN, + COLOR_NULL = 0xff +}; + +enum BlendMode : uint8_t { + BM_NONE, + BM_BLEND, + BM_LOGIC, + BM_SUBTRACT, + MAX_BLENDMODE, +}; + +enum LogicOp : uint8_t { + LO_CLEAR, + LO_AND, + LO_REVAND, + LO_COPY, + LO_INVAND, + LO_NOOP, + LO_XOR, + LO_OR, + LO_NOR, + LO_EQUIV, + LO_INV, + LO_REVOR, + LO_INVCOPY, + LO_INVOR, + LO_NAND, + LO_SET +}; + +enum AlphaOp : uint8_t { + AOP_AND, + AOP_OR, + AOP_XOR, + AOP_XNOR, + MAX_ALPHAOP, +}; + +enum ZTexOp { + ZT_DISABLE, + ZT_ADD, + ZT_REPLACE, + MAX_ZTEXOP, +}; + +enum Compare { + NEVER, + LESS, + EQUAL, + LEQUAL, + GREATER, + NEQUAL, + GEQUAL, + ALWAYS, }; enum BlendFactor : uint16_t { @@ -288,6 +459,103 @@ enum TexMapID { MAX_TEXMAP, }; +enum TevStageID { + TEVSTAGE0, + TEVSTAGE1, + TEVSTAGE2, + TEVSTAGE3, + TEVSTAGE4, + TEVSTAGE5, + TEVSTAGE6, + TEVSTAGE7, + TEVSTAGE8, + TEVSTAGE9, + TEVSTAGE10, + TEVSTAGE11, + TEVSTAGE12, + TEVSTAGE13, + TEVSTAGE14, + TEVSTAGE15, + MAX_TEVSTAGE +}; + +enum IndTexFormat { + ITF_8, + ITF_5, + ITF_4, + ITF_3, + MAX_ITFORMAT, +}; + +enum IndTexBiasSel { + ITB_NONE, + ITB_S, + ITB_T, + ITB_ST, + ITB_U, + ITB_SU, + ITB_TU, + ITB_STU, + MAX_ITBIAS, +}; + +enum IndTexWrap { + ITW_OFF, + ITW_256, + ITW_128, + ITW_64, + ITW_32, + ITW_16, + ITW_0, + MAX_ITWRAP, +}; + +enum IndTexAlphaSel { + ITBA_OFF, + ITBA_S, + ITBA_T, + ITBA_U, + MAX_ITBALPHA, +}; +enum IndTexStageID { + INDTEXSTAGE0, + INDTEXSTAGE1, + INDTEXSTAGE2, + INDTEXSTAGE3, + MAX_INDTEXSTAGE, +}; + +enum GXIndTexScale { + ITS_1, + ITS_2, + ITS_4, + ITS_8, + ITS_16, + ITS_32, + ITS_64, + ITS_128, + ITS_256, + MAX_ITSCALE, +}; + +enum IndTexMtxID { + ITM_OFF, + ITM_0, + ITM_1, + ITM_2, + ITM_S0 = 5, + ITM_S1, + ITM_S2, + ITM_T0 = 9, + ITM_T1, + ITM_T2, +}; + +enum TexMtxType { + MTX3x4 = 0, + MTX2x4, +}; + struct Color { union { uint8_t color[4]; @@ -316,11 +584,43 @@ struct Color { return *this; } - explicit Color(uint8_t val) { *this = val; } + explicit Color(uint32_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]; } }; +enum ColorSrc { + SRC_REG = 0, + SRC_VTX, +}; + +enum LightID { + LIGHT0 = 0x001, + LIGHT1 = 0x002, + LIGHT2 = 0x004, + LIGHT3 = 0x008, + LIGHT4 = 0x010, + LIGHT5 = 0x020, + LIGHT6 = 0x040, + LIGHT7 = 0x080, + MAX_LIGHT = 0x100, + LIGHT_NULL = 0x000, +}; + +enum FogType { + FOG_NONE = 0x00, + FOG_PERSP_LIN = 0x02, + FOG_PERSP_EXP = 0x04, + FOG_PERSP_EXP2 = 0x05, + FOG_PERSP_REVEXP = 0x06, + FOG_PERSP_REVEXP2 = 0x07, + FOG_ORTHO_LIN = 0x0A, + FOG_ORTHO_EXP = 0x0C, + FOG_ORTHO_EXP2 = 0x0D, + FOG_ORTHO_REVEXP = 0x0E, + FOG_ORTHO_REVEXP2 = 0x0F, +}; + } // namespace GX diff --git a/Runtime/GuiSys/CAuiImagePane.cpp b/Runtime/GuiSys/CAuiImagePane.cpp index c56594a16..b5174b376 100644 --- a/Runtime/GuiSys/CAuiImagePane.cpp +++ b/Runtime/GuiSys/CAuiImagePane.cpp @@ -51,8 +51,8 @@ void CAuiImagePane::Update(float dt) { CGuiWidget::Update(dt); } -void CAuiImagePane::DoDrawImagePane(const zeus::CColor& color, const CTexture& tex, int frame, float alpha, bool noBlur, - EFilterType filter) const { +void CAuiImagePane::DoDrawImagePane(const zeus::CColor& color, CTexture& tex, int frame, float alpha, + bool noBlur) const { zeus::CColor useColor = color; useColor.a() *= alpha; @@ -75,26 +75,35 @@ void CAuiImagePane::DoDrawImagePane(const zeus::CColor& color, const CTexture& t useUVs = &x114_uvs; } - std::vector realUseUvs; - realUseUvs.reserve(4); - for (auto v : *useUVs) { - realUseUvs.push_back(v + xd0_uvBias0); - } - - bool zTest = xac_drawFlags == EGuiModelDrawFlags::Shadeless || xac_drawFlags == EGuiModelDrawFlags::Opaque; if (noBlur) { -// aurora::gfx::queue_textured_quad_verts(aurora::gfx::CameraFilterType(filter), tex.GetTexture(), -// aurora::gfx::ZComp::LEqual, zTest, useColor, xe0_coords, realUseUvs, 0); - // quad.drawVerts(useColor, verts); + CGraphics::SetTevOp(ERglTevStage::Stage0, CTevCombiners::sTevPass805a5fec); + CGraphics::SetTevOp(ERglTevStage::Stage1, CTevCombiners::skPassThru); + tex.Load(GX::TEXMAP0, EClampMode::Repeat); + CGraphics::StreamBegin(GX::TRIANGLESTRIP); + CGraphics::StreamColor(useColor); + for (u32 i = 0; i < 4; ++i) { + CGraphics::StreamTexcoord((*useUVs)[i]); + CGraphics::StreamVertex(vec[i]); + } + CGraphics::StreamEnd(); } else if ((x14c_deResFactor == 0.f && alpha == 1.f) || tex.GetNumberOfMipMaps() == 1) { -// aurora::gfx::queue_textured_quad_verts(aurora::gfx::CameraFilterType(filter), tex.GetTexture(), -// aurora::gfx::ZComp::LEqual, zTest, useColor, xe0_coords, realUseUvs, 0); + CGraphics::SetTevOp(ERglTevStage::Stage0, CTevCombiners::sTevPass805a5ebc); + CGraphics::SetTevOp(ERglTevStage::Stage1, CTevCombiners::skPassThru); + tex.LoadMipLevel(0.f, GX::TEXMAP0, EClampMode::Repeat); + CGraphics::StreamBegin(GX::TRIANGLESTRIP); + CGraphics::StreamColor(useColor); + for (u32 i = 0; i < 4; ++i) { + CGraphics::StreamTexcoord((*useUVs)[i] + xd0_uvBias0); + CGraphics::StreamVertex(vec[i]); + } + CGraphics::StreamEnd(); } else { const float tmp = (1.f - x14c_deResFactor) * alpha; const float tmp3 = 1.f - tmp * tmp * tmp; const float mip = tmp3 * static_cast(tex.GetNumberOfMipMaps() - 1); -// aurora::gfx::queue_textured_quad_verts(aurora::gfx::CameraFilterType(filter), tex.GetTexture(), -// aurora::gfx::ZComp::LEqual, zTest, useColor, xe0_coords, realUseUvs, mip); + // aurora::gfx::queue_textured_quad_verts(aurora::gfx::CameraFilterType(filter), tex.GetTexture(), + // aurora::gfx::ZComp::LEqual, zTest, useColor, xe0_coords, realUseUvs, + // mip); } } @@ -107,7 +116,9 @@ void CAuiImagePane::Draw(const CGuiWidgetDrawParms& params) { GetIsFinishedLoadingWidgetSpecific(); zeus::CColor color = xa8_color2; color.a() *= params.x0_alphaMod; - // SetZUpdate(xac_drawFlags == EGuiModelDrawFlags::Shadeless || xac_drawFlags == EGuiModelDrawFlags::Opaque); + CGraphics::SetDepthWriteMode(true, ERglEnum::LEqual, + xac_drawFlags == EGuiModelDrawFlags::Shadeless || + xac_drawFlags == EGuiModelDrawFlags::Opaque); float blur0 = 1.f; float blur1 = 0.f; const int frame0 = static_cast(x144_frameTimer); @@ -123,46 +134,62 @@ void CAuiImagePane::Draw(const CGuiWidgetDrawParms& params) { } // Alpha blend - DoDrawImagePane(color * zeus::CColor(0.f, 0.5f), *xb8_tex0Tok, frame0, 1.f, true, EFilterType::Blend); + CGraphics::SetBlendMode(ERglBlendMode::Blend, ERglBlendFactor::SrcAlpha, ERglBlendFactor::InvSrcAlpha, + ERglLogicOp::Clear); + DoDrawImagePane(color * zeus::CColor(0.f, 0.5f), *xb8_tex0Tok, frame0, 1.f, true); if (x150_flashFactor > 0.f) { // Additive blend zeus::CColor color2 = xa8_color2; color2.a() = x150_flashFactor; - DoDrawImagePane(color2, *xb8_tex0Tok, frame0, blur0, false, EFilterType::Blend); + CGraphics::SetBlendMode(ERglBlendMode::Blend, ERglBlendFactor::SrcAlpha, ERglBlendFactor::One, ERglLogicOp::Clear); + DoDrawImagePane(color2, *xb8_tex0Tok, frame0, blur0, false); if (blur1 > 0.f) - DoDrawImagePane(color2, *xb8_tex0Tok, frame1, blur1, false, EFilterType::Blend); + DoDrawImagePane(color2, *xb8_tex0Tok, frame1, blur1, false); } switch (xac_drawFlags) { case EGuiModelDrawFlags::Shadeless: case EGuiModelDrawFlags::Opaque: // Opaque blend - DoDrawImagePane(color, *xb8_tex0Tok, frame0, blur0, false, EFilterType::Blend); - if (blur1 > 0.f) - DoDrawImagePane(color, *xb8_tex0Tok, frame1, blur1, false, EFilterType::Blend); + CGraphics::SetBlendMode(ERglBlendMode::Blend, ERglBlendFactor::SrcAlpha, ERglBlendFactor::InvSrcAlpha, + ERglLogicOp::Clear); + DoDrawImagePane(color, *xb8_tex0Tok, frame0, blur0, false); + if (blur1 > 0.f) { + DoDrawImagePane(color, *xb8_tex0Tok, frame1, blur1, false); + } break; case EGuiModelDrawFlags::Alpha: // Alpha blend - DoDrawImagePane(color, *xb8_tex0Tok, frame0, blur0, false, EFilterType::Blend); - if (blur1 > 0.f) - DoDrawImagePane(color, *xb8_tex0Tok, frame1, blur1, false, EFilterType::Blend); + CGraphics::SetBlendMode(ERglBlendMode::Blend, ERglBlendFactor::SrcAlpha, ERglBlendFactor::InvSrcAlpha, + ERglLogicOp::Clear); + DoDrawImagePane(color, *xb8_tex0Tok, frame0, blur0, false); + if (blur1 > 0.f) { + DoDrawImagePane(color, *xb8_tex0Tok, frame1, blur1, false); + } break; case EGuiModelDrawFlags::Additive: // Additive blend - DoDrawImagePane(color, *xb8_tex0Tok, frame0, blur0, false, EFilterType::Add); - if (blur1 > 0.f) - DoDrawImagePane(color, *xb8_tex0Tok, frame1, blur1, false, EFilterType::Add); + CGraphics::SetBlendMode(ERglBlendMode::Blend, ERglBlendFactor::SrcAlpha, ERglBlendFactor::One, ERglLogicOp::Clear); + DoDrawImagePane(color, *xb8_tex0Tok, frame0, blur0, false); + if (blur1 > 0.f) { + DoDrawImagePane(color, *xb8_tex0Tok, frame1, blur1, false); + } break; case EGuiModelDrawFlags::AlphaAdditiveOverdraw: // Alpha blend - DoDrawImagePane(color, *xb8_tex0Tok, frame0, blur0, false, EFilterType::Blend); - if (blur1 > 0.f) - DoDrawImagePane(color, *xb8_tex0Tok, frame1, blur1, false, EFilterType::Blend); + CGraphics::SetBlendMode(ERglBlendMode::Blend, ERglBlendFactor::SrcAlpha, ERglBlendFactor::InvSrcAlpha, + ERglLogicOp::Clear); + DoDrawImagePane(color, *xb8_tex0Tok, frame0, blur0, false); + if (blur1 > 0.f) { + DoDrawImagePane(color, *xb8_tex0Tok, frame1, blur1, false); + } // Full additive blend - DoDrawImagePane(color, *xb8_tex0Tok, frame0, blur0, false, EFilterType::Add); - if (blur1 > 0.f) - DoDrawImagePane(color, *xb8_tex0Tok, frame1, blur1, false, EFilterType::Add); + CGraphics::SetBlendMode(ERglBlendMode::Blend, ERglBlendFactor::One, ERglBlendFactor::One, ERglLogicOp::Clear); + DoDrawImagePane(color, *xb8_tex0Tok, frame0, blur0, false); + if (blur1 > 0.f) { + DoDrawImagePane(color, *xb8_tex0Tok, frame1, blur1, false); + } break; default: break; diff --git a/Runtime/GuiSys/CAuiImagePane.hpp b/Runtime/GuiSys/CAuiImagePane.hpp index 0b884e538..55c499f3b 100644 --- a/Runtime/GuiSys/CAuiImagePane.hpp +++ b/Runtime/GuiSys/CAuiImagePane.hpp @@ -32,8 +32,7 @@ class CAuiImagePane : public CGuiWidget { float x148_fadeDuration = 0.f; float x14c_deResFactor = 0.f; float x150_flashFactor = 0.f; - void DoDrawImagePane(const zeus::CColor& color, const CTexture& tex, int frame, float blurAmt, bool noBlur, - EFilterType filter) const; + void DoDrawImagePane(const zeus::CColor& color, CTexture& tex, int frame, float blurAmt, bool noBlur) const; public: CAuiImagePane(const CGuiWidgetParms& parms, CSimplePool* sp, CAssetId, CAssetId, diff --git a/Runtime/GuiSys/CGuiPane.cpp b/Runtime/GuiSys/CGuiPane.cpp index 446d78002..7faf9c6c3 100644 --- a/Runtime/GuiSys/CGuiPane.cpp +++ b/Runtime/GuiSys/CGuiPane.cpp @@ -16,8 +16,13 @@ void CGuiPane::Draw(const CGuiWidgetDrawParms& parms) { auto col = xa8_color2; col.a() = parms.x0_alphaMod * xa8_color2.a(); +#if 0 + CGraphics::SetTevOp(ERglTevStage::Stage0, CTevCombiners::skPassThru); + CGraphics::DrawPrimitive(GX::Primitive::TRIANGLESTRIP, xc0_verts.data(), skDefaultNormal, col, xc0_verts.size()); +#else aurora::gfx::queue_colored_quad_verts(aurora::gfx::CameraFilterType::Blend, aurora::gfx::ZComp::Always, false, col, xc0_verts); +#endif } CGuiWidget::Draw(parms); } diff --git a/Runtime/GuiSys/CGuiPane.hpp b/Runtime/GuiSys/CGuiPane.hpp index 980baa1fe..c2ec2333e 100644 --- a/Runtime/GuiSys/CGuiPane.hpp +++ b/Runtime/GuiSys/CGuiPane.hpp @@ -11,6 +11,7 @@ namespace metaforce { class CGuiPane : public CGuiWidget { + static constexpr zeus::CVector3f skDefaultNormal{0.f, -1.f, 0.f}; protected: zeus::CVector2f xb8_dim; diff --git a/Runtime/Particle/CDecal.cpp b/Runtime/Particle/CDecal.cpp index 74e4acbf0..faa208a8a 100644 --- a/Runtime/Particle/CDecal.cpp +++ b/Runtime/Particle/CDecal.cpp @@ -18,38 +18,27 @@ CDecal::CDecal(const TToken& desc, const zeus::CTransform& xf CDecalDescription* d = x0_description.GetObj(); if (d->x38_DMDL) { - if (d->x48_DLFT) + if (d->x48_DLFT) { d->x48_DLFT->GetValue(0, x54_modelLifetime); - else + } else { x54_modelLifetime = 0x7FFFFF; + } - if (d->x50_DMRT) + if (d->x50_DMRT) { d->x50_DMRT->GetValue(0, x60_rotation); + } } else { x5c_29_modelInvalid = true; } - -// CGraphics::CommitResources([this](boo::IGraphicsDataFactory::Context& ctx) { -// for (auto& decal : x3c_decalQuads) { -// if (decal.m_desc->x14_TEX) { -// decal.m_instBuf = ctx.newDynamicBuffer(boo::BufferUse::Vertex, sizeof(SParticleInstanceTex), 1); -// } else { -// decal.m_instBuf = ctx.newDynamicBuffer(boo::BufferUse::Vertex, sizeof(SParticleInstanceNoTex), 1); -// } -// decal.m_uniformBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(SParticleUniforms), 1); -// CDecalShaders::BuildShaderDataBinding(ctx, decal); -// } -// return true; -// } BooTrace); } bool CDecal::InitQuad(CQuadDecal& quad, const SQuadDescr& desc) { - quad.m_desc = &desc; if (desc.x14_TEX) { - if (desc.x0_LFT) + if (desc.x0_LFT) { desc.x0_LFT->GetValue(0, quad.x4_lifetime); - else + } else { quad.x4_lifetime = 0x7FFFFF; + } if (desc.x8_ROT) { desc.x8_ROT->GetValue(0, quad.x8_rotation); quad.x0_24_invalid = desc.x8_ROT->IsConstant(); @@ -62,8 +51,9 @@ bool CDecal::InitQuad(CQuadDecal& quad, const SQuadDescr& desc) { quad.x0_24_invalid = size <= 1.f; } - if (desc.xc_OFF) + if (desc.xc_OFF) { quad.x0_24_invalid = desc.xc_OFF->IsFastConstant(); + } return false; } @@ -79,14 +69,16 @@ void CDecal::RenderQuad(CQuadDecal& decal, const SQuadDescr& desc) const { zeus::CColor color = zeus::skWhite; float size = 1.f; zeus::CVector3f offset; - if (CColorElement* clr = desc.x10_CLR.get()) + if (CColorElement* clr = desc.x10_CLR.get()) { clr->GetValue(x58_frameIdx, color); + } if (CRealElement* sze = desc.x4_SZE.get()) { sze->GetValue(x58_frameIdx, size); size *= 0.5f; } - if (CRealElement* rot = desc.x8_ROT.get()) + if (CRealElement* rot = desc.x8_ROT.get()) { rot->GetValue(x58_frameIdx, decal.x8_rotation); + } if (CVectorElement* off = desc.xc_OFF.get()) { off->GetValue(x58_frameIdx, offset); offset.y() = 0.f; @@ -235,8 +227,9 @@ void CDecal::RenderMdl() { void CDecal::Render() { SCOPED_GRAPHICS_DEBUG_GROUP("CDecal::Render", zeus::skYellow); CGlobalRandom gr(sDecalRandom); - if (x5c_29_modelInvalid && x5c_30_quad2Invalid && x5c_31_quad1Invalid) + if (x5c_29_modelInvalid && x5c_30_quad2Invalid && x5c_31_quad1Invalid) { return; + } CGraphics::DisableAllLights(); CParticleGlobals::instance()->SetEmitterTime(x58_frameIdx); diff --git a/Runtime/Particle/CDecal.hpp b/Runtime/Particle/CDecal.hpp index 3e32547d0..f1e0cdce2 100644 --- a/Runtime/Particle/CDecal.hpp +++ b/Runtime/Particle/CDecal.hpp @@ -16,14 +16,8 @@ struct CQuadDecal { bool x0_24_invalid : 1 = true; s32 x4_lifetime = 0; float x8_rotation = 0.f; - const SQuadDescr* m_desc = nullptr; CQuadDecal() = default; CQuadDecal(s32 i, float f) : x4_lifetime(i), x8_rotation(f) {} - -// boo::ObjToken m_instBuf; -// boo::ObjToken m_uniformBuf; -// boo::ObjToken m_normalDataBind; -// boo::ObjToken m_redToAlphaDataBind; }; class CDecal { diff --git a/aurora/include/aurora/gfx.hpp b/aurora/include/aurora/gfx.hpp index d359c9798..fc2b887b2 100644 --- a/aurora/include/aurora/gfx.hpp +++ b/aurora/include/aurora/gfx.hpp @@ -149,7 +149,7 @@ struct CTevOp { GX::TevOp x4_op = GX::TevOp::TEV_ADD; GX::TevBias x8_bias = GX::TevBias::TB_ZERO; GX::TevScale xc_scale = GX::TevScale::CS_SCALE_1; - GX::TevRegID xc_regId = GX::TevRegID::TEVPREV; + GX::TevRegID x10_regId = GX::TevRegID::TEVPREV; bool operator<=>(const CTevOp&) const = default; }; diff --git a/aurora/lib/gfx/stream.cpp b/aurora/lib/gfx/stream.cpp index 860f14fdd..06cbfcd0a 100644 --- a/aurora/lib/gfx/stream.cpp +++ b/aurora/lib/gfx/stream.cpp @@ -296,13 +296,13 @@ static ShaderRef generate_shader() { { std::string op; std::string outReg; - switch (stage->colorOp.xc_regId) { + switch (stage->colorOp.x10_regId) { case GX::TevRegID::TEVPREV: outReg = "prev"; break; default: Log.report(logvisor::Fatal, FMT_STRING("TODO: colorOp outReg {}"), - magic_enum::enum_name(stage->colorOp.xc_regId)); + magic_enum::enum_name(stage->colorOp.x10_regId)); } op = fmt::format(FMT_STRING("({3} {4} ((1.0 - {2}) * {0} + {2} * {1}){5}){6}"), color_arg_reg(stage->colorPass.x0_a, idx), color_arg_reg(stage->colorPass.x4_b, idx), @@ -314,13 +314,13 @@ static ShaderRef generate_shader() { { std::string op; std::string outReg; - switch (stage->alphaOp.xc_regId) { + switch (stage->alphaOp.x10_regId) { case GX::TevRegID::TEVPREV: outReg = "prev.a"; break; default: Log.report(logvisor::Fatal, FMT_STRING("TODO: alphaOp outReg {}"), - magic_enum::enum_name(stage->alphaOp.xc_regId)); + magic_enum::enum_name(stage->alphaOp.x10_regId)); } op = fmt::format(FMT_STRING("({3} {4} ((1.0 - {2}) * {0} + {2} * {1}){5}){6}"), alpha_arg_reg(stage->alphaPass.x0_a, idx), alpha_arg_reg(stage->alphaPass.x4_b, idx),