mirror/ss
1
0
Fork 0
mirror of https://github.com/zeldaret/ss synced 2026-06-25 01:32:01 -04:00
Code Issues Packages Projects Releases Wiki Activity

StateGX OK

Browse Source
This commit is contained in:
robojumper
2025-03-21 20:38:00 +01:00
parent 4c9213be54
commit b6505d23ad
11 changed files with 429 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files
config/SOUE01/splits.txt
+4
View File
@@ -2335,6 +2335,10 @@ egg/gfx/eggStateEfb.cpp:
egg/gfx/eggStateGX.cpp:
.text start:0x804B4610 end:0x804B53EC
.rodata start:0x804FBDA0 end:0x804FBE08
.sbss start:0x805768A0 end:0x805768B8
.sdata2 start:0x8057F890 end:0x8057F8B0
.bss start:0x806750A0 end:0x80675190
egg/gfx/eggTextureBuffer.cpp:
.text start:0x804B53F0 end:0x804B59DC
config/SOUE01/symbols.txt
+23 -23
View File
@@ -22396,15 +22396,15 @@ GXInitFogAdjTable = .text:0x803C0CA0; // type:function size:0x160
GXSetFogRangeAdj = .text:0x803C0E00; // type:function size:0x110
GXSetBlendMode = .text:0x803C0F10; // type:function size:0x50
GXSetColorUpdate = .text:0x803C0F60; // type:function size:0x2C
FUN_803c0f90 = .text:0x803C0F90; // type:function size:0x14
GXGetColorUpdate = .text:0x803C0F90; // type:function size:0x14
GXSetAlphaUpdate = .text:0x803C0FB0; // type:function size:0x2C
FUN_803c0fe0 = .text:0x803C0FE0; // type:function size:0x14
GXGetAlphaUpdate = .text:0x803C0FE0; // type:function size:0x14
GXSetZMode = .text:0x803C1000; // type:function size:0x34
GXSetZCompLoc = .text:0x803C1040; // type:function size:0x30
GXSetPixelFmt = .text:0x803C1070; // type:function size:0xA8
FUN_803c1120 = .text:0x803C1120; // type:function size:0x20
GXGetPixelFmt = .text:0x803C1120; // type:function size:0x20
GXSetDither = .text:0x803C1140; // type:function size:0x2C
FUN_803c1170 = .text:0x803C1170; // type:function size:0x14
GXGetDither = .text:0x803C1170; // type:function size:0x14
GXSetDstAlpha = .text:0x803C1190; // type:function size:0x30
GXSetFieldMask = .text:0x803C11C0; // type:function size:0x34
GXSetFieldMode = .text:0x803C1200; // type:function size:0x70
@@ -26764,10 +26764,10 @@ FUN_804b4310 = .text:0x804B4310; // type:function size:0x23C
FUN_804b4550 = .text:0x804B4550; // type:function size:0xA0
FUN_804b45f0 = .text:0x804B45F0; // type:function size:0xC
FUN_804b4600 = .text:0x804B4600; // type:function size:0xC
FUN_804b4610 = .text:0x804B4610; // type:function size:0x28
texRegionCallback__24@unnamed@eggStateGX_cpp@FPC9_GXTexObj11_GXTexMapID = .text:0x804B4610; // type:function size:0x28
initialize__Q23EGG7StateGXFUsUs8_GXColor11_GXPixelFmt = .text:0x804B4640; // type:function size:0x114
frameInit__Q23EGG7StateGXFv = .text:0x804B4760; // type:function size:0xA8
FUN_804b4810 = .text:0x804B4810; // type:function size:0x160
setTMemLayout__Q23EGG7StateGXFi = .text:0x804B4810; // type:function size:0x160
resetGX__Q23EGG7StateGXFv = .text:0x804B4970; // type:function size:0x48
resetVtx__Q23EGG7StateGXFv = .text:0x804B49C0; // type:function size:0x13C
resetColorChannel__Q23EGG7StateGXFv = .text:0x804B4B00; // type:function size:0xB8
@@ -26777,15 +26777,15 @@ resetTexGen__Q23EGG7StateGXFv = .text:0x804B4CB0; // type:function size:0xB8
resetTev__Q23EGG7StateGXFv = .text:0x804B4D70; // type:function size:0x17C
resetPE__Q23EGG7StateGXFv = .text:0x804B4EF0; // type:function size:0xB0
resetGXCache__Q23EGG7StateGXFv = .text:0x804B4FA0; // type:function size:0x40
EGG__StateGX__GXSetPixelFmt_ = .text:0x804B4FE0; // type:function size:0xAC
GXSetPixelFmt___Q23EGG7StateGXF11_GXPixelFmt9_GXZFmt16 = .text:0x804B4FE0; // type:function size:0xAC
invalidateTexAllGX__Q23EGG7StateGXFv = .text:0x804B5090; // type:function size:0x4
GXSetColorUpdate___Q23EGG7StateGXFb = .text:0x804B50A0; // type:function size:0x4C
GXSetAlphaUpdate___Q23EGG7StateGXFb = .text:0x804B50F0; // type:function size:0x4C
GXSetDither___Q23EGG7StateGXFb = .text:0x804B5140; // type:function size:0x4C
GXCopyTex__Q23EGG7StateGXFPvb = .text:0x804B5190; // type:function size:0x8
GXCopyTex___Q23EGG7StateGXFPvb = .text:0x804B5190; // type:function size:0x8
GXSetDstAlpha___Q23EGG7StateGXFbUc = .text:0x804B51A0; // type:function size:0x4C
FUN_804b51f0 = .text:0x804B51F0; // type:function size:0x108
FUN_804b5300 = .text:0x804B5300; // type:function size:0x2C
CalculateScreenScissor__Q23EGG7StateGXFPCfPUl = .text:0x804B51F0; // type:function size:0x108
GXSetProjection___Q23EGG7StateGXFPA4_f17_GXProjectionType = .text:0x804B5300; // type:function size:0x2C
GXSetProjectionv___Q23EGG7StateGXFPCf = .text:0x804B5330; // type:function size:0x2C
GXSetViewport___Q23EGG7StateGXFffffff = .text:0x804B5360; // type:function size:0x2C
GXSetScissor___Q23EGG7StateGXFUlUlUlUl = .text:0x804B5390; // type:function size:0x2C
@@ -29176,10 +29176,10 @@ lbl_804FBD50 = .rodata:0x804FBD50; // type:object size:0x10 data:float
lbl_804FBD60 = .rodata:0x804FBD60; // type:object size:0x10 data:float
lbl_804FBD70 = .rodata:0x804FBD70; // type:object size:0x18
lbl_804FBD88 = .rodata:0x804FBD88; // type:object size:0x18 data:4byte
lbl_804FBDA0 = .rodata:0x804FBDA0; // type:object size:0x30
lbl_804FBDD0 = .rodata:0x804FBDD0; // type:object size:0x10
lbl_804FBDE0 = .rodata:0x804FBDE0; // type:object size:0x10
lbl_804FBDF0 = .rodata:0x804FBDF0; // type:object size:0x18
identity__24@unnamed@eggStateGX_cpp@ = .rodata:0x804FBDA0; // type:object size:0x30
@LOCAL@setTMemLayout__Q23EGG7StateGXFi@numbers = .rodata:0x804FBDD0; // type:object size:0x10
@LOCAL@setTMemLayout__Q23EGG7StateGXFi@offsets@0 = .rodata:0x804FBDE0; // type:object size:0x10
@LOCAL@resetIndirect__Q23EGG7StateGXFv@ind = .rodata:0x804FBDF0; // type:object size:0x18
lbl_804FBE08 = .rodata:0x804FBE08; // type:object size:0x10 data:4byte
lbl_804FBE18 = .rodata:0x804FBE18; // type:object size:0x40
lbl_804FBE58 = .rodata:0x804FBE58; // type:object size:0xC
@@ -41182,11 +41182,11 @@ sCanvasOffset__Q23EGG6Screen = .sbss:0x80576888; // type:object size:0x8 data:fl
lbl_80576898 = .sbss:0x80576898; // type:object size:0x8 data:4byte
s_widthEfb__Q23EGG7StateGX = .sbss:0x805768A0; // type:object size:0x2 data:2byte
s_heightEfb__Q23EGG7StateGX = .sbss:0x805768A2; // type:object size:0x2 data:2byte
lbl_805768A4 = .sbss:0x805768A4; // type:object size:0x4 data:4byte
lbl_805768A8 = .sbss:0x805768A8; // type:object size:0x4 data:4byte
sDefaultTexColor__Q23EGG7StateGX = .sbss:0x805768AC; // type:object size:0x1 data:byte
s_pixFormat__Q23EGG7StateGX = .sbss:0x805768A4; // type:object size:0x4 data:4byte
s_zFmt16__Q23EGG7StateGX = .sbss:0x805768A8; // type:object size:0x4 data:4byte
s_clearEfb__Q23EGG7StateGX = .sbss:0x805768AC; // type:object size:0x4 data:byte
s_flag__Q23EGG7StateGX = .sbss:0x805768B0; // type:object size:0x2 data:2byte
s_commandFlag__Q23EGG7StateGX = .sbss:0x805768B2; // type:object size:0x6 data:2byte
s_commandFlag__Q23EGG7StateGX = .sbss:0x805768B2; // type:object size:0x2 data:2byte
spHead__Q23EGG13TextureBuffer = .sbss:0x805768B8; // type:object size:0x4 data:4byte
spTailNotJoin__Q23EGG13TextureBuffer = .sbss:0x805768BC; // type:object size:0x4 data:4byte
spBufferAll__Q23EGG13TextureBuffer = .sbss:0x805768C0; // type:object size:0x4 data:4byte
@@ -48203,7 +48203,7 @@ lbl_8057F874 = .sdata2:0x8057F874; // type:object size:0x4 data:float
lbl_8057F878 = .sdata2:0x8057F878; // type:object size:0x4 data:float
lbl_8057F880 = .sdata2:0x8057F880; // type:object size:0x8 data:double
lbl_8057F888 = .sdata2:0x8057F888; // type:object size:0x4 data:float
lbl_8057F890 = .sdata2:0x8057F890; // type:object size:0x4 data:4byte
white__24@unnamed@eggStateGX_cpp@ = .sdata2:0x8057F890; // type:object size:0x4 data:4byte
lbl_8057F894 = .sdata2:0x8057F894; // type:object size:0x4 data:float
lbl_8057F898 = .sdata2:0x8057F898; // type:object size:0x4 data:float
lbl_8057F89C = .sdata2:0x8057F89C; // type:object size:0x4 data:float
@@ -49810,10 +49810,10 @@ lbl_80675010 = .bss:0x80675010; // type:object size:0x30
lbl_80675040 = .bss:0x80675040; // type:object size:0x18 data:float
lbl_80675058 = .bss:0x80675058; // type:object size:0x18 data:float
lbl_80675070 = .bss:0x80675070; // type:object size:0x30 data:float
lbl_806750A0 = .bss:0x806750A0; // type:object size:0x20
lbl_806750C0 = .bss:0x806750C0; // type:object size:0xA8 data:4byte
lbl_80675168 = .bss:0x80675168; // type:object size:0x18
lbl_80675180 = .bss:0x80675180; // type:object size:0x10
sDefaultTexObj__Q23EGG7StateGX = .bss:0x806750A0; // type:object size:0x20
s_tmem_layout__Q23EGG7StateGX = .bss:0x806750C0; // type:object size:0xA8 data:4byte
s_cacheGX__Q23EGG7StateGX = .bss:0x80675168; // type:object size:0x18
@LOCAL@initialize__Q23EGG7StateGXFUsUs8_GXColor11_GXPixelFmt@sDefaultTexObjData = .bss:0x80675180; // type:object size:0x10
spBufferTable__Q23EGG13TextureBuffer = .bss:0x80675190; // type:object size:0x200 data:4byte
sTasks__Q23EGG18AudioRmtSpeakerMgr = .bss:0x80675390; // type:object size:0xF0
sMoveParamMgr__Q23EGG12AudioUtility = .bss:0x80675480; // type:object size:0xC
configure.py
+1 -1
View File
@@ -900,7 +900,7 @@ config.libs = [
Object(Matching, "egg/gfx/eggScreenEffectBase.cpp"),
Object(NonMatching, "egg/gfx/eggScreenEffectBlur.cpp"), # Unknown Guess
Object(NonMatching, "egg/gfx/eggStateEfb.cpp"),
Object(NonMatching, "egg/gfx/eggStateGX.cpp"),
Object(Matching, "egg/gfx/eggStateGX.cpp"),
Object(Matching, "egg/gfx/eggTextureBuffer.cpp"),
],
),
include/egg/core/eggDisplay.h
+9
View File
@@ -5,6 +5,7 @@
#include "egg/core/eggSystem.h" // for BaseSystem config
#include "egg/core/eggVideo.h"
#include "egg/prim/eggBitFlag.h"
#include "nw4r/ut/ut_Color.h"
#include "nw4r/ut.h" // IWYU pragma: export
#include "rvl/VI.h" // IWYU pragma: export
@@ -49,6 +50,14 @@ public:
void calcFrequency();
void setBlack(bool b) {}
nw4r::ut::Color getClearColor() const {
return mClearColor;
}
void setClearColor(nw4r::ut::Color color) {
mClearColor = color;
}
public:
static u32 sTickPeriod;
};
include/egg/gfx/eggStateGX.h
+61 -52
View File
@@ -2,64 +2,71 @@
#define EGG_STATE_GX_H
#include "common.h"
#include "rvl/GX/GXTexture.h"
#include "rvl/GX/GXTypes.h"
#include "rvl/GX.h" // IWYU pragma: export
namespace EGG {
class StateGX {
public:
struct ScopedColor {
ScopedColor(bool x) {
old = GXSetColorUpdate_(x);
}
struct ScopedColor
{
ScopedColor(bool x)
{
old = GXSetColorUpdate_(x);
}
~ScopedColor() {
GXSetColorUpdate_(old);
}
~ScopedColor()
{
GXSetColorUpdate_(old);
}
bool old;
};
bool old;
};
struct ScopedAlpha {
ScopedAlpha(bool x) {
old = GXSetAlphaUpdate_(x);
}
struct ScopedAlpha
{
ScopedAlpha(bool x)
{
old = GXSetAlphaUpdate_(x);
}
~ScopedAlpha() {
GXSetAlphaUpdate_(old);
}
~ScopedAlpha()
{
GXSetAlphaUpdate_(old);
}
bool old;
};
bool old;
};
struct ScopedDither {
ScopedDither(bool x) {
old = GXSetDither_(x);
}
struct ScopedDither
{
ScopedDither(bool x)
{
old = GXSetDither_(x);
}
~ScopedDither() {
GXSetDither_(old);
}
~ScopedDither()
{
GXSetDither_(old);
}
bool old;
};
bool old;
};
struct CacheGX {
/* 0x00 */ u8 _0x00[0xC];
/* 0x0C */ bool mDstAlphaEnable;
/* 0x0D */ u8 mDstAlpha;
/* 0x0E */ u8 _0x0E[0x18 - 0x0E];
};
static GXColor& getDefaultTexColor() { return sDefaultTexColor; }
struct MemLayout {
/* 0x00 */ int mLayout;
/* 0x04 */ u32 numRegions;
/* 0x08 */ GXTexRegion mRegions[10];
};
static GXColor &getClearEfb() {
return s_clearEfb;
}
static void initialize(u16, u16, GXColor, GXPixelFmt);
static void frameInit();
static void textureInit(); // Guess for 804b4810
static void setTMemLayout(int layout);
static void resetGX();
static void resetVtx();
@@ -72,33 +79,35 @@ public:
static void resetGXCache();
static void GXSetPixelFmt(GXPixelFmt pixelFmt, GXZFmt16 zFmt);
static void invalidateTexAllGX();
static void GXSetPixelFmt_(GXPixelFmt pixelFmt, GXZFmt16 zFmt);
static bool GXSetColorUpdate_(bool);
static bool GXSetAlphaUpdate_(bool);
static bool GXSetDither_(bool);
static bool GXSetDstAlpha_(bool, u8);
static bool GXSetColorUpdate(bool);
static bool GXSetAlphaUpdate(bool);
static bool GXSetDither();
static void GXCopyTex(void *data, bool);
static bool GXSetDstAlpha();
// Unk func here
static void GXSetProjection(Mtx44, int);
static void GXCopyTex_(void *data, bool);
static CacheGX &GXSetDstAlpha_(bool, u8);
static void GXSetProjection_(Mtx44, GXProjectionType);
static void GXSetProjectionv_(const f32 *);
static void GXSetViewport_(f32, f32, f32, f32, f32, f32);
static void GXSetScissor_(u32, u32, u32, u32);
static void GXSetScissorBoxOffset_(s32, s32);
// not sure
static void CalculateScreenScissor(const f32 src[4], u32 dst[4]);
static u16 s_commandFlag;
static u16 s_flag;
static u16 s_widthEfb;
static u16 s_heightEfb;
static GXColor sDefaultTexColor;
static GXPixelFmt s_pixFormat;
static GXZFmt16 s_zFmt16;
static GXColor s_clearEfb;
static u16 s_flag;
static u16 s_commandFlag;
static CacheGX s_cacheGX;
// Inofficial names
static GXTexObj sDefaultTexObj;
static MemLayout s_tmem_layout; // same name, different type
};
} // namespace EGG
include/rvl/GX/GXPixel.h
+4
View File
@@ -17,11 +17,15 @@ void GXSetFog(GXFogType type, GXColor color, f32 start, f32 end, f32 near, f32 f
void GXInitFogAdjTable(GXFogAdjTable *table, u16 width, const Mtx44 proj);
void GXSetFogRangeAdj(GXBool enable, u16 center, const GXFogAdjTable *table);
void GXSetBlendMode(GXBlendMode mode, GXBlendFactor src, GXBlendFactor dst, GXLogicOp op);
void GXGetColorUpdate(GXBool *enable);
void GXSetColorUpdate(GXBool enable);
void GXGetAlphaUpdate(GXBool *enable);
void GXSetAlphaUpdate(GXBool enable);
void GXSetZMode(GXBool enableTest, GXCompare func, GXBool enableUpdate);
void GXSetZCompLoc(GXBool beforeTex);
void GXGetPixelFmt(GXPixelFmt *pixelFmt, GXZFmt16 *zFmt);
void GXSetPixelFmt(GXPixelFmt pixelFmt, GXZFmt16 zFmt);
void GXGetDither(GXBool *enable);
void GXSetDither(GXBool enable);
void GXSetDstAlpha(GXBool enable, u8 alpha);
void GXSetFieldMask(GXBool enableEven, GXBool enableOdd);
include/rvl/GX/GXTexture.h
+3
View File
@@ -44,6 +44,9 @@ void GXGetTexObjLODAll(
u8 *biasClampEnable, u8 *edgeLODEnable, GXAnisotropy *anisotropy
);
void GXSetTexCoordScaleManually(GXTexCoordID, GXBool, u16, u16);
void GXSetTexCoordBias(GXTexCoordID, GXBool, GXBool);
u16 GXGetTexObjWidth(const GXTexObj *obj);
u16 GXGetTexObjHeight(const GXTexObj *obj);
GXTexFmt GXGetTexObjFormat(const GXTexObj *obj);
include/rvl/GX/GXTransform.h
+1 -1
View File
@@ -33,7 +33,7 @@ void GXGetViewportv(f32 view[6]);
void GXSetZScaleOffset(f32 scale, f32 offset);
void GXSetScissor(u32 x, u32 y, u32 w, u32 h);
void GXGetScissor(u32 *x, u32 *y, u32 *w, u32 *h);
void GXSetScissorBoxOffset(u32 ox, u32 oy);
void GXSetScissorBoxOffset(s32 ox, s32 oy);
void GXSetClipMode(GXClipMode mode);
void __GXSetProjection(void);
src/egg/gfx/eggCapTexture.cpp
+1 -1
View File
@@ -40,7 +40,7 @@ void CapTexture::capture(u16 x, u16 y, bool upscale, int format) {
GXSetZMode(true, GX_ALWAYS, (mCapFlags & 4) != 0);
GXSetCopyClear(mClearColor, field_0x20);
GXSetCopyClamp(3);
StateGX::GXCopyTex(dataPtr, true);
StateGX::GXCopyTex_(dataPtr, true);
GXSetCopyFilter(0, copyArg2, 0, defaultFilter.values);
if ((mCapFlags & 0x10) != 0) {
src/egg/gfx/eggStateGX.cpp
+321 -1
View File
@@ -1,3 +1,323 @@
#include "egg/gfx/eggStateGX.h"
namespace EGG {} // namespace EGG
#include "common.h"
#include "egg/core/eggDisplay.h"
#include "egg/core/eggSystem.h"
#include "nw4r/g3d/g3d_init.h"
#include "nw4r/g3d/platform/g3d_tmem.h"
#include "rvl/GX/GXAttr.h"
#include "rvl/GX/GXBump.h"
#include "rvl/GX/GXFrameBuf.h"
#include "rvl/GX/GXGeometry.h"
#include "rvl/GX/GXPixel.h"
#include "rvl/GX/GXTexture.h"
#include "rvl/GX/GXTransform.h"
#include "rvl/GX/GXTypes.h"
#include <cstring>
namespace {
static GXTexRegion *texRegionCallback(const GXTexObj *pObj, GXTexMapID map) {
return &EGG::StateGX::s_tmem_layout.mRegions[map % EGG::StateGX::s_tmem_layout.numRegions];
}
static const GXColor white = {0xFF, 0xFF, 0xFF, 0xFF};
static const f32 identity[3][4] = {
{1.0f, 0.0f, 0.0f, 0.0f},
{0.0f, 1.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 1.0f, 0.0f},
};
} // namespace
namespace EGG {
GXTexObj StateGX::sDefaultTexObj;
StateGX::MemLayout StateGX::s_tmem_layout;
StateGX::CacheGX StateGX::s_cacheGX;
u16 StateGX::s_widthEfb;
u16 StateGX::s_heightEfb;
GXPixelFmt StateGX::s_pixFormat;
GXZFmt16 StateGX::s_zFmt16;
GXColor StateGX::s_clearEfb;
u16 StateGX::s_flag;
u16 StateGX::s_commandFlag;
void StateGX::initialize(u16 width, u16 height, GXColor color, GXPixelFmt pixelFmt) {
s_widthEfb = width;
s_heightEfb = height;
s_clearEfb = color;
s_pixFormat = pixelFmt;
if (BaseSystem::getDisplay() != nullptr) {
BaseSystem::getDisplay()->setClearColor(color);
}
static u8 sDefaultTexObjData[16] = {0};
GXInitTexObj(&sDefaultTexObj, sDefaultTexObjData, 4, 4, GX_TF_IA8, GX_CLAMP, GX_CLAMP, 0);
GXInitTexObjLOD(&sDefaultTexObj, GX_LINEAR, GX_LINEAR, 0.0f, 0.0f, 0.0f, 0, 0, GX_ANISO_1);
invalidateTexAllGX();
frameInit();
setTMemLayout(nw4r::g3d::tmem::TMEM_LAYOUT_1);
}
void StateGX::frameInit() {
GXSetPixelFmt_(s_pixFormat, s_zFmt16);
if (BaseSystem::mConfigData->getDisplay() != nullptr) {
s_clearEfb = BaseSystem::mConfigData->getDisplay()->getClearColor();
}
GXInvalidateVtxCache();
GXSetCurrentMtx(0);
GXSetCoPlanar(false);
GXSetClipMode(GX_CLIP_ENABLE);
resetGX();
nw4r::g3d::G3dReset();
}
void StateGX::setTMemLayout(int layout) {
s_tmem_layout.mLayout = layout;
if (nw4r::g3d::tmem::TMEM_LAYOUT_NONE <= layout && layout <= nw4r::g3d::tmem::TMEM_LAYOUT_3) {
nw4r::g3d::tmem::SetTMemLayout(static_cast<nw4r::g3d::tmem::TMemLayout>(layout));
s_tmem_layout.numRegions = 8;
} else {
static const u32 numbers[4] = {0x8, 0x4, 0x1, 0x7};
static const u32 offsets[4] = {0x8000, 0x20000, 0x80000, 0};
u32 index = layout - 4;
s_tmem_layout.numRegions = numbers[index];
for (u32 i = 0; i < 8; i++) {
std::memset(&s_tmem_layout.mRegions[i], 0, sizeof(GXTexRegion));
}
u32 addr = 0;
for (u32 i = 0; i < numbers[index]; i++) {
int u1 = layout == 7 ? (0 <= i && i < 3 ? 1 : 0) : index;
if ((i & 1) != 0) {
GXInitTexCacheRegion(&s_tmem_layout.mRegions[i], false, addr + 0x80000, u1, addr, u1);
} else {
GXInitTexCacheRegion(&s_tmem_layout.mRegions[i], false, addr, u1, addr + 0x80000, u1);
}
addr += offsets[u1];
}
GXSetTexRegionCallback(texRegionCallback);
}
}
void StateGX::resetGX() {
if ((s_flag & 1) == 0) {
resetVtx();
resetIndirect();
resetColorChannel();
resetTexture();
resetTexGen();
resetTev();
resetPE();
}
resetGXCache();
}
void StateGX::resetVtx() {
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, GX_F32, 0);
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_NRM, GX_CLR_RGB, GX_F32, 0);
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0);
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR1, GX_CLR_RGBA, GX_RGBA8, 0);
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_CLR_RGBA, GX_RGBA4, 7);
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX1, GX_CLR_RGBA, GX_RGBA4, 7);
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX2, GX_CLR_RGBA, GX_RGBA4, 7);
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX3, GX_CLR_RGBA, GX_RGBA4, 7);
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX4, GX_CLR_RGBA, GX_RGBA4, 7);
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX5, GX_CLR_RGBA, GX_RGBA4, 7);
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX6, GX_CLR_RGBA, GX_RGBA4, 7);
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX7, GX_CLR_RGBA, GX_RGBA4, 7);
}
void StateGX::resetColorChannel() {
GXSetNumChans(1);
GXSetChanAmbColor(GX_COLOR0A0, white);
GXSetChanAmbColor(GX_COLOR1A1, white);
GXSetChanMatColor(GX_COLOR0A0, white);
GXSetChanMatColor(GX_COLOR1A1, white);
GXSetCullMode(GX_CULL_BACK);
GXSetChanCtrl(GX_COLOR0A0, false, GX_SRC_REG, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_CLAMP, GX_AF_NONE);
GXSetChanCtrl(GX_COLOR1A1, false, GX_SRC_REG, GX_SRC_REG, GX_LIGHT_NULL, GX_DF_CLAMP, GX_AF_NONE);
}
void StateGX::resetIndirect() {
GXSetNumIndStages(0);
static const f32 ind[2][3] = {
{0.5f, 0.0f, 0.0f},
{0.0f, 0.5f, 0.0f},
};
for (u32 i = 0; i < 3; i++) {
GXSetIndTexMtx(static_cast<GXIndTexMtxID>(i + GX_ITM_0), ind, 1);
}
for (u32 i = 0; i < 4; i++) {
GXSetIndTexCoordScale(static_cast<GXIndTexStageID>(i + GX_INDTEXSTAGE0), GX_ITS_1, GX_ITS_1);
}
}
void StateGX::resetTexture() {
for (u32 i = 0; i < s_tmem_layout.numRegions; i++) {
GXLoadTexObj(&sDefaultTexObj, static_cast<GXTexMapID>(i + GX_TEXMAP0));
}
}
void StateGX::resetTexGen() {
GXSetNumTexGens(1);
for (u32 i = 0; i < 10; i++) {
GXLoadTexMtxImm(identity, i * 3 + 0x1E, GX_MTX_3x4);
}
for (u32 i = 0; i < GX_MAX_TEXCOORD; i++) {
GXTexCoordID id = static_cast<GXTexCoordID>(i);
GXSetTexCoordGen2(id, GX_TG_MTX2x4, GX_TG_TEX0, 0x3c, 0, 0x7d);
GXSetTexCoordScaleManually(id, false, 0, 0);
GXSetTexCoordBias(id, false, false);
}
}
void StateGX::resetTev() {
GXSetNumTevStages(1);
for (u32 i = 0; i < GX_MAX_TEVSTAGE; i++) {
GXTevStageID id = static_cast<GXTevStageID>(i);
GXSetTevDirect(id);
GXSetTevOrder(id, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR_NULL);
GXSetTevColorIn(id, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO);
GXSetTevColorOp(id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, 1, GX_TEVPREV);
GXSetTevAlphaIn(id, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO);
GXSetTevAlphaOp(id, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, true, GX_TEVPREV);
GXSetTevSwapMode(id, GX_TEV_SWAP0, GX_TEV_SWAP0);
}
for (u32 i = 0; i < GX_MAX_KCOLOR; i++) {
GXTevKColorID id = static_cast<GXTevKColorID>(i);
GXSetTevKColor(id, white);
}
for (u32 i = 0; i < GX_MAX_TEVREG; i++) {
GXTevRegID id = static_cast<GXTevRegID>(i);
GXSetTevColor(id, white);
}
GXSetTevSwapModeTable(GX_TEV_SWAP0, GX_CH_RED, GX_CH_GREEN, GX_CH_BLUE, GX_CH_ALPHA);
GXSetTevSwapModeTable(GX_TEV_SWAP1, GX_CH_RED, GX_CH_RED, GX_CH_RED, GX_CH_ALPHA);
GXSetTevSwapModeTable(GX_TEV_SWAP2, GX_CH_GREEN, GX_CH_GREEN, GX_CH_GREEN, GX_CH_ALPHA);
GXSetTevSwapModeTable(GX_TEV_SWAP3, GX_CH_BLUE, GX_CH_BLUE, GX_CH_BLUE, GX_CH_ALPHA);
}
void StateGX::resetPE() {
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_NOOP);
GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_AND, GX_ALWAYS, 0);
GXSetZTexture(0, GX_TF_Z24X8, 0);
GXSetZMode(true, GX_LEQUAL, true);
GXSetFog(GX_FOG_NONE, white, 0.0f, 1.0f, 0.1f, 1.0f);
GXSetFogRangeAdj(false, 0, nullptr);
GXSetZCompLoc(true);
GXSetDstAlpha(false, 0);
}
void StateGX::resetGXCache() {
GXSetColorUpdate_(true);
GXSetAlphaUpdate_(true);
GXSetDither_(true);
GXSetDstAlpha_(false, 0);
}
void StateGX::GXSetPixelFmt_(GXPixelFmt pixelFmt, GXZFmt16 zFmt) {
GXPixelFmt oldPixelFmt;
GXZFmt16 oldZFmt;
GXGetPixelFmt(&oldPixelFmt, &oldZFmt);
if (pixelFmt != oldPixelFmt || zFmt != oldZFmt) {
GXBool oldColorUpdate;
GXGetColorUpdate(&oldColorUpdate);
bool bOldColorUpdate = oldColorUpdate;
GXBool oldAlphaUpdate;
GXGetAlphaUpdate(&oldAlphaUpdate);
bool bOldAlphaUpdate = oldAlphaUpdate;
GXSetPixelFmt(pixelFmt, zFmt);
GXSetColorUpdate(bOldColorUpdate);
GXSetAlphaUpdate(bOldAlphaUpdate);
}
}
void StateGX::invalidateTexAllGX() {
GXInvalidateTexAll();
}
bool StateGX::GXSetColorUpdate_(bool enable) {
GXBool oldEnable;
GXGetColorUpdate(&oldEnable);
bool bOldEnable = oldEnable;
GXSetColorUpdate(enable);
return bOldEnable;
}
bool StateGX::GXSetAlphaUpdate_(bool enable) {
GXBool oldEnable;
GXGetAlphaUpdate(&oldEnable);
bool bOldEnable = oldEnable;
GXSetAlphaUpdate(enable);
return bOldEnable;
}
bool StateGX::GXSetDither_(bool enable) {
GXBool oldEnable;
GXGetDither(&oldEnable);
bool bOldEnable = oldEnable;
GXSetDither(enable);
return bOldEnable;
}
void StateGX::GXCopyTex_(void *data, bool bUpdate) {
GXCopyTex(data, bUpdate);
}
StateGX::CacheGX &StateGX::GXSetDstAlpha_(bool enable, u8 alpha) {
GXSetDstAlpha(enable, alpha);
s_cacheGX.mDstAlphaEnable = enable;
s_cacheGX.mDstAlpha = alpha;
return s_cacheGX;
}
void StateGX::CalculateScreenScissor(const f32 src[4], u32 dst[4]) {
dst[0] = src[0] >= 0.0f ? src[0] : 0.0f;
dst[1] = src[1] >= 0.0f ? src[1] : 0.0f;
dst[2] = dst[0] + src[2] > 640.0f ? 640 - dst[0] : src[2];
dst[3] = dst[1] + src[3] > 528.0f ? 528 - dst[1] : src[3];
}
void StateGX::GXSetProjection_(Mtx44 proj, GXProjectionType type) {
GXSetProjection(proj, type);
s_commandFlag |= 1;
}
void StateGX::GXSetProjectionv_(const f32 *proj) {
GXSetProjectionv(proj);
s_commandFlag |= 1;
}
void StateGX::GXSetViewport_(f32 ox, f32 oy, f32 sx, f32 sy, f32 near, f32 far) {
GXSetViewport(ox, oy, sx, sy, near, far);
s_commandFlag |= 2;
}
void StateGX::GXSetScissor_(u32 x, u32 y, u32 w, u32 h) {
GXSetScissor(x, y, w, h);
s_commandFlag |= 4;
}
void StateGX::GXSetScissorBoxOffset_(s32 ox, s32 oy) {
GXSetScissorBoxOffset(ox, oy);
s_commandFlag |= 8;
}
} // namespace EGG
src/egg/gfx/eggTextureBuffer.cpp
+1 -1
View File
@@ -12,7 +12,7 @@ TextureBuffer::TextureBuffer() : mSize(0), mState(STATE_FREE), mpNext(nullptr),
void TextureBuffer::configure() {
CapTexture::configure();
setClearColor(StateGX::getDefaultTexColor());
setClearColor(StateGX::getClearEfb());
setWrap(GX_CLAMP, GX_CLAMP);
setFilt(GX_LINEAR, GX_LINEAR);
setPixModeSync(true);