|
|
|
|
@ -55,7 +55,7 @@ void CCubeMaterial::SetCurrent(const CModelFlags& flags, const CCubeSurface& sur |
|
|
|
|
materialDataCur += 8; |
|
|
|
|
for (u32 i = 0; i < texCount; ++i) { |
|
|
|
|
u32 texIdx = SBig(*reinterpret_cast<const u32*>(materialDataCur)); |
|
|
|
|
model.GetTexture(texIdx)->Load(static_cast<GX::TexMapID>(i), EClampMode::Repeat); |
|
|
|
|
model.GetTexture(texIdx)->Load(static_cast<GXTexMapID>(i), EClampMode::Repeat); |
|
|
|
|
materialDataCur += 4; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
@ -83,14 +83,14 @@ void CCubeMaterial::SetCurrent(const CModelFlags& flags, const CCubeSurface& sur |
|
|
|
|
for (u32 i = 0; i < konstCount; ++i) { |
|
|
|
|
u32 kColor = SBig(*reinterpret_cast<const u32*>(materialDataCur)); |
|
|
|
|
materialDataCur += 4; |
|
|
|
|
CGX::SetTevKColor(static_cast<GX::TevKColorID>(i), kColor); |
|
|
|
|
CGX::SetTevKColor(static_cast<GXTevKColorID>(i), kColor); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
u32 blendFactors = SBig(*reinterpret_cast<const u32*>(materialDataCur)); |
|
|
|
|
materialDataCur += 4; |
|
|
|
|
if (g_Renderer->IsInAreaDraw()) { |
|
|
|
|
CGX::SetBlendMode(GX::BM_BLEND, GX::BL_ONE, GX::BL_ONE, GX::LO_CLEAR); |
|
|
|
|
CGX::SetBlendMode(GX_BM_BLEND, GX_BL_ONE, GX_BL_ONE, GX_LO_CLEAR); |
|
|
|
|
} else { |
|
|
|
|
SetupBlendMode(blendFactors, flags, matFlags.IsSet(CCubeMaterialFlagBits::fAlphaTest)); |
|
|
|
|
} |
|
|
|
|
@ -129,12 +129,12 @@ void CCubeMaterial::SetCurrent(const CModelFlags& flags, const CCubeSurface& sur |
|
|
|
|
finalTevCount = firstTev + 1; |
|
|
|
|
u32 ccFlags = SBig(*reinterpret_cast<const u32*>(materialDataCur + 8)); |
|
|
|
|
finalCCFlags = ccFlags; |
|
|
|
|
auto outputReg = static_cast<GX::TevRegID>(ccFlags >> 9 & 0x3); |
|
|
|
|
if (outputReg == GX::TEVREG0) { |
|
|
|
|
auto outputReg = static_cast<GXTevRegID>(ccFlags >> 9 & 0x3); |
|
|
|
|
if (outputReg == GX_TEVREG0) { |
|
|
|
|
materialDataCur += 20; |
|
|
|
|
texMapTexCoordFlags += 1; |
|
|
|
|
finalCCFlags = SBig(*reinterpret_cast<const u32*>(materialDataCur + 8)); |
|
|
|
|
GXSetTevColor(GX::TEVREG0, 0xc0c0c0c0); |
|
|
|
|
GXSetTevColor(GX_TEVREG0, GXColor{0xc0, 0xc0, 0xc0, 0xc0}); |
|
|
|
|
} |
|
|
|
|
finalACFlags = SBig(*reinterpret_cast<const u32*>(materialDataCur + 12)); |
|
|
|
|
HandleTev(firstTev, reinterpret_cast<const u32*>(materialDataCur), texMapTexCoordFlags, |
|
|
|
|
@ -148,8 +148,8 @@ void CCubeMaterial::SetCurrent(const CModelFlags& flags, const CCubeSurface& sur |
|
|
|
|
u32 ccFlags = SBig(*reinterpret_cast<const u32*>(materialDataCur + 8)); |
|
|
|
|
finalCCFlags = ccFlags; |
|
|
|
|
finalACFlags = SBig(*reinterpret_cast<const u32*>(materialDataCur + 12)); |
|
|
|
|
auto outputReg = static_cast<GX::TevRegID>(ccFlags >> 9 & 0x3); |
|
|
|
|
if (outputReg == GX::TEVREG2) { |
|
|
|
|
auto outputReg = static_cast<GXTevRegID>(ccFlags >> 9 & 0x3); |
|
|
|
|
if (outputReg == GX_TEVREG2) { |
|
|
|
|
usesTevReg2 = true; |
|
|
|
|
} |
|
|
|
|
materialDataCur += 20; |
|
|
|
|
@ -162,13 +162,13 @@ void CCubeMaterial::SetCurrent(const CModelFlags& flags, const CCubeSurface& sur |
|
|
|
|
u32 fullTcgCount = SBig(*tcgs); |
|
|
|
|
tcgCount = std::min(fullTcgCount, 2u); |
|
|
|
|
for (u32 i = 0; i < tcgCount; ++i) { |
|
|
|
|
CGX::SetTexCoordGen(GX::TexCoordID(i), SBig(tcgs[i + 1])); |
|
|
|
|
CGX::SetTexCoordGen(GXTexCoordID(i), SBig(tcgs[i + 1])); |
|
|
|
|
} |
|
|
|
|
tcgs += fullTcgCount + 1; |
|
|
|
|
} else { |
|
|
|
|
tcgCount = SBig(*tcgs); |
|
|
|
|
for (u32 i = 0; i < tcgCount; ++i) { |
|
|
|
|
CGX::SetTexCoordGen(GX::TexCoordID(i), SBig(tcgs[i + 1])); |
|
|
|
|
CGX::SetTexCoordGen(GXTexCoordID(i), SBig(tcgs[i + 1])); |
|
|
|
|
} |
|
|
|
|
tcgs += tcgCount + 1; |
|
|
|
|
} |
|
|
|
|
@ -176,10 +176,10 @@ void CCubeMaterial::SetCurrent(const CModelFlags& flags, const CCubeSurface& sur |
|
|
|
|
const u32* uvAnim = tcgs; |
|
|
|
|
u32 animCount = SBig(uvAnim[1]); |
|
|
|
|
uvAnim += 2; |
|
|
|
|
u32 texMtx = GX::TEXMTX0; |
|
|
|
|
u32 pttTexMtx = GX::PTTEXMTX0; |
|
|
|
|
u32 texMtx = GX_TEXMTX0; |
|
|
|
|
u32 pttTexMtx = GX_PTTEXMTX0; |
|
|
|
|
for (u32 i = 0; i < animCount; ++i) { |
|
|
|
|
u32 size = HandleAnimatedUV(uvAnim, static_cast<GX::TexMtx>(texMtx), static_cast<GX::PTTexMtx>(pttTexMtx)); |
|
|
|
|
u32 size = HandleAnimatedUV(uvAnim, static_cast<GXTexMtx>(texMtx), static_cast<GXPTTexMtx>(pttTexMtx)); |
|
|
|
|
if (size == 0) |
|
|
|
|
break; |
|
|
|
|
uvAnim += size; |
|
|
|
|
@ -228,17 +228,17 @@ void CCubeMaterial::SetCurrentBlack() { |
|
|
|
|
const auto flags = GetFlags(); |
|
|
|
|
const auto vatFlags = GetVatFlags(); |
|
|
|
|
if (flags.IsSet(CCubeMaterialFlagBits::fDepthSorting) || flags.IsSet(CCubeMaterialFlagBits::fAlphaTest)) { |
|
|
|
|
CGX::SetBlendMode(GX::BM_BLEND, GX::BL_ZERO, GX::BL_ONE, GX::LO_CLEAR); |
|
|
|
|
CGX::SetBlendMode(GX_BM_BLEND, GX_BL_ZERO, GX_BL_ONE, GX_LO_CLEAR); |
|
|
|
|
} else { |
|
|
|
|
CGX::SetBlendMode(GX::BM_BLEND, GX::BL_ONE, GX::BL_ZERO, GX::LO_CLEAR); |
|
|
|
|
CGX::SetBlendMode(GX_BM_BLEND, GX_BL_ONE, GX_BL_ZERO, GX_LO_CLEAR); |
|
|
|
|
} |
|
|
|
|
CGX::SetVtxDescv_Compressed(vatFlags); |
|
|
|
|
CGX::SetTevColorIn(GX::TEVSTAGE0, GX::CC_ZERO, GX::CC_ZERO, GX::CC_ZERO, GX::CC_ZERO /* ? CC_ONE */); |
|
|
|
|
CGX::SetTevAlphaIn(GX::TEVSTAGE0, GX::CA_ZERO, GX::CA_ZERO, GX::CA_ZERO, GX::CA_ZERO /* ? CA_KONST */); |
|
|
|
|
CGX::SetTevKAlphaSel(GX::TEVSTAGE0, GX::TEV_KASEL_1); |
|
|
|
|
CGX::SetTexCoordGen(GX::TEXCOORD0, GX::TG_MTX2x4, GX::TG_POS, GX::IDENTITY, false, GX::PTIDENTITY); |
|
|
|
|
CGX::SetStandardTevColorAlphaOp(GX::TEVSTAGE0); |
|
|
|
|
CGX::SetTevOrder(GX::TEVSTAGE0, GX::TEXCOORD_NULL, GX::TEXMAP_NULL, GX::COLOR_NULL); |
|
|
|
|
CGX::SetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO /* ? CC_ONE */); |
|
|
|
|
CGX::SetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO /* ? CA_KONST */); |
|
|
|
|
CGX::SetTevKAlphaSel(GX_TEVSTAGE0, GX_TEV_KASEL_1); |
|
|
|
|
CGX::SetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_POS, GX_IDENTITY, false, GX_PTIDENTITY); |
|
|
|
|
CGX::SetStandardTevColorAlphaOp(GX_TEVSTAGE0); |
|
|
|
|
CGX::SetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR_NULL); |
|
|
|
|
CGX::SetNumTevStages(1); |
|
|
|
|
CGX::SetNumChans(0); |
|
|
|
|
CGX::SetNumTexGens(1); |
|
|
|
|
@ -246,35 +246,35 @@ void CCubeMaterial::SetCurrentBlack() { |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void CCubeMaterial::SetupBlendMode(u32 blendFactors, const CModelFlags& flags, bool alphaTest) { |
|
|
|
|
auto newSrcFactor = static_cast<GX::BlendFactor>(blendFactors & 0xffff); |
|
|
|
|
auto newDstFactor = static_cast<GX::BlendFactor>(blendFactors >> 16 & 0xffff); |
|
|
|
|
auto newSrcFactor = static_cast<GXBlendFactor>(blendFactors & 0xffff); |
|
|
|
|
auto newDstFactor = static_cast<GXBlendFactor>(blendFactors >> 16 & 0xffff); |
|
|
|
|
if (alphaTest) { |
|
|
|
|
// discard fragments with alpha < 0.25
|
|
|
|
|
CGX::SetAlphaCompare(GX::GEQUAL, 64, GX::AOP_OR, GX::NEVER, 0); |
|
|
|
|
newSrcFactor = GX::BL_ONE; |
|
|
|
|
newDstFactor = GX::BL_ZERO; |
|
|
|
|
CGX::SetAlphaCompare(GX_GEQUAL, 64, GX_AOP_OR, GX_NEVER, 0); |
|
|
|
|
newSrcFactor = GX_BL_ONE; |
|
|
|
|
newDstFactor = GX_BL_ZERO; |
|
|
|
|
} else { |
|
|
|
|
CGX::SetAlphaCompare(GX::ALWAYS, 0, GX::AOP_OR, GX::ALWAYS, 0); |
|
|
|
|
CGX::SetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (flags.x0_blendMode > 4 && newSrcFactor == GX::BL_ONE) { |
|
|
|
|
newSrcFactor = GX::BL_SRCALPHA; |
|
|
|
|
if (newDstFactor == GX::BL_ZERO) { |
|
|
|
|
newDstFactor = flags.x0_blendMode > 6 ? GX::BL_ONE : GX::BL_INVSRCALPHA; |
|
|
|
|
if (flags.x0_blendMode > 4 && newSrcFactor == GX_BL_ONE) { |
|
|
|
|
newSrcFactor = GX_BL_SRCALPHA; |
|
|
|
|
if (newDstFactor == GX_BL_ZERO) { |
|
|
|
|
newDstFactor = flags.x0_blendMode > 6 ? GX_BL_ONE : GX_BL_INVSRCALPHA; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
CGX::SetBlendMode(GX::BM_BLEND, newSrcFactor, newDstFactor, GX::LO_CLEAR); |
|
|
|
|
CGX::SetBlendMode(GX_BM_BLEND, newSrcFactor, newDstFactor, GX_LO_CLEAR); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
void CCubeMaterial::HandleDepth(CModelFlagsFlags modelFlags, CCubeMaterialFlags matFlags) { |
|
|
|
|
GX::Compare func = GX::NEVER; |
|
|
|
|
GXCompare func = GX_NEVER; |
|
|
|
|
if (!(modelFlags & CModelFlagBits::DepthTest)) { |
|
|
|
|
func = GX::ALWAYS; |
|
|
|
|
func = GX_ALWAYS; |
|
|
|
|
} else if (modelFlags & CModelFlagBits::DepthGreater) { |
|
|
|
|
func = modelFlags & CModelFlagBits::DepthNonInclusive ? GX::GREATER : GX::GEQUAL; |
|
|
|
|
func = modelFlags & CModelFlagBits::DepthNonInclusive ? GX_GREATER : GX_GEQUAL; |
|
|
|
|
} else { |
|
|
|
|
func = modelFlags & CModelFlagBits::DepthNonInclusive ? GX::LESS : GX::LEQUAL; |
|
|
|
|
func = modelFlags & CModelFlagBits::DepthNonInclusive ? GX_LESS : GX_LEQUAL; |
|
|
|
|
} |
|
|
|
|
bool depthWrite = modelFlags & CModelFlagBits::DepthUpdate && matFlags & CCubeMaterialFlagBits::fDepthWrite; |
|
|
|
|
CGX::SetZMode(true, func, depthWrite); |
|
|
|
|
@ -309,14 +309,14 @@ void CCubeMaterial::EnsureViewDepStateCached(const CCubeSurface* surface) { |
|
|
|
|
u32 CCubeMaterial::HandleColorChannels(u32 chanCount, u32 firstChan) { |
|
|
|
|
if (CCubeModel::sRenderModelShadow) { |
|
|
|
|
if (chanCount != 0) { |
|
|
|
|
CGX::SetChanAmbColor(CGX::EChannelId::Channel1, zeus::skBlack); |
|
|
|
|
CGX::SetChanMatColor(CGX::EChannelId::Channel1, zeus::skWhite); |
|
|
|
|
CGX::SetChanAmbColor(CGX::EChannelId::Channel1, GX_BLACK); |
|
|
|
|
CGX::SetChanMatColor(CGX::EChannelId::Channel1, GX_WHITE); |
|
|
|
|
|
|
|
|
|
auto chan0Lights = CGraphics::g_LightActive & ~CCubeModel::sChannel0DisableLightMask; |
|
|
|
|
CGX::SetChanCtrl(CGX::EChannelId::Channel0, firstChan, chan0Lights); |
|
|
|
|
CGX::SetChanCtrl(CGX::EChannelId::Channel1, CCubeModel::sChannel1EnableLightMask); |
|
|
|
|
if (chan0Lights.any()) { |
|
|
|
|
CGX::SetChanMatColor(CGX::EChannelId::Channel0, zeus::skWhite); |
|
|
|
|
CGX::SetChanMatColor(CGX::EChannelId::Channel0, GX_WHITE); |
|
|
|
|
} else { |
|
|
|
|
CGX::SetChanMatColor(CGX::EChannelId::Channel0, CGX::GetChanAmbColor(CGX::EChannelId::Channel0)); |
|
|
|
|
} |
|
|
|
|
@ -325,8 +325,8 @@ u32 CCubeMaterial::HandleColorChannels(u32 chanCount, u32 firstChan) { |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
if (chanCount == 2) { |
|
|
|
|
CGX::SetChanAmbColor(CGX::EChannelId::Channel1, zeus::skBlack); |
|
|
|
|
CGX::SetChanMatColor(CGX::EChannelId::Channel1, zeus::skWhite); |
|
|
|
|
CGX::SetChanAmbColor(CGX::EChannelId::Channel1, GX_BLACK); |
|
|
|
|
CGX::SetChanMatColor(CGX::EChannelId::Channel1, GX_WHITE); |
|
|
|
|
} else { |
|
|
|
|
CGX::SetChanCtrl(CGX::EChannelId::Channel1, {}); |
|
|
|
|
} |
|
|
|
|
@ -336,7 +336,7 @@ u32 CCubeMaterial::HandleColorChannels(u32 chanCount, u32 firstChan) { |
|
|
|
|
} else { |
|
|
|
|
CGX::SetChanCtrl(CGX::EChannelId::Channel0, firstChan, CGraphics::g_LightActive); |
|
|
|
|
if (CGraphics::g_LightActive.any()) { |
|
|
|
|
CGX::SetChanMatColor(CGX::EChannelId::Channel0, zeus::skWhite); |
|
|
|
|
CGX::SetChanMatColor(CGX::EChannelId::Channel0, GX_WHITE); |
|
|
|
|
} else { |
|
|
|
|
CGX::SetChanMatColor(CGX::EChannelId::Channel0, CGX::GetChanAmbColor(CGX::EChannelId::Channel0)); |
|
|
|
|
} |
|
|
|
|
@ -352,15 +352,15 @@ void CCubeMaterial::HandleTev(u32 tevCur, const u32* materialDataCur, const u32* |
|
|
|
|
const u32 colorOps = SBig(materialDataCur[2]); |
|
|
|
|
const u32 alphaOps = SBig(materialDataCur[3]); |
|
|
|
|
|
|
|
|
|
const auto stage = static_cast<GX::TevStageID>(tevCur); |
|
|
|
|
const auto stage = static_cast<GXTevStageID>(tevCur); |
|
|
|
|
CGX::SetStandardDirectTev_Compressed(stage, colorArgs, alphaArgs, colorOps, alphaOps); |
|
|
|
|
|
|
|
|
|
u32 tmtcFlags = SBig(*texMapTexCoordFlags); |
|
|
|
|
u32 matFlags = SBig(materialDataCur[4]); |
|
|
|
|
CGX::SetTevOrder(stage, static_cast<GX::TexCoordID>(tmtcFlags & 0xFF), |
|
|
|
|
static_cast<GX::TexMapID>(tmtcFlags >> 8 & 0xFF), static_cast<GX::ChannelID>(matFlags & 0xFF)); |
|
|
|
|
CGX::SetTevKColorSel(stage, static_cast<GX::TevKColorSel>(matFlags >> 0x8 & 0xFF)); |
|
|
|
|
CGX::SetTevKAlphaSel(stage, static_cast<GX::TevKAlphaSel>(matFlags >> 0x10 & 0xFF)); |
|
|
|
|
CGX::SetTevOrder(stage, static_cast<GXTexCoordID>(tmtcFlags & 0xFF), static_cast<GXTexMapID>(tmtcFlags >> 8 & 0xFF), |
|
|
|
|
static_cast<GXChannelID>(matFlags & 0xFF)); |
|
|
|
|
CGX::SetTevKColorSel(stage, static_cast<GXTevKColorSel>(matFlags >> 0x8 & 0xFF)); |
|
|
|
|
CGX::SetTevKAlphaSel(stage, static_cast<GXTevKAlphaSel>(matFlags >> 0x10 & 0xFF)); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
constexpr zeus::CTransform MvPostXf{ |
|
|
|
|
@ -368,21 +368,21 @@ constexpr zeus::CTransform MvPostXf{ |
|
|
|
|
{0.5f, 0.5f, 1.f}, |
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
u32 CCubeMaterial::HandleAnimatedUV(const u32* uvAnim, GX::TexMtx texMtx, GX::PTTexMtx pttTexMtx) { |
|
|
|
|
u32 CCubeMaterial::HandleAnimatedUV(const u32* uvAnim, GXTexMtx texMtx, GXPTTexMtx pttTexMtx) { |
|
|
|
|
u32 type = SBig(*uvAnim); |
|
|
|
|
const float* params = reinterpret_cast<const float*>(uvAnim + 1); |
|
|
|
|
switch (type) { |
|
|
|
|
case 0: { |
|
|
|
|
auto xf = CGraphics::g_ViewMatrix.inverse().multiplyIgnoreTranslation(CGraphics::g_GXModelMatrix); |
|
|
|
|
xf.origin.zeroOut(); |
|
|
|
|
GXLoadTexMtxImm(&xf, texMtx, GX::MTX3x4); |
|
|
|
|
GXLoadTexMtxImm(&MvPostXf, pttTexMtx, GX::MTX3x4); |
|
|
|
|
GXLoadTexMtxImm(&xf, texMtx, GX_MTX3x4); |
|
|
|
|
GXLoadTexMtxImm(&MvPostXf, pttTexMtx, GX_MTX3x4); |
|
|
|
|
return 1; |
|
|
|
|
} |
|
|
|
|
case 1: { |
|
|
|
|
auto xf = CGraphics::g_ViewMatrix.inverse() * CGraphics::g_GXModelMatrix; |
|
|
|
|
GXLoadTexMtxImm(&xf, texMtx, GX::MTX3x4); |
|
|
|
|
GXLoadTexMtxImm(&MvPostXf, pttTexMtx, GX::MTX3x4); |
|
|
|
|
GXLoadTexMtxImm(&xf, texMtx, GX_MTX3x4); |
|
|
|
|
GXLoadTexMtxImm(&MvPostXf, pttTexMtx, GX_MTX3x4); |
|
|
|
|
return 1; |
|
|
|
|
} |
|
|
|
|
case 2: { |
|
|
|
|
@ -392,7 +392,7 @@ u32 CCubeMaterial::HandleAnimatedUV(const u32* uvAnim, GX::TexMtx texMtx, GX::PT |
|
|
|
|
const float f4 = SBig(params[3]); |
|
|
|
|
const float seconds = CGraphics::GetSecondsMod900(); |
|
|
|
|
const auto xf = zeus::CTransform::Translate(seconds * f3 + f1, seconds * f4 + f2, 0.f); |
|
|
|
|
GXLoadTexMtxImm(&xf, texMtx, GX::MTX3x4); |
|
|
|
|
GXLoadTexMtxImm(&xf, texMtx, GX_MTX3x4); |
|
|
|
|
return 5; |
|
|
|
|
} |
|
|
|
|
case 3: { |
|
|
|
|
@ -406,7 +406,7 @@ u32 CCubeMaterial::HandleAnimatedUV(const u32* uvAnim, GX::TexMtx texMtx, GX::PT |
|
|
|
|
xf.basis[1][1] = acos; |
|
|
|
|
xf.origin[0] = (1.f - (acos - asin)) * 0.5f; |
|
