mirror of
https://github.com/TwilitRealm/dusklight
synced 2026-07-29 07:21:54 -04:00
copy dolsdk2004 to tp / b_bh + e_mb done (#2299)
* move dolsdk2004 over * cleanup some temp work * finish and cleanup gf * b_bh done * d_a_e_mb done
This commit is contained in:
@@ -101,14 +101,14 @@ void J2DGrafContext::setColor(JUtility::TColor colorTL, JUtility::TColor colorTR
|
||||
mColorBR = colorBR;
|
||||
mColorBL = colorBL;
|
||||
field_0xb0.mType = GX_BM_BLEND;
|
||||
field_0xb0.mSrcFactor = GX_BL_SRC_ALPHA;
|
||||
field_0xb0.mDstFactor = GX_BL_INV_SRC_ALPHA;
|
||||
field_0xb0.mSrcFactor = GX_BL_SRCALPHA;
|
||||
field_0xb0.mDstFactor = GX_BL_INVSRCALPHA;
|
||||
mLinePart.mType = GX_BM_BLEND;
|
||||
mLinePart.mSrcFactor = GX_BL_SRC_ALPHA;
|
||||
mLinePart.mDstFactor = GX_BL_INV_SRC_ALPHA;
|
||||
mLinePart.mSrcFactor = GX_BL_SRCALPHA;
|
||||
mLinePart.mDstFactor = GX_BL_INVSRCALPHA;
|
||||
mBoxPart.mType = GX_BM_BLEND;
|
||||
mBoxPart.mSrcFactor = GX_BL_SRC_ALPHA;
|
||||
mBoxPart.mDstFactor = GX_BL_INV_SRC_ALPHA;
|
||||
mBoxPart.mSrcFactor = GX_BL_SRCALPHA;
|
||||
mBoxPart.mDstFactor = GX_BL_INVSRCALPHA;
|
||||
if ((mColorTL & 0xFF) != 0xFF) {
|
||||
return;
|
||||
}
|
||||
@@ -202,4 +202,4 @@ void J2DGrafContext::line(JGeometry::TVec2<f32> start, JGeometry::TVec2<f32> end
|
||||
void J2DGrafContext::lineTo(JGeometry::TVec2<f32> pos) {
|
||||
this->line(mPrevPos, pos);
|
||||
mPrevPos = pos;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -398,10 +398,10 @@ void J2DTevBlock1::setGX() {
|
||||
}
|
||||
GXSetTevSwapMode(GX_TEVSTAGE0, GXTevSwapSel(mTevStage[0].getRasSel()), GXTevSwapSel(mTevStage[0].getTexSel()));
|
||||
for (int i = 0; i < 4; i++) {
|
||||
GXSetTevSwapModeTable(GXTevSwapSel(i), GXTevColor(mTevSwapModeTable[i].getR()),
|
||||
GXTevColor(mTevSwapModeTable[i].getG()),
|
||||
GXTevColor(mTevSwapModeTable[i].getB()),
|
||||
GXTevColor(mTevSwapModeTable[i].getA()));
|
||||
GXSetTevSwapModeTable(GXTevSwapSel(i), GXTevColorChan(mTevSwapModeTable[i].getR()),
|
||||
GXTevColorChan(mTevSwapModeTable[i].getG()),
|
||||
GXTevColorChan(mTevSwapModeTable[i].getB()),
|
||||
GXTevColorChan(mTevSwapModeTable[i].getA()));
|
||||
}
|
||||
mIndTevStage->load(0);
|
||||
}
|
||||
@@ -636,7 +636,7 @@ bool J2DTevBlock2::setTexture(u32 param_0, ResTIMG const* p_timg) {
|
||||
const ResTIMG* timg = mTexture[param_0 == 0]->getTexInfo();
|
||||
if (timg != NULL && timg->indexTexture) {
|
||||
int tlutname = mTexture[param_0 == 0]->getTlutName();
|
||||
u8 tlut_no = tlutname - (tlutname >= GX_MAX_TLUT ? GX_BIGTLUT0 : GX_TLUT0);
|
||||
u8 tlut_no = tlutname - (tlutname >= GX_BIGTLUT0 ? GX_BIGTLUT0 : GX_TLUT0);
|
||||
|
||||
if (tlut_no == 0) {
|
||||
tlutid = 1;
|
||||
@@ -845,10 +845,10 @@ void J2DTevBlock2::setGX() {
|
||||
GXSetTevSwapMode(GXTevStageID(i), GXTevSwapSel(mTevStage[i].getRasSel()), GXTevSwapSel(mTevStage[i].getTexSel()));
|
||||
}
|
||||
for (int i = 0; i < 4; i++) {
|
||||
GXSetTevSwapModeTable(GXTevSwapSel(i), GXTevColor(mTevSwapModeTable[i].getR()),
|
||||
GXTevColor(mTevSwapModeTable[i].getG()),
|
||||
GXTevColor(mTevSwapModeTable[i].getB()),
|
||||
GXTevColor(mTevSwapModeTable[i].getA()));
|
||||
GXSetTevSwapModeTable(GXTevSwapSel(i), GXTevColorChan(mTevSwapModeTable[i].getR()),
|
||||
GXTevColorChan(mTevSwapModeTable[i].getG()),
|
||||
GXTevColorChan(mTevSwapModeTable[i].getB()),
|
||||
GXTevColorChan(mTevSwapModeTable[i].getA()));
|
||||
}
|
||||
for (u8 i = 0; i < mTevStageNum; i++) {
|
||||
mIndTevStage[i].load(i);
|
||||
@@ -977,7 +977,7 @@ bool J2DTevBlock4::insertTexture(u32 param_0, ResTIMG const* p_timg, JUTPalette*
|
||||
continue;
|
||||
}
|
||||
int tlutName = mTexture[i]->getTlutName();
|
||||
u8 tlut_no = tlutName - (tlutName >= GX_MAX_TLUT ? GX_BIGTLUT0 : GX_TLUT0);
|
||||
u8 tlut_no = tlutName - (tlutName >= GX_BIGTLUT0 ? GX_BIGTLUT0 : GX_TLUT0);
|
||||
if (tlut_no < 4) {
|
||||
local_44 |= 1 << tlut_no;
|
||||
}
|
||||
@@ -1095,7 +1095,7 @@ bool J2DTevBlock4::setTexture(u32 param_0, ResTIMG const* p_timg) {
|
||||
const ResTIMG* timg = mTexture[i]->getTexInfo();
|
||||
if (timg != NULL && timg->indexTexture) {
|
||||
int tlutname = mTexture[i]->getTlutName();
|
||||
u8 tlut_no = tlutname - (tlutname >= GX_MAX_TLUT ? GX_BIGTLUT0 : GX_TLUT0);
|
||||
u8 tlut_no = tlutname - (tlutname >= GX_BIGTLUT0 ? GX_BIGTLUT0 : GX_TLUT0);
|
||||
|
||||
if (tlut_no < 4) {
|
||||
used_tlut |= 1 << tlut_no;
|
||||
@@ -1312,10 +1312,10 @@ void J2DTevBlock4::setGX() {
|
||||
GXSetTevSwapMode(GXTevStageID(i), GXTevSwapSel(mTevStage[i].getRasSel()), GXTevSwapSel(mTevStage[i].getTexSel()));
|
||||
}
|
||||
for (int i = 0; i < 4; i++) {
|
||||
GXSetTevSwapModeTable(GXTevSwapSel(i), GXTevColor(mTevSwapModeTable[i].getR()),
|
||||
GXTevColor(mTevSwapModeTable[i].getG()),
|
||||
GXTevColor(mTevSwapModeTable[i].getB()),
|
||||
GXTevColor(mTevSwapModeTable[i].getA()));
|
||||
GXSetTevSwapModeTable(GXTevSwapSel(i), GXTevColorChan(mTevSwapModeTable[i].getR()),
|
||||
GXTevColorChan(mTevSwapModeTable[i].getG()),
|
||||
GXTevColorChan(mTevSwapModeTable[i].getB()),
|
||||
GXTevColorChan(mTevSwapModeTable[i].getA()));
|
||||
}
|
||||
for (u8 i = 0; i < mTevStageNum; i++) {
|
||||
mIndTevStage[i].load(i);
|
||||
@@ -1413,7 +1413,7 @@ bool J2DTevBlock8::insertTexture(u32 param_0, ResTIMG const* p_timg, JUTPalette*
|
||||
continue;
|
||||
}
|
||||
int tlutName = mTexture[i]->getTlutName();
|
||||
u8 tlut_no = tlutName - (tlutName >= GX_MAX_TLUT ? GX_BIGTLUT0 : GX_TLUT0);
|
||||
u8 tlut_no = tlutName - (tlutName >= GX_BIGTLUT0 ? GX_BIGTLUT0 : GX_TLUT0);
|
||||
if (tlut_no < 8) {
|
||||
local_44 |= 1 << tlut_no;
|
||||
}
|
||||
@@ -1531,7 +1531,7 @@ bool J2DTevBlock8::setTexture(u32 param_0, ResTIMG const* p_timg) {
|
||||
const ResTIMG* timg = mTexture[i]->getTexInfo();
|
||||
if (timg != NULL && timg->indexTexture) {
|
||||
int tlutname = mTexture[i]->getTlutName();
|
||||
u8 tlut_no = tlutname - (tlutname >= GX_MAX_TLUT ? GX_BIGTLUT0 : GX_TLUT0);
|
||||
u8 tlut_no = tlutname - (tlutname >= GX_BIGTLUT0 ? GX_BIGTLUT0 : GX_TLUT0);
|
||||
|
||||
if (tlut_no < 8) {
|
||||
used_tlut |= 1 << tlut_no;
|
||||
@@ -1743,10 +1743,10 @@ void J2DTevBlock8::setGX() {
|
||||
GXSetTevSwapMode(GXTevStageID(i), GXTevSwapSel(mTevStage[i].getRasSel()), GXTevSwapSel(mTevStage[i].getTexSel()));
|
||||
}
|
||||
for (int i = 0; i < 4; i++) {
|
||||
GXSetTevSwapModeTable(GXTevSwapSel(i), GXTevColor(mTevSwapModeTable[i].getR()),
|
||||
GXTevColor(mTevSwapModeTable[i].getG()),
|
||||
GXTevColor(mTevSwapModeTable[i].getB()),
|
||||
GXTevColor(mTevSwapModeTable[i].getA()));
|
||||
GXSetTevSwapModeTable(GXTevSwapSel(i), GXTevColorChan(mTevSwapModeTable[i].getR()),
|
||||
GXTevColorChan(mTevSwapModeTable[i].getG()),
|
||||
GXTevColorChan(mTevSwapModeTable[i].getB()),
|
||||
GXTevColorChan(mTevSwapModeTable[i].getA()));
|
||||
}
|
||||
for (u8 i = 0; i < mTevStageNum; i++) {
|
||||
mIndTevStage[i].load(i);
|
||||
@@ -1844,7 +1844,7 @@ bool J2DTevBlock16::insertTexture(u32 param_0, ResTIMG const* p_timg, JUTPalette
|
||||
continue;
|
||||
}
|
||||
int tlutName = mTexture[i]->getTlutName();
|
||||
u8 tlut_no = tlutName - (tlutName >= GX_MAX_TLUT ? GX_BIGTLUT0 : GX_TLUT0);
|
||||
u8 tlut_no = tlutName - (tlutName >= GX_BIGTLUT0 ? GX_BIGTLUT0 : GX_TLUT0);
|
||||
if (tlut_no < 8) {
|
||||
local_44 |= 1 << tlut_no;
|
||||
}
|
||||
@@ -1962,7 +1962,7 @@ bool J2DTevBlock16::setTexture(u32 param_0, ResTIMG const* p_timg) {
|
||||
const ResTIMG* timg = mTexture[i]->getTexInfo();
|
||||
if (timg != NULL && timg->indexTexture) {
|
||||
int tlutname = mTexture[i]->getTlutName();
|
||||
u8 tlut_no = tlutname - (tlutname >= GX_MAX_TLUT ? GX_BIGTLUT0 : GX_TLUT0);
|
||||
u8 tlut_no = tlutname - (tlutname >= GX_BIGTLUT0 ? GX_BIGTLUT0 : GX_TLUT0);
|
||||
|
||||
if (tlut_no < 8) {
|
||||
used_tlut |= 1 << tlut_no;
|
||||
@@ -2174,10 +2174,10 @@ void J2DTevBlock16::setGX() {
|
||||
GXSetTevSwapMode(GXTevStageID(i), GXTevSwapSel(mTevStage[i].getRasSel()), GXTevSwapSel(mTevStage[i].getTexSel()));
|
||||
}
|
||||
for (int i = 0; i < 4; i++) {
|
||||
GXSetTevSwapModeTable(GXTevSwapSel(i), GXTevColor(mTevSwapModeTable[i].getR()),
|
||||
GXTevColor(mTevSwapModeTable[i].getG()),
|
||||
GXTevColor(mTevSwapModeTable[i].getB()),
|
||||
GXTevColor(mTevSwapModeTable[i].getA()));
|
||||
GXSetTevSwapModeTable(GXTevSwapSel(i), GXTevColorChan(mTevSwapModeTable[i].getR()),
|
||||
GXTevColorChan(mTevSwapModeTable[i].getG()),
|
||||
GXTevColorChan(mTevSwapModeTable[i].getB()),
|
||||
GXTevColorChan(mTevSwapModeTable[i].getA()));
|
||||
}
|
||||
for (u8 i = 0; i < mTevStageNum; i++) {
|
||||
mIndTevStage[i].load(i);
|
||||
|
||||
@@ -1086,7 +1086,7 @@ void J2DPicture::setTevMode() {
|
||||
}
|
||||
|
||||
GXSetNumTevStages(u8(i));
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
|
||||
for (i = 0; i < mTextureNum; i++) {
|
||||
GXSetTexCoordGen(GXTexCoordID(i), GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY);
|
||||
@@ -1333,7 +1333,7 @@ u8 J2DPicture::getUsableTlut(u8 param_0) {
|
||||
|
||||
if (img != NULL && img->indexTexture != 0) {
|
||||
int name = mTexture[i]->getTlutName();
|
||||
int var_r0 = name >= GX_MAX_TLUT ? GX_MAX_TLUT : GX_TLUT0;
|
||||
int var_r0 = name >= GX_BIGTLUT0 ? GX_BIGTLUT0 : GX_TLUT0;
|
||||
|
||||
u8 temp_r0 = name - var_r0;
|
||||
if (temp_r0 < 2) {
|
||||
@@ -1481,4 +1481,4 @@ bool J2DPicture::isUsed(ResFONT const* param_0) {
|
||||
/* 802FF65C-802FF660 2F9F9C 0004+00 1/0 0/0 0/0 .text rewriteAlpha__10J2DPictureFv */
|
||||
void J2DPicture::rewriteAlpha() {
|
||||
/* empty function */
|
||||
}
|
||||
}
|
||||
|
||||
@@ -319,7 +319,7 @@ void J2DScreen::drawSelf(f32 param_0, f32 param_1, Mtx* param_2) {
|
||||
JUtility::TColor sp8(alpha | ((u32)color & 0xFFFFFF00));
|
||||
color = sp8;
|
||||
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
|
||||
GXBegin(GX_QUADS, GX_VTXFMT0, 4);
|
||||
|
||||
|
||||
@@ -69,7 +69,7 @@ void J2DIndTevStage::load(u8 tevStage) {
|
||||
|
||||
/* 802EA098-802EA0CC 2E49D8 0034+00 0/0 1/1 0/0 .text load__12J2DIndTexMtxFUc */
|
||||
void J2DIndTexMtx::load(u8 indTexMtx) {
|
||||
GXSetIndTexMtx((GXIndTexMtxID)(GX_ITM_0 + indTexMtx), (f32*)mIndTexMtxInfo.mMtx,
|
||||
GXSetIndTexMtx((GXIndTexMtxID)(GX_ITM_0 + indTexMtx), mIndTexMtxInfo.mMtx,
|
||||
mIndTexMtxInfo.mScaleExp);
|
||||
}
|
||||
|
||||
@@ -165,7 +165,7 @@ extern const J2DTevSwapModeTableInfo j2dDefaultTevSwapModeTable = {
|
||||
GX_CH_RED, GX_CH_GREEN, GX_CH_BLUE, GX_CH_ALPHA};
|
||||
|
||||
/* 804561A0-804561A4 0047A0 0004+00 0/0 3/3 0/0 .sdata2 j2dDefaultBlendInfo */
|
||||
extern const J2DBlendInfo j2dDefaultBlendInfo = {GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA,
|
||||
extern const J2DBlendInfo j2dDefaultBlendInfo = {GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA,
|
||||
GX_LO_NOOP};
|
||||
|
||||
/* 804561A4-804561A8 0047A4 0004+00 0/0 1/1 0/0 .sdata2 None */
|
||||
|
||||
@@ -430,7 +430,7 @@ void J2DWindow::drawContents(JGeometry::TBox2<f32> const& param_0) {
|
||||
{
|
||||
GXSetBlendMode(GX_BM_NONE, GX_BL_ONE, GX_BL_ZERO, GX_LO_SET);
|
||||
} else {
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
}
|
||||
GXClearVtxDesc();
|
||||
GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
|
||||
@@ -573,7 +573,7 @@ void J2DWindow::setTevMode(JUTTexture* param_0, JUtility::TColor param_1,
|
||||
GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, 1, GX_TEVPREV);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, 1, GX_TEVPREV);
|
||||
GXSetNumTevStages(1);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
} else {
|
||||
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL);
|
||||
GXSetTevColor(GX_TEVREG0, param_1);
|
||||
@@ -595,7 +595,7 @@ void J2DWindow::setTevMode(JUTTexture* param_0, JUtility::TColor param_1,
|
||||
GXSetNumTevStages(2);
|
||||
}
|
||||
GXSetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
}
|
||||
|
||||
/* 802FBE60-802FBEDC 2F67A0 007C+00 1/0 0/0 0/0 .text getFrameTexture__9J2DWindowCFUcUc
|
||||
@@ -676,4 +676,4 @@ bool J2DWindow::isUsed(ResFONT const* param_0) {
|
||||
/* 802FC04C-802FC050 2F698C 0004+00 1/0 0/0 0/0 .text rewriteAlpha__9J2DWindowFv */
|
||||
void J2DWindow::rewriteAlpha() {
|
||||
/* empty function */
|
||||
}
|
||||
}
|
||||
|
||||
@@ -552,9 +552,9 @@ void J3DSkinDeform::deformVtxPos_S16(J3DVertexBuffer* param_0, J3DMtxBuffer* par
|
||||
void* transformedVtxPos = param_0->getTransformedVtxPos(0);
|
||||
for (int i = 0; i < vtxNum; i++) {
|
||||
Mtx* anmMtx = anmMtxs[jointTree->getDrawMtxFlag(mPosData[i])];
|
||||
J3DPSMulMtxVec(anmMtx[jointTree->getDrawMtxIndex(mPosData[i])], ((SVec*)currentVtxPos) + i, ((SVec*)transformedVtxPos) + i);
|
||||
J3DPSMulMtxVec(anmMtx[jointTree->getDrawMtxIndex(mPosData[i])], ((S16Vec*)currentVtxPos) + i, ((S16Vec*)transformedVtxPos) + i);
|
||||
}
|
||||
DCStoreRange(param_0->getTransformedVtxPos(0), param_0->getVertexData()->getVtxNum() * sizeof(SVec));
|
||||
DCStoreRange(param_0->getTransformedVtxPos(0), param_0->getVertexData()->getVtxNum() * sizeof(S16Vec));
|
||||
param_0->setCurrentVtxPos(transformedVtxPos);
|
||||
}
|
||||
|
||||
@@ -584,9 +584,9 @@ void J3DSkinDeform::deformVtxNrm_S16(J3DVertexBuffer* param_0) const {
|
||||
void* currentVtxNrm = param_0->getCurrentVtxNrm();
|
||||
void* transformedVtxNrm = param_0->getTransformedVtxNrm(0);
|
||||
for (int i = 0; i < nrmNum; i++) {
|
||||
J3DPSMulMtxVec(mNrmMtx[mNrmData[i]], ((SVec*)currentVtxNrm) + i, ((SVec*)transformedVtxNrm) + i);
|
||||
J3DPSMulMtxVec(mNrmMtx[mNrmData[i]], ((S16Vec*)currentVtxNrm) + i, ((S16Vec*)transformedVtxNrm) + i);
|
||||
}
|
||||
DCStoreRange(param_0->getTransformedVtxNrm(0), param_0->getVertexData()->getNrmNum() * sizeof(SVec));
|
||||
DCStoreRange(param_0->getTransformedVtxNrm(0), param_0->getVertexData()->getNrmNum() * sizeof(S16Vec));
|
||||
param_0->setCurrentVtxNrm(transformedVtxNrm);
|
||||
}
|
||||
|
||||
|
||||
@@ -96,89 +96,89 @@ void J3DGDSetVtxAttrFmtv(GXVtxFmt fmt, GXVtxAttrFmtList const* fmtList, bool par
|
||||
u32 tex7_cnt = GX_TEX_ST;
|
||||
u32 tex7_type = GX_F32;
|
||||
u32 tex7_shift = 0;
|
||||
for (; fmtList->mAttrib != GX_VA_NULL; fmtList++) {
|
||||
switch (fmtList->mAttrib) {
|
||||
for (; fmtList->attr != GX_VA_NULL; fmtList++) {
|
||||
switch (fmtList->attr) {
|
||||
case GX_VA_POS:
|
||||
pos_cnt = fmtList->mCompCnt;
|
||||
pos_type = fmtList->mCompType;
|
||||
pos_shift = fmtList->mCompShift;
|
||||
pos_cnt = fmtList->cnt;
|
||||
pos_type = fmtList->type;
|
||||
pos_shift = fmtList->frac;
|
||||
break;
|
||||
case GX_VA_NRM:
|
||||
case GX_VA_NBT:
|
||||
nrm_type = fmtList->mCompType;
|
||||
if (fmtList->mCompCnt == GX_NRM_NBT3) {
|
||||
nrm_type = fmtList->type;
|
||||
if (fmtList->cnt == GX_NRM_NBT3) {
|
||||
nrm_cnt = GX_NRM_NBT;
|
||||
local_34 = 1;
|
||||
} else {
|
||||
if (param_2) {
|
||||
nrm_cnt = GX_NRM_NBT;
|
||||
} else {
|
||||
nrm_cnt = fmtList->mCompCnt;
|
||||
nrm_cnt = fmtList->cnt;
|
||||
}
|
||||
local_34 = 0;
|
||||
}
|
||||
break;
|
||||
case GX_VA_CLR0:
|
||||
clr0_cnt = fmtList->mCompCnt;
|
||||
clr0_type = fmtList->mCompType;
|
||||
clr0_cnt = fmtList->cnt;
|
||||
clr0_type = fmtList->type;
|
||||
break;
|
||||
case GX_VA_CLR1:
|
||||
clr1_cnt = fmtList->mCompCnt;
|
||||
clr1_type = fmtList->mCompType;
|
||||
clr1_cnt = fmtList->cnt;
|
||||
clr1_type = fmtList->type;
|
||||
break;
|
||||
case GX_VA_TEX0:
|
||||
tex0_cnt = fmtList->mCompCnt;
|
||||
tex0_type = fmtList->mCompType;
|
||||
tex0_shift = fmtList->mCompShift;
|
||||
tex0_cnt = fmtList->cnt;
|
||||
tex0_type = fmtList->type;
|
||||
tex0_shift = fmtList->frac;
|
||||
break;
|
||||
case GX_VA_TEX1:
|
||||
tex1_cnt = fmtList->mCompCnt;
|
||||
tex1_type = fmtList->mCompType;
|
||||
tex1_shift = fmtList->mCompShift;
|
||||
tex1_cnt = fmtList->cnt;
|
||||
tex1_type = fmtList->type;
|
||||
tex1_shift = fmtList->frac;
|
||||
break;
|
||||
case GX_VA_TEX2:
|
||||
tex2_cnt = fmtList->mCompCnt;
|
||||
tex2_type = fmtList->mCompType;
|
||||
tex2_shift = fmtList->mCompShift;
|
||||
tex2_cnt = fmtList->cnt;
|
||||
tex2_type = fmtList->type;
|
||||
tex2_shift = fmtList->frac;
|
||||
break;
|
||||
case GX_VA_TEX3:
|
||||
tex3_cnt = fmtList->mCompCnt;
|
||||
tex3_type = fmtList->mCompType;
|
||||
tex3_shift = fmtList->mCompShift;
|
||||
tex3_cnt = fmtList->cnt;
|
||||
tex3_type = fmtList->type;
|
||||
tex3_shift = fmtList->frac;
|
||||
break;
|
||||
case GX_VA_TEX4:
|
||||
tex4_cnt = fmtList->mCompCnt;
|
||||
tex4_type = fmtList->mCompType;
|
||||
tex4_shift = fmtList->mCompShift;
|
||||
tex4_cnt = fmtList->cnt;
|
||||
tex4_type = fmtList->type;
|
||||
tex4_shift = fmtList->frac;
|
||||
break;
|
||||
case GX_VA_TEX5:
|
||||
tex5_cnt = fmtList->mCompCnt;
|
||||
tex5_type = fmtList->mCompType;
|
||||
tex5_shift = fmtList->mCompShift;
|
||||
tex5_cnt = fmtList->cnt;
|
||||
tex5_type = fmtList->type;
|
||||
tex5_shift = fmtList->frac;
|
||||
break;
|
||||
case GX_VA_TEX6:
|
||||
tex6_cnt = fmtList->mCompCnt;
|
||||
tex6_type = fmtList->mCompType;
|
||||
tex6_shift = fmtList->mCompShift;
|
||||
tex6_cnt = fmtList->cnt;
|
||||
tex6_type = fmtList->type;
|
||||
tex6_shift = fmtList->frac;
|
||||
break;
|
||||
case GX_VA_TEX7:
|
||||
tex7_cnt = fmtList->mCompCnt;
|
||||
tex7_type = fmtList->mCompType;
|
||||
tex7_shift = fmtList->mCompShift;
|
||||
tex7_cnt = fmtList->cnt;
|
||||
tex7_type = fmtList->type;
|
||||
tex7_shift = fmtList->frac;
|
||||
break;
|
||||
}
|
||||
}
|
||||
GDOverflowCheck(0x12);
|
||||
J3DGDWriteCPCmd(GX_CP_REG_VAT_GRP0 + fmt,
|
||||
J3DGDWriteCPCmd(CP_REG_VAT_GRP0_ID + fmt,
|
||||
pos_cnt | pos_type << 1 | pos_shift << 4 | nrm_cnt << 9 | nrm_type << 0xa |
|
||||
clr0_cnt << 0xd | clr0_type << 0xe | clr1_cnt << 0x11 | clr1_type << 0x12 |
|
||||
tex0_cnt << 0x15 | tex0_type << 0x16 | tex0_shift << 0x19 | 0x40000000 |
|
||||
local_34 << 0x1f);
|
||||
J3DGDWriteCPCmd(GX_CP_REG_VAT_GRP1 + fmt,
|
||||
J3DGDWriteCPCmd(CP_REG_VAT_GRP1_ID + fmt,
|
||||
tex1_cnt | tex1_type << 1 | tex1_shift << 4 | tex2_cnt << 9 | tex2_type << 0xa |
|
||||
tex2_shift << 0xd | tex3_cnt << 0x12 | tex3_type << 0x13 |
|
||||
tex3_shift << 0x16 | tex4_cnt << 0x1b | tex4_type << 0x1c | 0x80000000);
|
||||
J3DGDWriteCPCmd(GX_CP_REG_VAT_GRP2 + fmt,
|
||||
J3DGDWriteCPCmd(CP_REG_VAT_GRP2_ID + fmt,
|
||||
tex4_shift | tex5_cnt << 5 | tex5_type << 6 | tex5_shift << 9 |
|
||||
tex6_cnt << 0xe | tex6_type << 0xf | tex6_shift << 0x12 | tex7_cnt << 0x17 |
|
||||
tex7_type << 0x18 | tex7_shift << 0x1b);
|
||||
@@ -482,14 +482,14 @@ void J3DGDSetIndTexOrder(u32 count, GXTexCoordID coord0, GXTexMapID map0, GXTexC
|
||||
void J3DGDSetTevOrder(GXTevStageID stage, GXTexCoordID coord0, GXTexMapID map0,
|
||||
GXChannelID channel0, GXTexCoordID coord1, GXTexMapID map1,
|
||||
GXChannelID channel1) {
|
||||
coord0 = coord0 >= GX_MAXCOORD ? GX_TEXCOORD0 : coord0;
|
||||
coord1 = coord1 >= GX_MAXCOORD ? GX_TEXCOORD0 : coord1;
|
||||
coord0 = coord0 >= GX_MAX_TEXCOORD ? GX_TEXCOORD0 : coord0;
|
||||
coord1 = coord1 >= GX_MAX_TEXCOORD ? GX_TEXCOORD0 : coord1;
|
||||
GDOverflowCheck(5);
|
||||
static u8 c2r[] = {0, 1, 0, 1, 0, 1, 7, 5, 6, 0, 0, 0, 0, 0, 0, 7};
|
||||
J3DGDWriteBPCmd((map0 & 7) | coord0 << 3 |
|
||||
(map0 != GX_TEXMAP_NULL && !(map0 & GX_TEXMAP_DISABLE)) << 6 |
|
||||
(map0 != GX_TEXMAP_NULL && !(map0 & GX_TEX_DISABLE)) << 6 |
|
||||
c2r[channel0 & 0xf] << 7 | (map1 & 7) << 0xc | coord1 << 0xf |
|
||||
(map1 != GX_TEXMAP_NULL && !(map1 & GX_TEXMAP_DISABLE)) << 0x12 |
|
||||
(map1 != GX_TEXMAP_NULL && !(map1 & GX_TEX_DISABLE)) << 0x12 |
|
||||
c2r[channel1 & 0xf] << 0x13 | (stage / 2 + GX_BP_REG_RAS1_TREF0) << 0x18);
|
||||
}
|
||||
|
||||
@@ -552,8 +552,8 @@ void J3DGDSetFog(GXFogType fogType, f32 param_1, f32 param_2, f32 nearZ, f32 far
|
||||
void J3DGDSetFogRangeAdj(u8 param_0, u16 param_1, GXFogAdjTable* table) {
|
||||
if (param_0 != 0) {
|
||||
for (int i = 0; i < 0xa; i += 2) {
|
||||
J3DGDWriteBPCmd((i / 2 + GX_BP_REG_FOGRANGEK0) << 0x18 | table->fogVals[i + 1] << 0xc |
|
||||
table->fogVals[i]);
|
||||
J3DGDWriteBPCmd((i / 2 + GX_BP_REG_FOGRANGEK0) << 0x18 | table->r[i + 1] << 0xc |
|
||||
table->r[i]);
|
||||
}
|
||||
}
|
||||
u32 cmd = GX_BP_REG_FOGRANGE << 0x18 | (param_1 + 0x156) | param_0 << 0xa;
|
||||
|
||||
@@ -10,6 +10,7 @@
|
||||
#include "dol2asm.h"
|
||||
#include "dolphin/os.h"
|
||||
#include "string.h"
|
||||
#include "global.h"
|
||||
|
||||
inline void loadMatColors(const J3DGXColor* color) {
|
||||
J3DGDWriteXFCmdHdr(0x100C, 2);
|
||||
@@ -408,25 +409,25 @@ void J3DColorBlockLightOff::patch() {
|
||||
/* 80318F00-803190AC 313840 01AC+00 2/0 0/0 0/0 .text patchMatColor__21J3DColorBlockLightOffFv */
|
||||
void J3DColorBlockLightOff::patchMatColor() {
|
||||
GDSetCurrOffset(mMatColorOffset);
|
||||
u8* start = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
GDOverflowCheck(SizeOfLoadMatColors);
|
||||
loadMatColors(mMatColor);
|
||||
u8* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, end - start);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 803190AC-803194E8 3139EC 043C+00 2/0 0/0 0/0 .text patchLight__21J3DColorBlockLightOffFv */
|
||||
void J3DColorBlockLightOff::patchLight() {
|
||||
GDSetCurrOffset(mColorChanOffset);
|
||||
u8* start = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
GDOverflowCheck(SizeOfLoadColorChans);
|
||||
J3DGDWriteXFCmdHdr(0x100e, 4);
|
||||
mColorChan[0].load();
|
||||
mColorChan[1].load();
|
||||
mColorChan[2].load();
|
||||
mColorChan[3].load();
|
||||
u8* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, end - start);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 803194E8-80319534 313E28 004C+00 1/0 0/0 0/0 .text patch__20J3DColorBlockLightOnFv */
|
||||
@@ -438,17 +439,17 @@ void J3DColorBlockLightOn::patch() {
|
||||
/* 80319534-803196E0 313E74 01AC+00 1/0 0/0 0/0 .text patchMatColor__20J3DColorBlockLightOnFv */
|
||||
void J3DColorBlockLightOn::patchMatColor() {
|
||||
GDSetCurrOffset(mMatColorOffset);
|
||||
u8* start = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
GDOverflowCheck(SizeOfLoadMatColors);
|
||||
loadMatColors(mMatColor);
|
||||
u8* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, end - start);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 803196E0-80319B4C 314020 046C+00 1/0 0/0 0/0 .text patchLight__20J3DColorBlockLightOnFv */
|
||||
void J3DColorBlockLightOn::patchLight() {
|
||||
GDSetCurrOffset(mColorChanOffset);
|
||||
u8* start = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
GDOverflowCheck(SizeOfLoadColorChans);
|
||||
J3DGDWriteXFCmdHdr(0x100e, 4);
|
||||
mColorChan[0].load();
|
||||
@@ -460,8 +461,8 @@ void J3DColorBlockLightOn::patchLight() {
|
||||
mLight[i]->load(i);
|
||||
}
|
||||
}
|
||||
u8* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, end - start);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 80319B4C-80319BB4 31448C 0068+00 2/0 0/0 0/0 .text diff__21J3DColorBlockLightOffFUl */
|
||||
@@ -563,40 +564,40 @@ void J3DTexGenBlockBasic::load() {
|
||||
/* 8031AA88-8031AB18 3153C8 0090+00 1/0 0/0 0/0 .text patch__21J3DTexGenBlockPatchedFv */
|
||||
void J3DTexGenBlockPatched::patch() {
|
||||
GDSetCurrOffset(mTexMtxOffset);
|
||||
u8* start = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
for (u32 i = 0; i < 8; i++) {
|
||||
if (mTexMtx[i]) {
|
||||
mTexMtx[i]->load(i);
|
||||
}
|
||||
}
|
||||
u8* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, end - start);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 8031AB18-8031ABC0 315458 00A8+00 1/0 0/0 0/0 .text patch__15J3DTexGenBlock4Fv */
|
||||
void J3DTexGenBlock4::patch() {
|
||||
GDSetCurrOffset(mTexMtxOffset);
|
||||
u8* start = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
for (u32 i = 0; i < 4; i++) {
|
||||
if (mTexMtx[i] && mTexCoord[i].getTexGenMtx() != GX_IDENTITY) {
|
||||
mTexMtx[i]->load(i);
|
||||
}
|
||||
}
|
||||
u8* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, end - start);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 8031ABC0-8031AC68 315500 00A8+00 1/0 0/0 0/0 .text patch__19J3DTexGenBlockBasicFv */
|
||||
void J3DTexGenBlockBasic::patch() {
|
||||
GDSetCurrOffset(mTexMtxOffset);
|
||||
u8* start = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
for (u32 i = 0; i < 8; i++) {
|
||||
if (mTexMtx[i] && mTexCoord[i].getTexGenMtx() != GX_IDENTITY) {
|
||||
mTexMtx[i]->load(i);
|
||||
}
|
||||
}
|
||||
u8* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, end - start);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 8031AC68-8031ACD0 3155A8 0068+00 3/0 0/0 0/0 .text diff__21J3DTexGenBlockPatchedFUl */
|
||||
@@ -693,8 +694,8 @@ void J3DTevBlock2::load() {
|
||||
GXTevKAlphaSel(mTevKAlphaSel[0]),
|
||||
GXTevKColorSel(mTevKColorSel[1]),
|
||||
GXTevKAlphaSel(mTevKAlphaSel[1]),
|
||||
GXTevColor(mTevSwapModeTable[i / 4].getR()),
|
||||
GXTevColor(mTevSwapModeTable[i / 4].getG())
|
||||
GXTevColorChan(mTevSwapModeTable[i / 4].getR()),
|
||||
GXTevColorChan(mTevSwapModeTable[i / 4].getG())
|
||||
);
|
||||
J3DGDSetTevKonstantSel_SwapModeTable(
|
||||
GXTevStageID(i + 2),
|
||||
@@ -702,8 +703,8 @@ void J3DTevBlock2::load() {
|
||||
GXTevKAlphaSel(mTevKAlphaSel[0]),
|
||||
GXTevKColorSel(mTevKColorSel[1]),
|
||||
GXTevKAlphaSel(mTevKAlphaSel[1]),
|
||||
GXTevColor(mTevSwapModeTable[i / 4].getB()),
|
||||
GXTevColor(mTevSwapModeTable[i / 4].getA())
|
||||
GXTevColorChan(mTevSwapModeTable[i / 4].getB()),
|
||||
GXTevColorChan(mTevSwapModeTable[i / 4].getA())
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -754,8 +755,8 @@ void J3DTevBlock4::load() {
|
||||
GXTevKAlphaSel(mTevKAlphaSel[0]),
|
||||
GXTevKColorSel(mTevKColorSel[1]),
|
||||
GXTevKAlphaSel(mTevKAlphaSel[1]),
|
||||
GXTevColor(mTevSwapModeTable[i / 4].getR()),
|
||||
GXTevColor(mTevSwapModeTable[i / 4].getG())
|
||||
GXTevColorChan(mTevSwapModeTable[i / 4].getR()),
|
||||
GXTevColorChan(mTevSwapModeTable[i / 4].getG())
|
||||
);
|
||||
J3DGDSetTevKonstantSel_SwapModeTable(
|
||||
GXTevStageID(i + 2),
|
||||
@@ -763,8 +764,8 @@ void J3DTevBlock4::load() {
|
||||
GXTevKAlphaSel(mTevKAlphaSel[2]),
|
||||
GXTevKColorSel(mTevKColorSel[3]),
|
||||
GXTevKAlphaSel(mTevKAlphaSel[3]),
|
||||
GXTevColor(mTevSwapModeTable[i / 4].getB()),
|
||||
GXTevColor(mTevSwapModeTable[i / 4].getA())
|
||||
GXTevColorChan(mTevSwapModeTable[i / 4].getB()),
|
||||
GXTevColorChan(mTevSwapModeTable[i / 4].getA())
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -815,8 +816,8 @@ void J3DTevBlock16::load() {
|
||||
GXTevKAlphaSel(mTevKAlphaSel[i]),
|
||||
GXTevKColorSel(mTevKColorSel[i + 1]),
|
||||
GXTevKAlphaSel(mTevKAlphaSel[i + 1]),
|
||||
GXTevColor(mTevSwapModeTable[i / 4].getR()),
|
||||
GXTevColor(mTevSwapModeTable[i / 4].getG())
|
||||
GXTevColorChan(mTevSwapModeTable[i / 4].getR()),
|
||||
GXTevColorChan(mTevSwapModeTable[i / 4].getG())
|
||||
);
|
||||
J3DGDSetTevKonstantSel_SwapModeTable(
|
||||
GXTevStageID(i + 2),
|
||||
@@ -824,8 +825,8 @@ void J3DTevBlock16::load() {
|
||||
GXTevKAlphaSel(mTevKAlphaSel[i + 2]),
|
||||
GXTevKColorSel(mTevKColorSel[i + 3]),
|
||||
GXTevKAlphaSel(mTevKAlphaSel[i + 3]),
|
||||
GXTevColor(mTevSwapModeTable[i / 4].getB()),
|
||||
GXTevColor(mTevSwapModeTable[i / 4].getA())
|
||||
GXTevColorChan(mTevSwapModeTable[i / 4].getB()),
|
||||
GXTevColorChan(mTevSwapModeTable[i / 4].getA())
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -835,7 +836,7 @@ void J3DTevBlock16::load() {
|
||||
*/
|
||||
void J3DTevBlockPatched::patchTexNo() {
|
||||
GDSetCurrOffset(mTexNoOffset);
|
||||
u8* start = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
|
||||
for (u32 i = 0; i < 8; i++) {
|
||||
if (mTexNo[i] != 0xffff) {
|
||||
@@ -843,15 +844,15 @@ void J3DTevBlockPatched::patchTexNo() {
|
||||
}
|
||||
}
|
||||
|
||||
u8* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, end - start);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 8031BFE0-8031C0AC 316920 00CC+00 1/0 0/0 0/0 .text patchTevReg__18J3DTevBlockPatchedFv
|
||||
*/
|
||||
void J3DTevBlockPatched::patchTevReg() {
|
||||
GDSetCurrOffset(mTevRegOffset);
|
||||
u8 *pStart = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
|
||||
for (u32 i = 0; i < ARRAY_SIZE(mTevColor) - 1; i++) {
|
||||
J3DGDSetTevColorS10((GXTevRegID)(i + 1), mTevColor[i]);
|
||||
@@ -860,15 +861,15 @@ void J3DTevBlockPatched::patchTevReg() {
|
||||
J3DGDSetTevKColor((GXTevKColorID)i, mTevKColor[i]);
|
||||
}
|
||||
|
||||
u8 *pEnd = GDGetCurrPointer();
|
||||
DCStoreRange(pStart, pEnd - pStart);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 8031C0AC-8031C228 3169EC 017C+00 1/0 0/0 0/0 .text
|
||||
* patchTexNoAndTexCoordScale__18J3DTevBlockPatchedFv */
|
||||
void J3DTevBlockPatched::patchTexNoAndTexCoordScale() {
|
||||
GDSetCurrOffset(mTexNoOffset);
|
||||
u8 *start = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
|
||||
u8 tevStageNum = mTevStageNum;
|
||||
for (u32 i = 0; i < 8; i++) {
|
||||
@@ -897,8 +898,8 @@ void J3DTevBlockPatched::patchTexNoAndTexCoordScale() {
|
||||
);
|
||||
}
|
||||
|
||||
u8 *end = GDGetCurrPointer();
|
||||
DCStoreRange(start, end - start);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 8031C228-8031C274 316B68 004C+00 1/0 0/0 0/0 .text patch__18J3DTevBlockPatchedFv */
|
||||
@@ -910,14 +911,14 @@ void J3DTevBlockPatched::patch() {
|
||||
/* 8031C274-8031C2E4 316BB4 0070+00 1/0 0/0 0/0 .text patchTexNo__12J3DTevBlock1Fv */
|
||||
void J3DTevBlock1::patchTexNo() {
|
||||
GDSetCurrOffset(mTexNoOffset);
|
||||
u8 *pStart = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
|
||||
if (mTexNo[0] != 0xFFFF) {
|
||||
loadTexNo(0, mTexNo[0]);
|
||||
}
|
||||
|
||||
u8 *pEnd = GDGetCurrPointer();
|
||||
DCStoreRange(pStart, pEnd - pStart);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 8031C2E4-8031C2E8 316C24 0004+00 1/0 0/0 0/0 .text patchTevReg__12J3DTevBlock1Fv */
|
||||
@@ -928,7 +929,7 @@ void J3DTevBlock1::patchTevReg() {
|
||||
*/
|
||||
void J3DTevBlock1::patchTexNoAndTexCoordScale() {
|
||||
GDSetCurrOffset(mTexNoOffset);
|
||||
u8 *start = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
|
||||
if (mTexNo[0] != 0xffff) {
|
||||
loadTexNo(0, mTexNo[0]);
|
||||
@@ -948,8 +949,8 @@ void J3DTevBlock1::patchTexNoAndTexCoordScale() {
|
||||
J3DSys::sTexCoordScaleTable[mTevOrder[0].getTevOrderInfo().mTexMap & 7]
|
||||
);
|
||||
|
||||
u8 *end = GDGetCurrPointer();
|
||||
DCStoreRange(start, end - start);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 8031C3CC-8031C3F8 316D0C 002C+00 1/0 0/0 0/0 .text patch__12J3DTevBlock1Fv */
|
||||
@@ -960,7 +961,7 @@ void J3DTevBlock1::patch() {
|
||||
/* 8031C3F8-8031C48C 316D38 0094+00 1/0 0/0 0/0 .text patchTexNo__12J3DTevBlock2Fv */
|
||||
void J3DTevBlock2::patchTexNo() {
|
||||
GDSetCurrOffset(mTexNoOffset);
|
||||
u8 *start = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
|
||||
for (u32 i = 0; i < 2; i++) {
|
||||
if (mTexNo[i] != 0xffff) {
|
||||
@@ -968,14 +969,14 @@ void J3DTevBlock2::patchTexNo() {
|
||||
}
|
||||
}
|
||||
|
||||
u8 *end = GDGetCurrPointer();
|
||||
DCStoreRange(start, end - start);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 8031C48C-8031C558 316DCC 00CC+00 1/0 0/0 0/0 .text patchTevReg__12J3DTevBlock2Fv */
|
||||
void J3DTevBlock2::patchTevReg() {
|
||||
GDSetCurrOffset(mTevRegOffset);
|
||||
u8 *pStart = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
|
||||
for (u32 i = 0; i < ARRAY_SIZE(mTevColor) - 1; i++) {
|
||||
J3DGDSetTevColorS10((GXTevRegID)(i + 1), mTevColor[i]);
|
||||
@@ -984,15 +985,15 @@ void J3DTevBlock2::patchTevReg() {
|
||||
J3DGDSetTevKColor((GXTevKColorID)i, mTevKColor[i]);
|
||||
}
|
||||
|
||||
u8 *pEnd = GDGetCurrPointer();
|
||||
DCStoreRange(pStart, pEnd - pStart);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 8031C558-8031C6A8 316E98 0150+00 1/0 0/0 0/0 .text patchTexNoAndTexCoordScale__12J3DTevBlock2Fv
|
||||
*/
|
||||
void J3DTevBlock2::patchTexNoAndTexCoordScale() {
|
||||
GDSetCurrOffset(mTexNoOffset);
|
||||
u8 *start = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
|
||||
for (u32 i = 0; i < 2; i++) {
|
||||
if (mTexNo[i] != 0xffff) {
|
||||
@@ -1018,8 +1019,8 @@ void J3DTevBlock2::patchTexNoAndTexCoordScale() {
|
||||
J3DSys::sTexCoordScaleTable[mTevOrder[1].getTevOrderInfo().mTexMap & 7]
|
||||
);
|
||||
|
||||
u8 *end = GDGetCurrPointer();
|
||||
DCStoreRange(start, end - start);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 8031C6A8-8031C6F4 316FE8 004C+00 1/0 0/0 0/0 .text patch__12J3DTevBlock2Fv */
|
||||
@@ -1031,7 +1032,7 @@ void J3DTevBlock2::patch() {
|
||||
/* 8031C6F4-8031C788 317034 0094+00 1/0 0/0 0/0 .text patchTexNo__12J3DTevBlock4Fv */
|
||||
void J3DTevBlock4::patchTexNo() {
|
||||
GDSetCurrOffset(mTexNoOffset);
|
||||
u8 *start = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
|
||||
for (u32 i = 0; i < 4; i++) {
|
||||
if (mTexNo[i] != 0xffff) {
|
||||
@@ -1039,14 +1040,14 @@ void J3DTevBlock4::patchTexNo() {
|
||||
}
|
||||
}
|
||||
|
||||
u8 *end = GDGetCurrPointer();
|
||||
DCStoreRange(start, end - start);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 8031C788-8031C854 3170C8 00CC+00 1/0 0/0 0/0 .text patchTevReg__12J3DTevBlock4Fv */
|
||||
void J3DTevBlock4::patchTevReg() {
|
||||
GDSetCurrOffset(mTevRegOffset);
|
||||
u8 *pStart = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
|
||||
for (u32 i = 0; i < ARRAY_SIZE(mTevColor) - 1; i++) {
|
||||
J3DGDSetTevColorS10((GXTevRegID)(i + 1), mTevColor[i]);
|
||||
@@ -1055,15 +1056,15 @@ void J3DTevBlock4::patchTevReg() {
|
||||
J3DGDSetTevKColor((GXTevKColorID)i, mTevKColor[i]);
|
||||
}
|
||||
|
||||
u8 *pEnd = GDGetCurrPointer();
|
||||
DCStoreRange(pStart, pEnd - pStart);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 8031C854-8031C9D0 317194 017C+00 1/0 0/0 0/0 .text patchTexNoAndTexCoordScale__12J3DTevBlock4Fv
|
||||
*/
|
||||
void J3DTevBlock4::patchTexNoAndTexCoordScale() {
|
||||
GDSetCurrOffset(mTexNoOffset);
|
||||
u8 *start = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
|
||||
u8 tevStageNum = mTevStageNum;
|
||||
for (u32 i = 0; i < 4; i++) {
|
||||
@@ -1092,8 +1093,8 @@ void J3DTevBlock4::patchTexNoAndTexCoordScale() {
|
||||
);
|
||||
}
|
||||
|
||||
u8 *end = GDGetCurrPointer();
|
||||
DCStoreRange(start, end - start);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
/* 8031C9D0-8031CA1C 317310 004C+00 1/0 0/0 0/0 .text patch__12J3DTevBlock4Fv */
|
||||
void J3DTevBlock4::patch() {
|
||||
@@ -1104,7 +1105,7 @@ void J3DTevBlock4::patch() {
|
||||
/* 8031CA1C-8031CAB0 31735C 0094+00 1/0 0/0 0/0 .text patchTexNo__13J3DTevBlock16Fv */
|
||||
void J3DTevBlock16::patchTexNo() {
|
||||
GDSetCurrOffset(mTexNoOffset);
|
||||
u8 *start = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
|
||||
for (u32 i = 0; i < 8; i++) {
|
||||
if (mTexNo[i] != 0xffff) {
|
||||
@@ -1112,14 +1113,14 @@ void J3DTevBlock16::patchTexNo() {
|
||||
}
|
||||
}
|
||||
|
||||
u8 *end = GDGetCurrPointer();
|
||||
DCStoreRange(start, end - start);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 8031CAB0-8031CB7C 3173F0 00CC+00 1/0 0/0 0/0 .text patchTevReg__13J3DTevBlock16Fv */
|
||||
void J3DTevBlock16::patchTevReg() {
|
||||
GDSetCurrOffset(mTevRegOffset);
|
||||
u8 *pStart = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
|
||||
for (u32 i = 0; i < ARRAY_SIZE(mTevColor) - 1; i++) {
|
||||
J3DGDSetTevColorS10((GXTevRegID)(i + 1), mTevColor[i]);
|
||||
@@ -1128,15 +1129,15 @@ void J3DTevBlock16::patchTevReg() {
|
||||
J3DGDSetTevKColor((GXTevKColorID)i, mTevKColor[i]);
|
||||
}
|
||||
|
||||
u8 *pEnd = GDGetCurrPointer();
|
||||
DCStoreRange(pStart, pEnd - pStart);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 8031CB7C-8031CCF8 3174BC 017C+00 1/0 0/0 0/0 .text
|
||||
* patchTexNoAndTexCoordScale__13J3DTevBlock16Fv */
|
||||
void J3DTevBlock16::patchTexNoAndTexCoordScale() {
|
||||
GDSetCurrOffset(mTexNoOffset);
|
||||
u8 *start = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
|
||||
u8 tevStageNum = mTevStageNum;
|
||||
for (u32 i = 0; i < 8; i++) {
|
||||
@@ -1165,8 +1166,8 @@ void J3DTevBlock16::patchTexNoAndTexCoordScale() {
|
||||
);
|
||||
}
|
||||
|
||||
u8 *end = GDGetCurrPointer();
|
||||
DCStoreRange(start, end - start);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
|
||||
@@ -1428,7 +1429,7 @@ void J3DTevBlock16::diffTexCoordScale() {
|
||||
/* 8031DED0-8031DFB4 318810 00E4+00 1/0 0/0 0/0 .text ptrToIndex__13J3DTevBlock16Fv */
|
||||
void J3DTevBlock16::ptrToIndex() {
|
||||
GDSetCurrOffset(mTexNoOffset);
|
||||
u8* pStart = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
|
||||
u32 offs = 0;
|
||||
for (u32 i = 0; i < 8; i++) {
|
||||
@@ -1442,15 +1443,15 @@ void J3DTevBlock16::ptrToIndex() {
|
||||
}
|
||||
}
|
||||
|
||||
u8 *pEnd = GDGetCurrPointer();
|
||||
DCStoreRange(pStart, pEnd - pStart);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 8031DFB4-8031E098 3188F4 00E4+00 1/0 0/0 0/0 .text ptrToIndex__18J3DTevBlockPatchedFv
|
||||
*/
|
||||
void J3DTevBlockPatched::ptrToIndex() {
|
||||
GDSetCurrOffset(mTexNoOffset);
|
||||
u8* pStart = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
|
||||
u32 offs = 0;
|
||||
for (u32 i = 0; i < 8; i++) {
|
||||
@@ -1464,17 +1465,17 @@ void J3DTevBlockPatched::ptrToIndex() {
|
||||
}
|
||||
}
|
||||
|
||||
u8 *pEnd = GDGetCurrPointer();
|
||||
DCStoreRange(pStart, pEnd - pStart);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 8031E098-8031E12C 3189D8 0094+00 5/5 1/1 0/0 .text indexToPtr_private__11J3DTevBlockFUl */
|
||||
void J3DTevBlock::indexToPtr_private(u32 offs) {
|
||||
GDSetCurrOffset(offs);
|
||||
u8* pStart = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
|
||||
for (u32 i = 0; ; i++) {
|
||||
u8* pDL = GDGetCurrPointer();
|
||||
void* pDL = GDGetCurrPointer();
|
||||
if (!isTexNoReg(pDL)) {
|
||||
break;
|
||||
}
|
||||
@@ -1483,8 +1484,8 @@ void J3DTevBlock::indexToPtr_private(u32 offs) {
|
||||
loadTexNo(i, texNoReg);
|
||||
}
|
||||
|
||||
u8 *pEnd = GDGetCurrPointer();
|
||||
DCStoreRange(pStart, pEnd - pStart);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 8031E12C-8031E328 318A6C 01FC+00 1/0 0/0 0/0 .text load__15J3DIndBlockFullFv */
|
||||
@@ -1570,7 +1571,7 @@ void J3DPEBlockTexEdge::load() {
|
||||
void J3DPEBlockXlu::load() {
|
||||
GDOverflowCheck(0x1e);
|
||||
J3DGDSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_AND,GX_ALWAYS, 0);
|
||||
J3DGDSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_COPY);
|
||||
J3DGDSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_COPY);
|
||||
J3DGDSetZMode(1, GX_LEQUAL, 0);
|
||||
J3DGDSetZCompLoc(1);
|
||||
}
|
||||
@@ -1611,10 +1612,10 @@ void J3DPEBlockFull::load() {
|
||||
void J3DPEBlockFull::patch() {
|
||||
GDSetCurrOffset(mFogOffset);
|
||||
GDOverflowCheck(0x37);
|
||||
u8* start = GDGetCurrPointer();
|
||||
void* start = GDGetCurrPointer();
|
||||
mFog.load();
|
||||
u8* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, end - start);
|
||||
void* end = GDGetCurrPointer();
|
||||
DCStoreRange(start, (u32)end - (u32)start);
|
||||
}
|
||||
|
||||
/* 8031F940-8031F9B8 31A280 0078+00 1/0 0/0 0/0 .text diffFog__14J3DPEBlockFullFv */
|
||||
|
||||
@@ -3,9 +3,10 @@
|
||||
#include "JSystem/J3DGraphBase/J3DDrawBuffer.h"
|
||||
#include "JSystem/J3DGraphBase/J3DMaterial.h"
|
||||
#include "JSystem/JKernel/JKRHeap.h"
|
||||
#include "dolphin/os/OSCache.h"
|
||||
#include "dolphin/os/OSInterrupt.h"
|
||||
#include <dolphin/os.h>
|
||||
#include <dolphin/os.h>
|
||||
#include "string.h"
|
||||
#include "global.h"
|
||||
|
||||
J3DError J3DDisplayListObj::newDisplayList(u32 capacity) {
|
||||
mCapacity = ALIGN_NEXT(capacity, 0x20);
|
||||
@@ -400,4 +401,4 @@ void J3DPacket::draw() {}
|
||||
int J3DMatPacket::entry(J3DDrawBuffer* i_buffer) {
|
||||
sortFunc func = J3DDrawBuffer::sortFuncTable[i_buffer->mSortType];
|
||||
return (i_buffer->*func)(this);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -119,7 +119,7 @@ u32 J3DShape::countBumpMtxNum() const {
|
||||
|
||||
/* 80314E98-80314EB0 30F7D8 0018+00 1/1 0/0 0/0 .text J3DLoadCPCmd__FUcUl */
|
||||
void J3DLoadCPCmd(u8 cmd, u32 param) {
|
||||
GXWGFifo.u8 = GX_CMD_LOAD_CP_REG;
|
||||
GXWGFifo.u8 = GX_LOAD_CP_REG;
|
||||
GXWGFifo.u8 = cmd;
|
||||
GXWGFifo.u32 = param;
|
||||
}
|
||||
@@ -160,31 +160,31 @@ void J3DShape::makeVtxArrayCmd() {
|
||||
array[i] = 0;
|
||||
}
|
||||
|
||||
for (; vtxAttr->mAttrib != GX_VA_NULL; vtxAttr++) {
|
||||
switch (vtxAttr->mAttrib) {
|
||||
for (; vtxAttr->attr != GX_VA_NULL; vtxAttr++) {
|
||||
switch (vtxAttr->attr) {
|
||||
case GX_VA_POS: {
|
||||
if (vtxAttr->mCompType == GX_F32)
|
||||
stride[vtxAttr->mAttrib - GX_VA_POS] = 0x0C;
|
||||
if (vtxAttr->type == GX_F32)
|
||||
stride[vtxAttr->attr - GX_VA_POS] = 0x0C;
|
||||
else
|
||||
stride[vtxAttr->mAttrib - GX_VA_POS] = 0x06;
|
||||
array[vtxAttr->mAttrib - GX_VA_POS] = mVertexData->getVtxPosArray();
|
||||
mVertexData->setVtxPosFrac(vtxAttr->mCompShift);
|
||||
mVertexData->setVtxPosType((GXCompType)vtxAttr->mCompType);
|
||||
stride[vtxAttr->attr - GX_VA_POS] = 0x06;
|
||||
array[vtxAttr->attr - GX_VA_POS] = mVertexData->getVtxPosArray();
|
||||
mVertexData->setVtxPosFrac(vtxAttr->frac);
|
||||
mVertexData->setVtxPosType((GXCompType)vtxAttr->type);
|
||||
} break;
|
||||
case GX_VA_NRM: {
|
||||
if (vtxAttr->mCompType == GX_F32)
|
||||
stride[vtxAttr->mAttrib - GX_VA_POS] = 0x0C;
|
||||
if (vtxAttr->type == GX_F32)
|
||||
stride[vtxAttr->attr - GX_VA_POS] = 0x0C;
|
||||
else
|
||||
stride[vtxAttr->mAttrib - GX_VA_POS] = 0x06;
|
||||
array[vtxAttr->mAttrib - GX_VA_POS] = mVertexData->getVtxNrmArray();
|
||||
mVertexData->setVtxNrmFrac(vtxAttr->mCompShift);
|
||||
mVertexData->setVtxNrmType((GXCompType)vtxAttr->mCompType);
|
||||
stride[vtxAttr->attr - GX_VA_POS] = 0x06;
|
||||
array[vtxAttr->attr - GX_VA_POS] = mVertexData->getVtxNrmArray();
|
||||
mVertexData->setVtxNrmFrac(vtxAttr->frac);
|
||||
mVertexData->setVtxNrmType((GXCompType)vtxAttr->type);
|
||||
} break;
|
||||
case GX_VA_CLR0:
|
||||
case GX_VA_CLR1: {
|
||||
stride[vtxAttr->mAttrib - GX_VA_POS] = 0x04;
|
||||
array[vtxAttr->mAttrib - GX_VA_POS] =
|
||||
mVertexData->getVtxColorArray(vtxAttr->mAttrib - GX_VA_CLR0);
|
||||
stride[vtxAttr->attr - GX_VA_POS] = 0x04;
|
||||
array[vtxAttr->attr - GX_VA_POS] =
|
||||
mVertexData->getVtxColorArray(vtxAttr->attr - GX_VA_CLR0);
|
||||
} break;
|
||||
case GX_VA_TEX0:
|
||||
case GX_VA_TEX1:
|
||||
@@ -194,12 +194,12 @@ void J3DShape::makeVtxArrayCmd() {
|
||||
case GX_VA_TEX5:
|
||||
case GX_VA_TEX6:
|
||||
case GX_VA_TEX7: {
|
||||
if (vtxAttr->mCompType == GX_F32)
|
||||
stride[vtxAttr->mAttrib - GX_VA_POS] = 0x08;
|
||||
if (vtxAttr->type == GX_F32)
|
||||
stride[vtxAttr->attr - GX_VA_POS] = 0x08;
|
||||
else
|
||||
stride[vtxAttr->mAttrib - GX_VA_POS] = 0x04;
|
||||
array[vtxAttr->mAttrib - GX_VA_POS] =
|
||||
mVertexData->getVtxTexCoordArray(vtxAttr->mAttrib - GX_VA_TEX0);
|
||||
stride[vtxAttr->attr - GX_VA_POS] = 0x04;
|
||||
array[vtxAttr->attr - GX_VA_POS] =
|
||||
mVertexData->getVtxTexCoordArray(vtxAttr->attr - GX_VA_TEX0);
|
||||
} break;
|
||||
default:
|
||||
break;
|
||||
@@ -351,4 +351,4 @@ void J3DShape::simpleDrawCache() const {
|
||||
for (u16 n = getMtxGroupNum(), i = 0; i < n; i++)
|
||||
if (getShapeDraw(i) != NULL)
|
||||
getShapeDraw(i)->draw();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,7 +7,7 @@
|
||||
#include "JSystem/JKernel/JKRHeap.h"
|
||||
#include "string.h"
|
||||
#include "dolphin/gx.h"
|
||||
#include "dolphin/os/OSCache.h"
|
||||
#include <dolphin/os.h>
|
||||
#include "global.h"
|
||||
|
||||
//
|
||||
|
||||
@@ -31,9 +31,9 @@ void J3DShapeMtx::resetMtxLoadCache() {
|
||||
/* 803130E4-80313128 30DA24 0044+00 1/0 0/0 0/0 .text loadMtxIndx_PNGP__11J3DShapeMtxCFiUs */
|
||||
void J3DShapeMtx::loadMtxIndx_PNGP(int slot, u16 indx) const {
|
||||
// inlined J3DFifoLoadPosMtxIndx
|
||||
J3DFifoLoadIndx(GX_CMD_LOAD_INDX_A, indx, 0xB000 | ((u16)(slot * 0x0C)));
|
||||
J3DFifoLoadIndx(GX_LOAD_INDX_A, indx, 0xB000 | ((u16)(slot * 0x0C)));
|
||||
// inlined J3DFifoLoadNrmMtxIndx3x3
|
||||
J3DFifoLoadIndx(GX_CMD_LOAD_INDX_B, indx, 0x8000 | ((u16)((slot * 0x09) + 0x400)));
|
||||
J3DFifoLoadIndx(GX_LOAD_INDX_B, indx, 0x8000 | ((u16)((slot * 0x09) + 0x400)));
|
||||
}
|
||||
|
||||
/* 80313128-80313188 30DA68 0060+00 1/0 0/0 0/0 .text loadMtxIndx_PCPU__11J3DShapeMtxCFiUs */
|
||||
|
||||
@@ -61,7 +61,7 @@ J3DFogInfo& J3DFogInfo::operator=(J3DFogInfo const& param_0) {
|
||||
mFarZ = param_0.mFarZ;
|
||||
mColor = param_0.mColor;
|
||||
for (int i = 0; i < 10; i++) {
|
||||
mFogAdjTable.fogVals[i] = param_0.mFogAdjTable.fogVals[i];
|
||||
mFogAdjTable.r[i] = param_0.mFogAdjTable.r[i];
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
@@ -72,4 +72,4 @@ J3DNBTScaleInfo& J3DNBTScaleInfo::operator=(J3DNBTScaleInfo const& param_0) {
|
||||
mbHasScale = param_0.mbHasScale;
|
||||
mScale = param_0.mScale;
|
||||
return *this;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
#include "JSystem/J3DGraphBase/J3DSys.h"
|
||||
|
||||
#include "dol2asm.h"
|
||||
#include "dolphin/gx/GXPixel.h"
|
||||
#include <dolphin/gx.h>
|
||||
#include "dolphin/os.h"
|
||||
#include "dolphin/types.h"
|
||||
#include "global.h"
|
||||
@@ -84,12 +84,12 @@ J3DSys::J3DSys() {
|
||||
|
||||
/* 8030FEC0-8030FEE4 30A800 0024+00 0/0 1/1 0/0 .text loadPosMtxIndx__6J3DSysCFiUs */
|
||||
void J3DSys::loadPosMtxIndx(int addr, u16 indx) const {
|
||||
J3DFifoLoadIndx(GX_CMD_LOAD_INDX_A, indx, 0xB000 | ((u16)(addr * 0x0C)));
|
||||
J3DFifoLoadIndx(GX_LOAD_INDX_A, indx, 0xB000 | ((u16)(addr * 0x0C)));
|
||||
}
|
||||
|
||||
/* 8030FEE4-8030FF0C 30A824 0028+00 0/0 1/1 0/0 .text loadNrmMtxIndx__6J3DSysCFiUs */
|
||||
void J3DSys::loadNrmMtxIndx(int addr, u16 indx) const {
|
||||
J3DFifoLoadIndx(GX_CMD_LOAD_INDX_B, indx, 0x8000 | ((u16)((addr * 0x09) + 0x400)));
|
||||
J3DFifoLoadIndx(GX_LOAD_INDX_B, indx, 0x8000 | ((u16)((addr * 0x09) + 0x400)));
|
||||
}
|
||||
|
||||
/* 8030FF0C-803100BC 30A84C 01B0+00 1/1 0/0 0/0 .text setTexCacheRegion__6J3DSysF15_GXTexCacheSize
|
||||
@@ -149,7 +149,7 @@ void J3DSys::drawInit() {
|
||||
GXSetClipMode(GX_CLIP_ENABLE);
|
||||
GXSetColorUpdate(GX_TRUE);
|
||||
GXSetDither(GX_TRUE);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_NOOP);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_NOOP);
|
||||
GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_AND, GX_ALWAYS, 0);
|
||||
GXSetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
|
||||
GXSetZCompLoc(GX_TRUE);
|
||||
@@ -196,7 +196,7 @@ void J3DSys::drawInit() {
|
||||
|
||||
u8 i;
|
||||
for (i = 0; i < 3; i++)
|
||||
GXSetIndTexMtx((GXIndTexMtxID)(GX_ITM_0 + i), (f32*)indTexMtx, 1);
|
||||
GXSetIndTexMtx((GXIndTexMtxID)(GX_ITM_0 + i), indTexMtx, 1);
|
||||
|
||||
GXSetChanMatColor(GX_COLOR0A0, j3dDefaultColInfo);
|
||||
GXSetChanMatColor(GX_COLOR1A1, j3dDefaultColInfo);
|
||||
@@ -378,14 +378,14 @@ void J3DSys::reinitIndStages() {
|
||||
GXSetIndTexCoordScale(GX_INDTEXSTAGE1, GX_ITS_1, GX_ITS_1);
|
||||
GXSetIndTexCoordScale(GX_INDTEXSTAGE2, GX_ITS_1, GX_ITS_1);
|
||||
GXSetIndTexCoordScale(GX_INDTEXSTAGE3, GX_ITS_1, GX_ITS_1);
|
||||
GXSetIndTexMtx(GX_ITM_0, (f32*)IndMtx, 1);
|
||||
GXSetIndTexMtx(GX_ITM_1, (f32*)IndMtx, 1);
|
||||
GXSetIndTexMtx(GX_ITM_2, (f32*)IndMtx, 1);
|
||||
GXSetIndTexMtx(GX_ITM_0, IndMtx, 1);
|
||||
GXSetIndTexMtx(GX_ITM_1, IndMtx, 1);
|
||||
GXSetIndTexMtx(GX_ITM_2, IndMtx, 1);
|
||||
}
|
||||
|
||||
/* 80310E3C-80310ED0 30B77C 0094+00 1/1 0/0 0/0 .text reinitPixelProc__6J3DSysFv */
|
||||
void J3DSys::reinitPixelProc() {
|
||||
GXSetBlendMode(GX_BM_NONE, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_CLEAR);
|
||||
GXSetBlendMode(GX_BM_NONE, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
|
||||
GXSetColorUpdate(GX_TRUE);
|
||||
GXSetAlphaUpdate(GX_FALSE);
|
||||
GXSetDither(GX_TRUE);
|
||||
|
||||
@@ -7,6 +7,7 @@
|
||||
#include "JSystem/J3DGraphBase/J3DMatBlock.h"
|
||||
#include "JSystem/J3DGraphBase/J3DSys.h"
|
||||
#include "JSystem/J3DGraphBase/J3DTransform.h"
|
||||
#include "global.h"
|
||||
|
||||
static void J3DGDLoadTexMtxImm(f32 (*)[4], u32, _GXTexMtxType);
|
||||
static void J3DGDLoadPostTexMtxImm(f32 (*)[4], u32);
|
||||
@@ -548,7 +549,7 @@ extern J3DTevSwapModeInfo const j3dDefaultTevSwapMode = {
|
||||
extern const J3DTevSwapModeTableInfo j3dDefaultTevSwapModeTable = {0x00, 0x01, 0x02, 0x03};
|
||||
|
||||
/* 804563EC-804563F0 0049EC 0004+00 0/0 3/3 0/0 .sdata2 j3dDefaultBlendInfo */
|
||||
extern const J3DBlendInfo j3dDefaultBlendInfo = {GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_NOOP};
|
||||
extern const J3DBlendInfo j3dDefaultBlendInfo = {GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_NOOP};
|
||||
|
||||
/* 804563F0-804563F8 0049F0 0008+00 0/0 3/3 0/0 .sdata2 j3dDefaultColorChanInfo */
|
||||
extern const J3DColorChanInfo j3dDefaultColorChanInfo = {
|
||||
|
||||
@@ -8,7 +8,8 @@
|
||||
#include "JSystem/J3DGraphBase/J3DSys.h"
|
||||
#include "JSystem/JKernel/JKRHeap.h"
|
||||
#include "string.h"
|
||||
#include "dolphin/os/OSCache.h"
|
||||
#include <dolphin/os.h>
|
||||
#include "global.h"
|
||||
|
||||
/* 80310EF8-80310F78 30B838 0080+00 0/0 1/1 0/0 .text __ct__13J3DVertexDataFv */
|
||||
J3DVertexData::J3DVertexData() {
|
||||
@@ -241,4 +242,4 @@ J3DDrawMtxData::J3DDrawMtxData() {
|
||||
}
|
||||
|
||||
/* 803115F4-80311630 30BF34 003C+00 0/0 2/2 0/0 .text __dt__14J3DDrawMtxDataFv */
|
||||
J3DDrawMtxData::~J3DDrawMtxData() {}
|
||||
J3DDrawMtxData::~J3DDrawMtxData() {}
|
||||
|
||||
@@ -263,9 +263,9 @@ void J3DModelLoader::readInformation(J3DModelInfoBlock const* i_block, u32 i_fla
|
||||
|
||||
/* 803351A4-803351D0 32FAE4 002C+00 1/1 0/0 0/0 .text getFmtType__FP17_GXVtxAttrFmtList7_GXAttr */
|
||||
static _GXCompType getFmtType(_GXVtxAttrFmtList* i_fmtList, _GXAttr i_attr) {
|
||||
for (; i_fmtList->mAttrib != GX_VA_NULL; i_fmtList++) {
|
||||
if (i_fmtList->mAttrib == i_attr) {
|
||||
return i_fmtList->mCompType;
|
||||
for (; i_fmtList->attr != GX_VA_NULL; i_fmtList++) {
|
||||
if (i_fmtList->attr == i_attr) {
|
||||
return i_fmtList->type;
|
||||
}
|
||||
}
|
||||
return GX_F32;
|
||||
|
||||
@@ -11,6 +11,7 @@
|
||||
#include "JSystem/J3DGraphAnimator/J3DModelData.h"
|
||||
#include "JSystem/JSupport/JSupport.h"
|
||||
#include "dolphin/os.h"
|
||||
#include "global.h"
|
||||
|
||||
|
||||
/* 80336794-803367D4 3310D4 0040+00 0/0 3/0 0/0 .text countMaterialNum__14J3DModelLoaderFPCv */
|
||||
|
||||
@@ -8,6 +8,7 @@
|
||||
#include "JSystem/JKernel/JKRHeap.h"
|
||||
#include "JSystem/JSupport/JSupport.h"
|
||||
#include "dolphin/os.h"
|
||||
#include "global.h"
|
||||
|
||||
/* 80337350-80337400 331C90 00B0+00 0/0 2/2 0/0 .text __ct__15J3DShapeFactoryFRC13J3DShapeBlock */
|
||||
J3DShapeFactory::J3DShapeFactory(J3DShapeBlock const& block) {
|
||||
|
||||
@@ -18,8 +18,8 @@
|
||||
#include "JSystem/JKernel/JKRSolidHeap.h"
|
||||
#include "dol2asm.h"
|
||||
#include "dolphin/ai.h"
|
||||
#include "dolphin/os/OSCache.h"
|
||||
#include "dolphin/os/OSTime.h"
|
||||
#include <dolphin/os.h>
|
||||
#include <dolphin/os.h>
|
||||
|
||||
/* 80431C58-80431C68 05E978 000C+04 2/2 0/0 0/0 .bss sDmaDacBuffer__9JASDriver */
|
||||
s16* JASDriver::sDmaDacBuffer[3];
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
//
|
||||
|
||||
#include "JSystem/JAudio2/JASCalc.h"
|
||||
#include "dolphin/os/OSCache.h"
|
||||
#include <dolphin/os.h>
|
||||
#include "math.h"
|
||||
#include "limits.h"
|
||||
|
||||
@@ -329,4 +329,4 @@ s16 JASCalc::clamp(s32 x) {
|
||||
if (x >= std::numeric_limits<s16>::max())
|
||||
return std::numeric_limits<s16>::max();
|
||||
return x;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -12,7 +12,7 @@
|
||||
#include "JSystem/JAudio2/osdsp_task.h"
|
||||
#include "JSystem/JAudio2/JASCriticalSection.h"
|
||||
#include "JSystem/JKernel/JKRSolidHeap.h"
|
||||
#include "dolphin/os/OSCache.h"
|
||||
#include <dolphin/os.h>
|
||||
|
||||
/* 804512E8-804512EC 0007E8 0004+00 5/5 0/0 0/0 .sbss CH_BUF__6JASDsp */
|
||||
JASDsp::TChannel* JASDsp::CH_BUF;
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
#include "JSystem/JAudio2/JASDriverIF.h"
|
||||
#include "JSystem/JAudio2/JASAiCtrl.h"
|
||||
#include "JSystem/JAudio2/JASDSPInterface.h"
|
||||
#include "dolphin/os/OSThread.h"
|
||||
#include <dolphin/os.h>
|
||||
|
||||
//
|
||||
// Declarations:
|
||||
@@ -99,4 +99,4 @@ void JASDriver::DSPSyncCallback() {
|
||||
/* 8029E2F8-8029E320 298C38 0028+00 0/0 1/1 0/0 .text updateDacCallback__9JASDriverFv */
|
||||
void JASDriver::updateDacCallback() {
|
||||
sUpdateDacCallback.callback();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -23,7 +23,7 @@ JASHeap::JASHeap(JASDisposer* disposer) : mTree(this) {
|
||||
void JASHeap::initRootHeap(void* param_0, u32 param_1) {
|
||||
JUT_ASSERT(97, ! isAllocated());
|
||||
JASMutexLock lock(&mMutex);
|
||||
mBase = (u8*)OSRoundUpPtr(param_0, 0x20);
|
||||
mBase = (u8*)OSRoundUp32B(param_0);
|
||||
field_0x40 = NULL;
|
||||
mSize = param_1 - (u32(mBase) - u32(param_0));
|
||||
}
|
||||
|
||||
@@ -18,7 +18,7 @@
|
||||
#include "JSystem/JKernel/JKRAram.h"
|
||||
#include "JSystem/JKernel/JKRSolidHeap.h"
|
||||
#include "JSystem/JKernel/JKRThread.h"
|
||||
#include "dolphin/os/OSRtc.h"
|
||||
#include <dolphin/os.h>
|
||||
|
||||
/* 802A4AD0-802A4B28 29F410 0058+00 0/0 1/1 0/0 .text __ct__18JAU_JASInitializerFv */
|
||||
JAU_JASInitializer::JAU_JASInitializer() {
|
||||
|
||||
@@ -5,6 +5,7 @@
|
||||
|
||||
#include "JSystem/JAudio2/dsptask.h"
|
||||
#include "JSystem/JAudio2/osdsp.h"
|
||||
#include "global.h"
|
||||
|
||||
//
|
||||
// Forward References:
|
||||
@@ -531,7 +532,7 @@ static u8 jdsp[7936] ALIGN_DECL(32) = {
|
||||
};
|
||||
|
||||
/* 80431F80-80431FE0 05ECA0 0050+10 1/1 0/0 0/0 .bss audio_task */
|
||||
static STRUCT_DSP_TASK audio_task ALIGN_DECL(32);
|
||||
static DSPTaskInfo audio_task ALIGN_DECL(32);
|
||||
|
||||
/* 80431FE0-80433FE0 05ED00 2000+00 1/1 0/0 0/0 .bss AUDIO_YIELD_BUFFER */
|
||||
static u8 AUDIO_YIELD_BUFFER[8192] ALIGN_DECL(32);
|
||||
@@ -539,19 +540,19 @@ static u8 AUDIO_YIELD_BUFFER[8192] ALIGN_DECL(32);
|
||||
/* 8029E720-8029E7CC 299060 00AC+00 0/0 1/1 0/0 .text DspBoot__FPFPv_v */
|
||||
void DspBoot(void (*param_0)(void*)) {
|
||||
DspInitWork();
|
||||
audio_task.info.priority = 0xf0;
|
||||
audio_task.info.iram_mmem_addr = (u16*)(jdsp + 0x80000000);
|
||||
audio_task.info.iram_length = sizeof(jdsp);
|
||||
audio_task.info.iram_addr = 0;
|
||||
audio_task.info.dram_mmem_addr = (u16*)(AUDIO_YIELD_BUFFER + 0x80000000);
|
||||
audio_task.info.dram_length = sizeof(AUDIO_YIELD_BUFFER);
|
||||
audio_task.info.dram_addr = 0;
|
||||
audio_task.info.dsp_init_vector = 0;
|
||||
audio_task.info.dsp_resume_vector = 0x10;
|
||||
audio_task.info.init_cb = DspHandShake;
|
||||
audio_task.info.res_cb = NULL;
|
||||
audio_task.info.done_cb = NULL;
|
||||
audio_task.info.req_cb = param_0;
|
||||
audio_task.priority = 0xf0;
|
||||
audio_task.iram_mmem_addr = (u16*)(jdsp + 0x80000000);
|
||||
audio_task.iram_length = sizeof(jdsp);
|
||||
audio_task.iram_addr = 0;
|
||||
audio_task.dram_mmem_addr = (u16*)(AUDIO_YIELD_BUFFER + 0x80000000);
|
||||
audio_task.dram_length = sizeof(AUDIO_YIELD_BUFFER);
|
||||
audio_task.dram_addr = 0;
|
||||
audio_task.dsp_init_vector = 0;
|
||||
audio_task.dsp_resume_vector = 0x10;
|
||||
audio_task.init_cb = DspHandShake;
|
||||
audio_task.res_cb = NULL;
|
||||
audio_task.done_cb = NULL;
|
||||
audio_task.req_cb = param_0;
|
||||
DSPInit();
|
||||
DSPAddPriorTask(&audio_task);
|
||||
}
|
||||
|
||||
@@ -6,7 +6,10 @@
|
||||
#include "JSystem/JAudio2/osdsp.h"
|
||||
#include "JSystem/JAudio2/osdsp_task.h"
|
||||
#include "dolphin/os.h"
|
||||
#include "dolphin/dsp/dsp_task.h"
|
||||
#include <dolphin/dsp.h>
|
||||
|
||||
extern "C" void __DSP_insert_task(DSPTaskInfo*);
|
||||
extern "C" void __DSP_boot_task(DSPTaskInfo*);
|
||||
|
||||
/* 8029EA00-8029EA84 299340 0084+00 0/0 1/1 0/0 .text DSPAddTask */
|
||||
DSPTaskInfo* DSPAddTask(DSPTaskInfo* task) {
|
||||
@@ -32,8 +35,8 @@ void DSPAddPriorTask(STRUCT_DSP_TASK* task) {
|
||||
}
|
||||
BOOL status = OSDisableInterrupts();
|
||||
DSP_prior_task = (DSPTaskInfo*)task;
|
||||
task->info.state = 0;
|
||||
task->info.flags = 1;
|
||||
task->state = 0;
|
||||
task->flags = 1;
|
||||
__DSP_boot_task((DSPTaskInfo*)task);
|
||||
OSRestoreInterrupts(status);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5,8 +5,13 @@
|
||||
|
||||
#include "JSystem/JAudio2/osdsp_task.h"
|
||||
#include "JSystem/JAudio2/dspproc.h"
|
||||
#include "dolphin/dsp/dsp_task.h"
|
||||
#include "dolphin/os/OSContext.h"
|
||||
#include <dolphin/dsp.h>
|
||||
#include <dolphin/os.h>
|
||||
|
||||
extern DSPTaskInfo* __DSP_first_task;
|
||||
extern DSPTaskInfo* __DSP_curr_task;
|
||||
extern "C" void __DSP_exec_task(DSPTaskInfo*, DSPTaskInfo*);
|
||||
extern "C" void __DSP_remove_task(DSPTaskInfo* task);
|
||||
|
||||
static void Dsp_Update_Request();
|
||||
|
||||
@@ -20,7 +25,7 @@ static u8 struct_80451309;
|
||||
DSPTaskInfo* DSP_prior_task;
|
||||
|
||||
/* 8029EB20-8029EE24 299460 0304+00 0/0 1/1 0/0 .text __DSPHandler */
|
||||
void __DSPHandler(__OSInterrupt interrupt, OSContext* context) {
|
||||
extern "C" void __DSPHandler(__OSInterrupt interrupt, OSContext* context) {
|
||||
OSContext funcContext;
|
||||
__DSPRegs[5] = ((u16)(__DSPRegs[5]) & ~0x28) | 0x80;
|
||||
OSClearContext(&funcContext);
|
||||
|
||||
@@ -5,6 +5,8 @@
|
||||
#include "JSystem/JUtility/JUTDbPrint.h"
|
||||
#include "JSystem/JUtility/JUTProcBar.h"
|
||||
#include "dolphin/gx.h"
|
||||
#include <dolphin/vi.h>
|
||||
#include "global.h"
|
||||
|
||||
/* 80272040-802720F8 26C980 00B8+00 1/1 0/0 0/0 .text ctor_subroutine__10JFWDisplayFb */
|
||||
void JFWDisplay::ctor_subroutine(bool enableAlpha) {
|
||||
@@ -616,4 +618,4 @@ static void diagnoseGpHang() {
|
||||
} else {
|
||||
OSReport("GP is in unknown state.\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -123,7 +123,7 @@ void JFWSystem::init() {
|
||||
systemConsole = JUTConsole::create(60, 200, NULL);
|
||||
systemConsole->setFont(systemFont);
|
||||
|
||||
if (CSetUpParam::renderMode->efb_height < 300) {
|
||||
if (CSetUpParam::renderMode->efbHeight < 300) {
|
||||
systemConsole->setFontSize(systemFont->getWidth() * 0.85f, systemFont->getHeight() * 0.5f);
|
||||
systemConsole->setPosition(20, 25);
|
||||
} else {
|
||||
|
||||
@@ -5,8 +5,8 @@
|
||||
#include "JSystem/JKernel/JKRExpHeap.h"
|
||||
#include "JSystem/JUtility/JUTException.h"
|
||||
#include "dolphin/ar.h"
|
||||
#include "dolphin/os/OSCache.h"
|
||||
#include "dolphin/os/OSInterrupt.h"
|
||||
#include <dolphin/os.h>
|
||||
#include <dolphin/os.h>
|
||||
#include "string.h"
|
||||
|
||||
static u8* firstSrcData();
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
#include "JSystem/JKernel/JKRAramHeap.h"
|
||||
#include "JSystem/JKernel/JKRHeap.h"
|
||||
#include "global.h"
|
||||
#include <limits.h>
|
||||
|
||||
/* 8043430C-80434318 06102C 000C+00 8/8 0/0 0/0 .bss sAramList__11JKRAramHeap */
|
||||
JSUList<JKRAramBlock> JKRAramHeap::sAramList;
|
||||
@@ -47,7 +48,7 @@ JKRAramBlock* JKRAramHeap::alloc(u32 size, JKRAramHeap::EAllocMode allocationMod
|
||||
/* 802D3034-802D30BC 2CD974 0088+00 1/1 0/0 0/0 .text allocFromHead__11JKRAramHeapFUl */
|
||||
JKRAramBlock* JKRAramHeap::allocFromHead(u32 size) {
|
||||
u32 alignedSize = ALIGN_NEXT(size, 0x20);
|
||||
u32 bestFreeSize = UINT32_MAX;
|
||||
u32 bestFreeSize = UINT_MAX;
|
||||
JKRAramBlock* bestBlock = NULL;
|
||||
|
||||
JSUList<JKRAramBlock>* list = &sAramList;
|
||||
@@ -139,4 +140,4 @@ void JKRAramHeap::dump(void) {
|
||||
for (; iterator != list->getEnd(); ++iterator) {}
|
||||
|
||||
unlock();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
#include "JSystem/JKernel/JKRDecomp.h"
|
||||
#include "JSystem/JKernel/JKRAramPiece.h"
|
||||
#include "global.h"
|
||||
|
||||
/* ############################################################################################## */
|
||||
/* 804514B0-804514B8 0009B0 0004+04 1/1 0/0 0/0 .sbss sDecompObject__9JKRDecomp */
|
||||
@@ -299,4 +300,4 @@ JKRDecompCommand::JKRDecompCommand() {
|
||||
}
|
||||
|
||||
/* 802DBDC0-802DBDFC 2D6700 003C+00 1/1 0/0 0/0 .text __dt__16JKRDecompCommandFv */
|
||||
JKRDecompCommand::~JKRDecompCommand() {}
|
||||
JKRDecompCommand::~JKRDecompCommand() {}
|
||||
|
||||
@@ -5,8 +5,8 @@
|
||||
#include "JSystem/JKernel/JKRDecomp.h"
|
||||
#include "JSystem/JKernel/JKRDvdFile.h"
|
||||
#include "JSystem/JSupport/JSUFileStream.h"
|
||||
#include "dolphin/os/OSCache.h"
|
||||
#include "dolphin/os/OSInterrupt.h"
|
||||
#include <dolphin/os.h>
|
||||
#include <dolphin/os.h>
|
||||
#include "dolphin/vi.h"
|
||||
#include "global.h"
|
||||
#include "string.h"
|
||||
|
||||
@@ -7,8 +7,8 @@
|
||||
#include "JSystem/JKernel/JKRDecomp.h"
|
||||
#include "JSystem/JUtility/JUTException.h"
|
||||
#include "string.h"
|
||||
#include "dolphin/os/OSCache.h"
|
||||
#include "dolphin/os/OSInterrupt.h"
|
||||
#include <dolphin/os.h>
|
||||
#include <dolphin/os.h>
|
||||
#include "dolphin/vi.h"
|
||||
|
||||
static int JKRDecompressFromDVD(JKRDvdFile*, void*, u32, u32, u32, u32, u32*);
|
||||
@@ -560,4 +560,4 @@ static u8* nextSrcData(u8* src) {
|
||||
/* 802DA7D4-802DA7DC -00001 0008+00 0/0 0/0 0/0 .text isErrorRetry__12JKRDvdRipperFv */
|
||||
u8 JKRDvdRipper::isErrorRetry() {
|
||||
return errorRetry;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -272,8 +272,8 @@ u32 JKRFileCache::getResSize(const void* resource) const {
|
||||
|
||||
/* 802D52A0-802D531C 2CFBE0 007C+00 1/0 0/0 0/0 .text countFile__12JKRFileCacheCFPCc */
|
||||
u32 JKRFileCache::countFile(const char* path) const {
|
||||
DVDDirectory dir;
|
||||
DVDDirectoryEntry dirEntry;
|
||||
DVDDir dir;
|
||||
DVDDirEntry dirEntry;
|
||||
|
||||
u32 count = 0;
|
||||
char* name = getDvdPathName(path);
|
||||
@@ -334,14 +334,14 @@ JKRFileCache::CCacheBlock* JKRFileCache::findCacheBlock(u32 fileID) const {
|
||||
|
||||
/* 802D5410-802D551C 2CFD50 010C+00 2/2 0/0 0/0 .text findFile__12JKRFileCacheCFPcPCc */
|
||||
bool JKRFileCache::findFile(char* path, const char* fileName) const {
|
||||
DVDDirectory dir;
|
||||
DVDDirectoryEntry dirEntry;
|
||||
DVDDir dir;
|
||||
DVDDirEntry dirEntry;
|
||||
|
||||
bool result = false;
|
||||
u32 pathLength = strlen(path);
|
||||
if (DVDOpenDir(path, &dir)) {
|
||||
while (DVDReadDir(&dir, &dirEntry)) {
|
||||
if (dirEntry.is_directory) {
|
||||
if (dirEntry.isDir) {
|
||||
char* endOfPath = path + pathLength;
|
||||
*endOfPath = '/';
|
||||
strcpy(path + pathLength + 1, dirEntry.name);
|
||||
@@ -428,4 +428,4 @@ u32 JKRFileCache::readFsResource(void* dst, u32 dstLength, const char* path) {
|
||||
*/
|
||||
u32 JKRFileCache::readNameResource(void* dst, u32 dstLength, u32 type, const char* path) {
|
||||
return readResource(dst, dstLength, type, path);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -47,13 +47,13 @@ JKRDvdFinder::~JKRDvdFinder() {
|
||||
/* 802D4874-802D4910 2CF1B4 009C+00 1/0 0/0 0/0 .text findNextFile__12JKRDvdFinderFv */
|
||||
bool JKRDvdFinder::findNextFile(void) {
|
||||
if (mIsAvailable) {
|
||||
DVDDirectoryEntry directoryEntry;
|
||||
DVDDirEntry directoryEntry;
|
||||
mIsAvailable = DVDReadDir(&mDvdDirectory, &directoryEntry);
|
||||
|
||||
if (mIsAvailable) {
|
||||
mIsFileOrDirectory = directoryEntry.is_directory != 0;
|
||||
mIsFileOrDirectory = directoryEntry.isDir != 0;
|
||||
mEntryName = directoryEntry.name;
|
||||
mEntryFileIndex = directoryEntry.entry_number;
|
||||
mEntryFileIndex = directoryEntry.entryNum;
|
||||
mEntryId = 0;
|
||||
|
||||
// only matches with enum
|
||||
@@ -67,4 +67,4 @@ bool JKRDvdFinder::findNextFile(void) {
|
||||
}
|
||||
|
||||
return mIsAvailable;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -7,6 +7,8 @@
|
||||
#include "JSystem/JUtility/JUTAssert.h"
|
||||
#include "JSystem/JUtility/JUTException.h"
|
||||
|
||||
bool data_804508B0 = 1;
|
||||
|
||||
/* 80451370-80451374 000870 0004+00 3/3 44/44 0/0 .sbss sSystemHeap__7JKRHeap */
|
||||
JKRHeap* JKRHeap::sSystemHeap;
|
||||
|
||||
@@ -104,13 +106,13 @@ bool JKRHeap::initArena(char** memory, u32* size, int maxHeaps) {
|
||||
ram_start = (void*)ALIGN_NEXT((u32)arenaStart, 0x20);
|
||||
ram_end = (void*)ALIGN_PREV((u32)arenaHi, 0x20);
|
||||
|
||||
GLOBAL_MEMORY* codeStart = (GLOBAL_MEMORY*)OSPhysicalToCached(0);
|
||||
OSBootInfo* codeStart = (OSBootInfo*)OSPhysicalToCached(0);
|
||||
mCodeStart = codeStart;
|
||||
mCodeEnd = ram_start;
|
||||
|
||||
mUserRamStart = ram_start;
|
||||
mUserRamEnd = ram_end;
|
||||
mMemorySize = codeStart->memory_size;
|
||||
mMemorySize = codeStart->memorySize;
|
||||
|
||||
OSSetArenaLo(ram_end);
|
||||
OSSetArenaHi(ram_end);
|
||||
@@ -507,4 +509,4 @@ s32 JKRHeap::do_changeGroupID(u8 param_0) {
|
||||
/* 802CEDAC-802CEDB4 2C96EC 0008+00 1/0 1/0 0/0 .text do_getCurrentGroupId__7JKRHeapFv */
|
||||
u8 JKRHeap::do_getCurrentGroupId() {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
#include "JSystem/JKernel/JKRSolidHeap.h"
|
||||
#include "JSystem/JUtility/JUTAssert.h"
|
||||
#include "JSystem/JUtility/JUTConsole.h"
|
||||
#include "global.h"
|
||||
|
||||
/* 802D0A24-802D0AD0 2CB364 00AC+00 0/0 4/4 1/1 .text create__12JKRSolidHeapFUlP7JKRHeapb
|
||||
*/
|
||||
@@ -294,4 +295,4 @@ void* JKRSolidHeap::do_getMaxFreeBlock(void) {
|
||||
/* 802D12A4-802D12C4 2CBBE4 0020+00 1/0 0/0 0/0 .text do_getTotalFreeSize__12JKRSolidHeapFv */
|
||||
s32 JKRSolidHeap::do_getTotalFreeSize(void) {
|
||||
return getFreeSize();
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
#include "JSystem/JUtility/JUTConsole.h"
|
||||
#include "stdio.h"
|
||||
#include "dol2asm.h"
|
||||
#include "global.h"
|
||||
|
||||
/* 8043428C-80434298 060FAC 000C+00 5/6 0/0 0/0 .bss sThreadList__9JKRThread */
|
||||
JSUList<JKRThread> JKRThread::sThreadList(0);
|
||||
@@ -52,8 +53,8 @@ JKRThread::JKRThread(JKRHeap* heap, u32 stack_size, int message_count, int param
|
||||
JKRThread::JKRThread(OSThread* thread, int message_count) : mThreadListLink(this) {
|
||||
mHeap = NULL;
|
||||
mThreadRecord = thread;
|
||||
mStackSize = (u32)thread->stack_end - (u32)thread->stack_base;
|
||||
mStackMemory = thread->stack_base;
|
||||
mStackSize = (u32)thread->stackEnd - (u32)thread->stackBase;
|
||||
mStackMemory = thread->stackBase;
|
||||
|
||||
setCommon_mesgQueue(JKRHeap::getSystemHeap(), message_count);
|
||||
}
|
||||
@@ -325,4 +326,4 @@ JSUList<JKRTask> JKRTask::sTaskList;
|
||||
#pragma push
|
||||
#pragma force_active on
|
||||
u8 JKRTask::sEndMesgQueue[32];
|
||||
#pragma pop
|
||||
#pragma pop
|
||||
|
||||
@@ -1352,16 +1352,16 @@ GXBlendMode JPABaseShape::st_bm[3] = {
|
||||
|
||||
/* 803C436C-803C4394 02148C 0028+00 0/1 0/0 0/0 .data st_bf__12JPABaseShape */
|
||||
GXBlendFactor JPABaseShape::st_bf[10] = {
|
||||
GX_BL_ZERO, GX_BL_ONE, GX_BL_SRC_COLOR, GX_BL_INV_SRC_COLOR,
|
||||
GX_BL_SRC_COLOR, GX_BL_INV_SRC_COLOR, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA,
|
||||
GX_BL_DST_ALPHA, GX_BL_INV_DST_ALPHA,
|
||||
GX_BL_ZERO, GX_BL_ONE, GX_BL_SRCCLR, GX_BL_INVSRCCLR,
|
||||
GX_BL_SRCCLR, GX_BL_INVSRCCLR, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA,
|
||||
GX_BL_DSTALPHA, GX_BL_INVDSTALPHA,
|
||||
};
|
||||
|
||||
/* 803C4394-803C43D4 0214B4 0040+00 0/1 0/0 0/0 .data st_lo__12JPABaseShape */
|
||||
GXLogicOp JPABaseShape::st_lo[16] = {
|
||||
GX_LO_CLEAR, GX_LO_SET, GX_LO_COPY, GX_LO_INV_COPY, GX_LO_NOOP, GX_LO_INV,
|
||||
GX_LO_CLEAR, GX_LO_SET, GX_LO_COPY, GX_LO_INVCOPY, GX_LO_NOOP, GX_LO_INV,
|
||||
GX_LO_AND, GX_LO_NAND, GX_LO_OR, GX_LO_NOR, GX_LO_XOR, GX_LO_EQUIV,
|
||||
GX_LO_REV_AND, GX_LO_INV_AND, GX_LO_REV_OR, GX_LO_INV_OR,
|
||||
GX_LO_REVAND, GX_LO_INVAND, GX_LO_REVOR, GX_LO_INVOR,
|
||||
};
|
||||
|
||||
/* 803C43D4-803C43F4 0214F4 0020+00 0/1 0/0 0/0 .data st_c__12JPABaseShape */
|
||||
|
||||
@@ -15,6 +15,7 @@
|
||||
#include "JSystem/JParticle/JPAParticle.h"
|
||||
#include "JSystem/JParticle/JPAResourceManager.h"
|
||||
#include "dolphin/gx.h"
|
||||
#include "global.h"
|
||||
|
||||
/* 80274010-80274080 26E950 0070+00 0/0 1/1 0/0 .text __ct__11JPAResourceFv */
|
||||
JPAResource::JPAResource() {
|
||||
@@ -957,8 +958,7 @@ void JPAResource::setPTev() {
|
||||
if (mpExTexShape->isUseIndirect()) {
|
||||
GXSetIndTexOrder(GX_INDTEXSTAGE0, GX_TEXCOORD1, GX_TEXMAP2);
|
||||
GXSetIndTexCoordScale(GX_INDTEXSTAGE0, GX_ITS_1, GX_ITS_1);
|
||||
GXSetIndTexMtx(GX_ITM_0, (f32*)mpExTexShape->getIndTexMtx(),
|
||||
mpExTexShape->getExpScale());
|
||||
GXSetIndTexMtx(GX_ITM_0, (f32(*)[3])mpExTexShape->getIndTexMtx(), mpExTexShape->getExpScale());
|
||||
GXSetTevIndirect(GX_TEVSTAGE0, GX_INDTEXSTAGE0, GX_ITF_8, GX_ITB_STU, GX_ITM_0,
|
||||
GX_ITW_OFF, GX_ITW_OFF, 0, 0, GX_ITBA_OFF);
|
||||
ind_stages++;
|
||||
|
||||
@@ -375,4 +375,4 @@ void JStudio_JAudio2::TAdaptor_sound::endSound_fadeOut_(u32 u32FadeTime) {
|
||||
JUT_ASSERT(654, (u32FadeTime>0)||!opJAISoundHandle_);
|
||||
field_0x120 = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -8,6 +8,7 @@
|
||||
#include "JSystem/JUtility/JUTDbPrint.h"
|
||||
#include "JSystem/JUtility/JUTDirectPrint.h"
|
||||
#include "stdio.h"
|
||||
#include <dolphin/vi.h>
|
||||
|
||||
/* 804508F8-80450900 000378 0008+00 0/0 3/3 0/0 .sdata None */
|
||||
bool sAssertVisible = true;
|
||||
|
||||
@@ -4,7 +4,9 @@
|
||||
#include "JSystem/JUtility/JUTAssert.h"
|
||||
#include "JSystem/JUtility/JUTDirectPrint.h"
|
||||
#include "JSystem/JUtility/JUTVideo.h"
|
||||
#include <dolphin/vi.h>
|
||||
#include <stdio.h>
|
||||
#include "global.h"
|
||||
|
||||
/* 80451570-80451574 000A70 0004+00 4/4 7/7 0/0 .sbss sManager__17JUTConsoleManager */
|
||||
JUTConsoleManager* JUTConsoleManager::sManager;
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
//
|
||||
|
||||
#include "JSystem/JUtility/JUTDirectFile.h"
|
||||
#include "dolphin/os/OSInterrupt.h"
|
||||
#include <dolphin/os.h>
|
||||
#include "global.h"
|
||||
|
||||
//
|
||||
@@ -34,7 +34,7 @@ int JUTDirectFile::fetch32byte() {
|
||||
return -1;
|
||||
} else {
|
||||
interrupts = OSEnableInterrupts();
|
||||
while (DVDGetCommandBlockStatus(&mFileInfo.block)) {
|
||||
while (DVDGetCommandBlockStatus(&mFileInfo.cb)) {
|
||||
;
|
||||
}
|
||||
OSRestoreInterrupts(interrupts);
|
||||
@@ -181,4 +181,4 @@ int JUTDirectFile::fgets(void* buf, int len) {
|
||||
}
|
||||
|
||||
return readCount;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5,7 +5,8 @@
|
||||
|
||||
#include "JSystem/JUtility/JUTDirectPrint.h"
|
||||
#include "stdio.h"
|
||||
#include "dolphin/os/OSCache.h"
|
||||
#include <dolphin/os.h>
|
||||
#include "global.h"
|
||||
|
||||
//
|
||||
// Forward References:
|
||||
@@ -265,4 +266,4 @@ void JUTDirectPrint::setCharColor(u8 r, u8 g, u8 b) {
|
||||
mCharColor_Cr = Cr;
|
||||
mCharColor_Cr2 = (Cr >> 1) & 0x7fff;
|
||||
mCharColor_Cr4 = (Cr >> 2) & 0x3fff;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -43,20 +43,20 @@ const char* JUTException::sCpuExpName[17] = {
|
||||
JUTException* JUTException::sErrorManager;
|
||||
|
||||
/* 8045150C-80451510 000A0C 0004+00 4/4 0/0 0/0 .sbss sPreUserCallback__12JUTException */
|
||||
OSErrorHandler JUTException::sPreUserCallback;
|
||||
JUTExceptionUserCallback JUTException::sPreUserCallback;
|
||||
|
||||
/* 80451510-80451514 000A10 0004+00 3/3 0/0 0/0 .sbss sPostUserCallback__12JUTException
|
||||
*/
|
||||
OSErrorHandler JUTException::sPostUserCallback;
|
||||
JUTExceptionUserCallback JUTException::sPostUserCallback;
|
||||
|
||||
/* 802E1D5C-802E1E40 2DC69C 00E4+00 1/1 0/0 0/0 .text __ct__12JUTExceptionFP14JUTDirectPrint */
|
||||
JUTException::JUTException(JUTDirectPrint* directPrint)
|
||||
: JKRThread(0x1C00, 0x10, 0), mDirectPrint(directPrint) {
|
||||
OSSetErrorHandler(EXCEPTION_DSI, errorHandler);
|
||||
OSSetErrorHandler(EXCEPTION_ISI, errorHandler);
|
||||
OSSetErrorHandler(EXCEPTION_PROGRAM, errorHandler);
|
||||
OSSetErrorHandler(EXCEPTION_ALIGNMENT, errorHandler);
|
||||
OSSetErrorHandler(EXCEPTION_MEMORY_PROTECTION, errorHandler);
|
||||
OSSetErrorHandler(__OS_EXCEPTION_DSI, (OSErrorHandler)errorHandler);
|
||||
OSSetErrorHandler(__OS_EXCEPTION_ISI, (OSErrorHandler)errorHandler);
|
||||
OSSetErrorHandler(__OS_EXCEPTION_PROGRAM, (OSErrorHandler)errorHandler);
|
||||
OSSetErrorHandler(__OS_EXCEPTION_ALIGNMENT, (OSErrorHandler)errorHandler);
|
||||
OSSetErrorHandler(__OS_EXCEPTION_MEMORY_PROTECTION, (OSErrorHandler)errorHandler);
|
||||
setFPException(0);
|
||||
|
||||
sPreUserCallback = NULL;
|
||||
@@ -87,7 +87,7 @@ JUTException* JUTException::create(JUTDirectPrint* directPrint) {
|
||||
OSMessage JUTException::sMessageBuffer[1] = {0};
|
||||
|
||||
struct CallbackObject {
|
||||
/* 0x00 */ OSErrorHandler callback;
|
||||
/* 0x00 */ JUTExceptionUserCallback callback;
|
||||
/* 0x04 */ u16 error;
|
||||
/* 0x06 */ u16 pad_0x06;
|
||||
/* 0x08 */ OSContext* context;
|
||||
@@ -106,7 +106,7 @@ void* JUTException::run() {
|
||||
VISetPreRetraceCallback(NULL);
|
||||
VISetPostRetraceCallback(NULL);
|
||||
CallbackObject* cb = (CallbackObject*)message;
|
||||
OSErrorHandler callback = cb->callback;
|
||||
JUTExceptionUserCallback callback = cb->callback;
|
||||
u16 error = cb->error;
|
||||
OSContext* context = cb->context;
|
||||
int r24 = cb->param_3;
|
||||
@@ -156,7 +156,7 @@ void JUTException::errorHandler(OSError error, OSContext* context, u32 param_3,
|
||||
fpscr = context->fpscr;
|
||||
OSFillFPUContext(context);
|
||||
OSSetErrorHandler(error, NULL);
|
||||
if (error == OS_ERROR_MEMORY_PROTECTION) {
|
||||
if (error == __OS_EXCEPTION_MEMORY_PROTECTION) {
|
||||
OSProtectRange(0, NULL, 0, 3);
|
||||
OSProtectRange(1, NULL, 0, 3);
|
||||
OSProtectRange(2, NULL, 0, 3);
|
||||
@@ -226,9 +226,9 @@ void JUTException::panic_f(char const* file, int line, char const* format, ...)
|
||||
void JUTException::setFPException(u32 fpscr_enable_bits) {
|
||||
__OSFpscrEnableBits = fpscr_enable_bits;
|
||||
if (fpscr_enable_bits) {
|
||||
OSSetErrorHandler(EXCEPTION_FLOATING_POINT_EXCEPTION, errorHandler);
|
||||
OSSetErrorHandler(__OS_EXCEPTION_FLOATING_POINT_EXCEPTION, (OSErrorHandler)errorHandler);
|
||||
} else {
|
||||
OSSetErrorHandler(EXCEPTION_FLOATING_POINT_EXCEPTION, NULL);
|
||||
OSSetErrorHandler(__OS_EXCEPTION_FLOATING_POINT_EXCEPTION, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -362,13 +362,13 @@ void JUTException::showMainInfo(u16 error, OSContext* context, u32 dsisr, u32 da
|
||||
return;
|
||||
}
|
||||
|
||||
if (error < (OS_ERROR_MACHINE_CHECK | OS_ERROR_FLOATING_POINT_EXCEPTION)) {
|
||||
if (error < (OS_ERROR_MACHINE_CHECK | __OS_EXCEPTION_FLOATING_POINT_EXCEPTION)) {
|
||||
sConsole->print_f("CONTEXT:%08XH (%s EXCEPTION)\n", context, sCpuExpName[error]);
|
||||
} else {
|
||||
sConsole->print_f("CONTEXT:%08XH\n", context);
|
||||
}
|
||||
|
||||
if (error == OS_ERROR_FLOATING_POINT_EXCEPTION) {
|
||||
if (error == __OS_EXCEPTION_FLOATING_POINT_EXCEPTION) {
|
||||
u32 flags = fpscr & (((fpscr & 0xf8) << 0x16) | 0x1f80700);
|
||||
if ((flags & 0x20000000) != 0) {
|
||||
sConsole->print_f(" FPE: Invalid operation\n");
|
||||
@@ -659,7 +659,7 @@ void JUTException::printContext(OSError error, OSContext* context, u32 dsisr, u3
|
||||
return;
|
||||
}
|
||||
|
||||
if (error < (OS_ERROR_MACHINE_CHECK | OS_ERROR_FLOATING_POINT_EXCEPTION)) {
|
||||
if (error < (OS_ERROR_MACHINE_CHECK | __OS_EXCEPTION_FLOATING_POINT_EXCEPTION)) {
|
||||
sConsole->print_f("******** EXCEPTION OCCURRED! ********\nFrameMemory:%XH\n",
|
||||
getFrameMemory());
|
||||
} else {
|
||||
@@ -821,8 +821,8 @@ void JUTException::waitTime(s32 timeout_ms) {
|
||||
void JUTException::createFB() {
|
||||
_GXRenderModeObj* renderMode = &GXNtsc480Int;
|
||||
void* end = (void*)OSGetArenaHi();
|
||||
u16 width = ALIGN_NEXT(renderMode->fb_width, 16);
|
||||
u16 height = renderMode->xfb_height;
|
||||
u16 width = ALIGN_NEXT(renderMode->fbWidth, 16);
|
||||
u16 height = renderMode->xfbHeight;
|
||||
u32 pixel_count = width * height;
|
||||
u32 size = pixel_count * 2;
|
||||
|
||||
@@ -830,7 +830,7 @@ void JUTException::createFB() {
|
||||
void* object = (void*)ALIGN_PREV((s32)begin - sizeof(JUTExternalFB), 32);
|
||||
new (object) JUTExternalFB(renderMode, GX_GM_1_7, begin, size);
|
||||
|
||||
mDirectPrint->changeFrameBuffer(begin, renderMode->fb_width, renderMode->efb_height);
|
||||
mDirectPrint->changeFrameBuffer(begin, renderMode->fbWidth, renderMode->efbHeight);
|
||||
VIConfigure(renderMode);
|
||||
VISetNextFrameBuffer(begin);
|
||||
VISetBlack(FALSE);
|
||||
@@ -848,16 +848,16 @@ void JUTException::createFB() {
|
||||
|
||||
/* 802E3AEC-802E3AFC 2DE42C 0010+00 0/0 1/1 0/0 .text
|
||||
* setPreUserCallback__12JUTExceptionFPFUsP9OSContextUlUl_v */
|
||||
OSErrorHandler JUTException::setPreUserCallback(OSErrorHandler callback) {
|
||||
OSErrorHandler previous = sPreUserCallback;
|
||||
JUTExceptionUserCallback JUTException::setPreUserCallback(JUTExceptionUserCallback callback) {
|
||||
JUTExceptionUserCallback previous = sPreUserCallback;
|
||||
sPreUserCallback = callback;
|
||||
return previous;
|
||||
}
|
||||
|
||||
/* 802E3AFC-802E3B0C 2DE43C 0010+00 0/0 1/1 0/0 .text
|
||||
* setPostUserCallback__12JUTExceptionFPFUsP9OSContextUlUl_v */
|
||||
OSErrorHandler JUTException::setPostUserCallback(OSErrorHandler callback) {
|
||||
OSErrorHandler previous = sPostUserCallback;
|
||||
JUTExceptionUserCallback JUTException::setPostUserCallback(JUTExceptionUserCallback callback) {
|
||||
JUTExceptionUserCallback previous = sPostUserCallback;
|
||||
sPostUserCallback = callback;
|
||||
return previous;
|
||||
}
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
#include <dolphin.h>
|
||||
#include "global.h"
|
||||
|
||||
/* 8039DA20-803A1B80 02A080 4160+00 0/0 1/0 0/0 .rodata JUTResFONT_Ascfont_fix12 */
|
||||
extern u8 const JUTResFONT_Ascfont_fix12[16736] ALIGN_DECL(32) = {
|
||||
|
||||
@@ -113,13 +113,13 @@ u32 JUTGamePad::read() {
|
||||
for (int i = 0; i < 4; i++) {
|
||||
bittest = PAD_CHAN0_BIT >> i;
|
||||
|
||||
if (mPadStatus[i].error == 0) {
|
||||
if (mPadStatus[i].err == 0) {
|
||||
u32 stick_status;
|
||||
stick_status = mPadMStick[i].update(mPadStatus[i].stick_x, mPadStatus[i].stick_y, sStickMode, EMainStick, mPadButton[i].mButton) << 0x18;
|
||||
stick_status |= (mPadSStick[i].update(mPadStatus[i].substick_x, mPadStatus[i].substick_y, sStickMode, ESubStick, mPadButton[i].mButton) << 0x10);
|
||||
stick_status = mPadMStick[i].update(mPadStatus[i].stickX, mPadStatus[i].stickY, sStickMode, EMainStick, mPadButton[i].mButton) << 0x18;
|
||||
stick_status |= (mPadSStick[i].update(mPadStatus[i].substickX, mPadStatus[i].substickY, sStickMode, ESubStick, mPadButton[i].mButton) << 0x10);
|
||||
|
||||
mPadButton[i].update(&mPadStatus[i], stick_status);
|
||||
} else if (mPadStatus[i].error == -1) {
|
||||
} else if (mPadStatus[i].err == -1) {
|
||||
mPadMStick[i].update(0, 0, sStickMode, EMainStick, 0);
|
||||
mPadSStick[i].update(0, 0, sStickMode, ESubStick, 0);
|
||||
mPadButton[i].update(NULL, 0);
|
||||
@@ -140,9 +140,9 @@ u32 JUTGamePad::read() {
|
||||
pad->getPadReplay()->getStatus(&status);
|
||||
|
||||
u32 stick_status;
|
||||
stick_status = pad->mMainStick.update(status.stick_x, status.stick_y, sStickMode,
|
||||
stick_status = pad->mMainStick.update(status.stickX, status.stickY, sStickMode,
|
||||
EMainStick, pad->mButton.mButton) << 0x18;
|
||||
stick_status |= pad->mSubStick.update(status.substick_x, status.substick_y, sStickMode,
|
||||
stick_status |= pad->mSubStick.update(status.substickX, status.substickY, sStickMode,
|
||||
ESubStick, pad->mButton.mButton) << 0x10;
|
||||
|
||||
pad->mButton.update(&status, stick_status);
|
||||
@@ -155,7 +155,7 @@ u32 JUTGamePad::read() {
|
||||
|
||||
if (pad->getPadRecord() != NULL && pad->getPadRecord()->isActive()) {
|
||||
int port = pad->mPortNum;
|
||||
if (port >= 0 && mPadStatus[port].error == 0) {
|
||||
if (port >= 0 && mPadStatus[port].err == 0) {
|
||||
pad->getPadRecord()->write(&mPadStatus[port]);
|
||||
}
|
||||
}
|
||||
@@ -172,7 +172,7 @@ u32 JUTGamePad::read() {
|
||||
/* 802E0BBC-802E0C6C 2DB4FC 00B0+00 1/1 0/0 0/0 .text assign__10JUTGamePadFv */
|
||||
void JUTGamePad::assign() {
|
||||
for (int i = 0; i < 4; i++) {
|
||||
if (mPadStatus[i].error == 0 && mPadAssign[i] == 0) {
|
||||
if (mPadStatus[i].err == 0 && mPadAssign[i] == 0) {
|
||||
mPortNum = i;
|
||||
mPadAssign[i] = 1;
|
||||
mPadButton[i].setRepeat(mButton.mRepeatMask, mButton.mRepeatDelay, mButton.mRepeatRate);
|
||||
@@ -243,7 +243,7 @@ void JUTGamePad::update() {
|
||||
mButton = mPadButton[mPortNum];
|
||||
mMainStick = mPadMStick[mPortNum];
|
||||
mSubStick = mPadSStick[mPortNum];
|
||||
mErrorStatus = mPadStatus[mPortNum].error;
|
||||
mErrorStatus = mPadStatus[mPortNum].err;
|
||||
}
|
||||
|
||||
if (field_0xa8 == 0 || C3ButtonReset::sResetPattern != (mButton.mButton & C3ButtonReset::sResetMaskPattern)) {
|
||||
@@ -369,10 +369,10 @@ void JUTGamePad::CButton::update(const PADStatus* padStatus, u32 stickStatus) {
|
||||
mRepeat |= (mRepeatMask ^ 0xFFFFFFFF) & mTrigger;
|
||||
|
||||
if (padStatus != NULL) {
|
||||
mAnalogA = padStatus->analog_a;
|
||||
mAnalogB = padStatus->analog_b;
|
||||
mAnalogL = padStatus->trigger_left;
|
||||
mAnalogR = padStatus->trigger_right;
|
||||
mAnalogA = padStatus->analogA;
|
||||
mAnalogB = padStatus->analogB;
|
||||
mAnalogL = padStatus->triggerLeft;
|
||||
mAnalogR = padStatus->triggerRight;
|
||||
} else {
|
||||
mAnalogA = 0;
|
||||
mAnalogB = 0;
|
||||
|
||||
@@ -124,7 +124,7 @@ void JUTProcBar::draw() {
|
||||
void JUTProcBar::drawProcessBar() {
|
||||
if (mVisible) {
|
||||
int frameDuration = 16666; // duration in miliseconds? for how long a frame takes,
|
||||
if (JUTVideo::getManager() && ((JUTVideo::getManager()->getRenderMode()->vi_tv_mode >> 2) &
|
||||
if (JUTVideo::getManager() && ((JUTVideo::getManager()->getRenderMode()->viTVmode >> 2) &
|
||||
0x0f) == 1) // possibly a define
|
||||
frameDuration = 20000; // duration for PAL
|
||||
|
||||
@@ -324,4 +324,4 @@ void JUTProcBar::drawHeapBar() {
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -187,7 +187,7 @@ void JUTResFont::setGX() {
|
||||
GXSetChanCtrl(GX_COLOR0A0, GX_FALSE, GX_SRC_REG, GX_SRC_VTX, GX_LIGHT_NULL, GX_DF_NONE,
|
||||
GX_AF_NONE);
|
||||
GXSetTevOp(GX_TEVSTAGE0, GX_MODULATE);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, GX_RGBA4, 0);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_CLR_RGBA, GX_RGBX8, 15);
|
||||
@@ -220,7 +220,7 @@ void JUTResFont::setGX(JUtility::TColor col1, JUtility::TColor col2) {
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE1, GX_CA_ZERO, GX_CA_APREV, GX_CA_RASA, GX_CA_ZERO);
|
||||
GXSetTevColorOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, GX_RGBA4, 0);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_CLR_RGBA, GX_RGBX8, 15);
|
||||
|
||||
@@ -7,6 +7,7 @@
|
||||
#include "JSystem/JUtility/JUTDirectPrint.h"
|
||||
#include "JSystem/JUtility/JUTXfb.h"
|
||||
#include "dolphin/gx.h"
|
||||
#include <dolphin/vi.h>
|
||||
|
||||
/* 80451538-8045153C 000A38 0004+00 4/4 18/18 1/1 .sbss sManager__8JUTVideo */
|
||||
JUTVideo* JUTVideo::sManager;
|
||||
@@ -93,7 +94,7 @@ void JUTVideo::preRetraceProc(u32 retrace_count) {
|
||||
JUTVideo* videoManager = JUTGetVideoManager();
|
||||
const GXRenderModeObj* renderMode = videoManager->getRenderMode();
|
||||
JUTDirectPrint* directPrint = JUTDirectPrint::getManager();
|
||||
directPrint->changeFrameBuffer(frameBuffer, renderMode->fb_width, renderMode->efb_height);
|
||||
directPrint->changeFrameBuffer(frameBuffer, renderMode->fbWidth, renderMode->efbHeight);
|
||||
}
|
||||
|
||||
if (sManager->mSetBlack == 1) {
|
||||
@@ -198,7 +199,7 @@ void JUTVideo::postRetraceProc(u32 retrace_count) {
|
||||
/* 802E5198-802E5210 2DFAD8 0078+00 1/1 2/2 0/0 .text
|
||||
* setRenderMode__8JUTVideoFPC16_GXRenderModeObj */
|
||||
void JUTVideo::setRenderMode(GXRenderModeObj const* pObj) {
|
||||
if (mRenderObj != NULL && pObj->vi_tv_mode != mRenderObj->vi_tv_mode) {
|
||||
if (mRenderObj != NULL && pObj->viTVmode != mRenderObj->viTVmode) {
|
||||
mSetBlack = true;
|
||||
mSetBlackFrameCount = 4;
|
||||
}
|
||||
@@ -213,4 +214,4 @@ void JUTVideo::setRenderMode(GXRenderModeObj const* pObj) {
|
||||
}
|
||||
|
||||
/* 802E5210-802E5214 2DFB50 0004+00 0/0 1/1 0/0 .text waitRetraceIfNeed__8JUTVideoFv */
|
||||
void JUTVideo::waitRetraceIfNeed() {}
|
||||
void JUTVideo::waitRetraceIfNeed() {}
|
||||
|
||||
@@ -59,15 +59,15 @@ JUTXfb::JUTXfb(GXRenderModeObj const* pObj, JKRHeap* pHeap, JUTXfb::EXfbNumber x
|
||||
common_init(xfbNum);
|
||||
|
||||
if (pObj) {
|
||||
initiate(pObj->fb_width, pObj->xfb_height, pHeap, xfbNum);
|
||||
initiate(pObj->fbWidth, pObj->xfbHeight, pHeap, xfbNum);
|
||||
} else {
|
||||
u16 fb_width = JUTVideo::getManager()->getRenderMode()->fb_width;
|
||||
u16 efb_height = (u32)JUTVideo::getManager()->getRenderMode()->efb_height;
|
||||
u16 xfb_height = JUTVideo::getManager()->getRenderMode()->xfb_height;
|
||||
f32 scale_factor = GXGetYScaleFactor(efb_height, xfb_height);
|
||||
u16 xfb_lines = GXGetNumXfbLines(efb_height, scale_factor);
|
||||
u16 fbWidth = JUTVideo::getManager()->getRenderMode()->fbWidth;
|
||||
u16 efbHeight = (u32)JUTVideo::getManager()->getRenderMode()->efbHeight;
|
||||
u16 xfb_height = JUTVideo::getManager()->getRenderMode()->xfbHeight;
|
||||
f32 scale_factor = GXGetYScaleFactor(efbHeight, xfb_height);
|
||||
u16 xfb_lines = GXGetNumXfbLines(efbHeight, scale_factor);
|
||||
|
||||
initiate(fb_width, xfb_lines, pHeap, xfbNum);
|
||||
initiate(fbWidth, xfb_lines, pHeap, xfbNum);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -18,8 +18,8 @@ inline static void InitDefaultHeap(void) {
|
||||
arenaLo = OSInitAlloc(arenaLo, arenaHi, 1);
|
||||
OSSetArenaLo(arenaLo);
|
||||
|
||||
arenaLo = OSRoundUpPtr(arenaLo, 0x20);
|
||||
arenaHi = OSRoundDownPtr(arenaHi, 0x20);
|
||||
arenaLo = (void*)OSRoundUp32B(arenaLo);
|
||||
arenaHi = (void*)OSRoundDown32B(arenaHi);
|
||||
|
||||
OSSetCurrentHeap(OSCreateHeap(arenaLo, arenaHi));
|
||||
OSSetArenaLo(arenaLo = arenaHi);
|
||||
@@ -32,4 +32,4 @@ void __sys_free(void* p) {
|
||||
}
|
||||
|
||||
OSFreeToHeap(__OSCurrHeap, p);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,6 +4,7 @@
|
||||
*/
|
||||
|
||||
#include "SSystem/SComponent/c_bg_s_chk.h"
|
||||
#include "f_pc/f_pc_manager.h"
|
||||
|
||||
/* 80267B4C-80267B70 26248C 0024+00 0/0 7/7 0/0 .text __ct__8cBgS_ChkFv */
|
||||
cBgS_Chk::cBgS_Chk() {
|
||||
@@ -24,10 +25,10 @@ void cBgS_Chk::SetExtChk(cBgS_Chk& other) {
|
||||
}
|
||||
|
||||
/* 80267BDC-80267C1C 26251C 0040+00 0/0 7/7 0/0 .text ChkSameActorPid__8cBgS_ChkCFUi */
|
||||
bool cBgS_Chk::ChkSameActorPid(unsigned int pid) const {
|
||||
if (mActorPid == -1 || pid == UINT32_MAX || !mSameActorChk) {
|
||||
bool cBgS_Chk::ChkSameActorPid(fpc_ProcID pid) const {
|
||||
if (mActorPid == fpcM_ERROR_PROCESS_ID_e || pid == fpcM_ERROR_PROCESS_ID_e || !mSameActorChk) {
|
||||
return FALSE;
|
||||
} else {
|
||||
return (mActorPid == pid) ? TRUE : FALSE;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,11 +4,12 @@
|
||||
*/
|
||||
|
||||
#include "SSystem/SComponent/c_bg_s_gnd_chk.h"
|
||||
#include "f_pc/f_pc_manager.h"
|
||||
|
||||
/* 80267C1C-80267C94 26255C 0078+00 0/0 2/2 123/123 .text __ct__11cBgS_GndChkFv */
|
||||
cBgS_GndChk::cBgS_GndChk() {
|
||||
m_pos = cXyz::Zero;
|
||||
SetActorPid(UINT32_MAX);
|
||||
SetActorPid(fpcM_ERROR_PROCESS_ID_e);
|
||||
mFlags = 2;
|
||||
}
|
||||
|
||||
@@ -29,4 +30,4 @@ void cBgS_GndChk::SetPos(cXyz const* pos) {
|
||||
/* 80267D44-80267D54 262684 0010+00 0/0 1/1 0/0 .text PreCheck__11cBgS_GndChkFv */
|
||||
void cBgS_GndChk::PreCheck() {
|
||||
mWallPrecheck = mFlags & 2;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -4,6 +4,7 @@
|
||||
*/
|
||||
|
||||
#include "SSystem/SComponent/c_bg_s_lin_chk.h"
|
||||
#include "f_pc/f_pc_manager.h"
|
||||
|
||||
/* 80267D5C-80267DBC 26269C 0060+00 0/0 2/2 0/0 .text __ct__11cBgS_LinChkFv */
|
||||
cBgS_LinChk::cBgS_LinChk() {
|
||||
@@ -19,7 +20,7 @@ void cBgS_LinChk::ct() {
|
||||
mLin.SetStartEnd(start_end, start_end);
|
||||
field_0x40 = start_end;
|
||||
|
||||
SetActorPid(UINT32_MAX);
|
||||
SetActorPid(fpcM_ERROR_PROCESS_ID_e);
|
||||
mStts = 0;
|
||||
mFrontFlag = 1;
|
||||
mBackFlag = 0;
|
||||
|
||||
@@ -2,7 +2,9 @@
|
||||
#include "TRK_MINNOW_DOLPHIN/MetroTRK/Portable/main_TRK.h"
|
||||
#include "TRK_MINNOW_DOLPHIN/Os/dolphin/dolphin_trk_glue.h"
|
||||
#include "TRK_MINNOW_DOLPHIN/ppc/Generic/targimpl.h"
|
||||
#include "dolphin/ar.h"
|
||||
#include <dolphin/ar.h>
|
||||
#include "global.h"
|
||||
#include "__ar.h"
|
||||
|
||||
#define EXCEPTIONMASK_ADDR 0x80000044
|
||||
|
||||
@@ -330,4 +332,4 @@ initCommTableSuccess:
|
||||
b TRK_main //Jump to TRK_main
|
||||
blr
|
||||
// clang-format on
|
||||
}
|
||||
}
|
||||
|
||||
@@ -48,7 +48,7 @@ int InitMetroTRKCommTable(int hwId) {
|
||||
OSReport("MetroTRK : Set to GDEV hardware\n");
|
||||
// Initialize gDBCommTable
|
||||
result = Hu_IsStub();
|
||||
gDBCommTable.initialize_func = gdev_cc_initialize;
|
||||
gDBCommTable.initialize_func = (DBCommInitFunc)gdev_cc_initialize;
|
||||
gDBCommTable.open_func = gdev_cc_open;
|
||||
gDBCommTable.close_func = gdev_cc_close;
|
||||
gDBCommTable.read_func = gdev_cc_read;
|
||||
@@ -63,7 +63,7 @@ int InitMetroTRKCommTable(int hwId) {
|
||||
OSReport("MetroTRK : Set to AMC DDH hardware\n");
|
||||
result = AMC_IsStub();
|
||||
// Initialize gDBCommTable
|
||||
gDBCommTable.initialize_func = ddh_cc_initialize;
|
||||
gDBCommTable.initialize_func = (DBCommInitFunc)ddh_cc_initialize;
|
||||
gDBCommTable.open_func = ddh_cc_open;
|
||||
gDBCommTable.close_func = ddh_cc_close;
|
||||
gDBCommTable.read_func = ddh_cc_read;
|
||||
@@ -186,4 +186,4 @@ lbl_80371C20:
|
||||
lwz r31, OSContext.gpr[31](r31)
|
||||
b TRKInterruptHandler
|
||||
// clang-format on
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#include "TRK_MINNOW_DOLPHIN/utils/common/CircleBuffer.h"
|
||||
#include "TRK_MINNOW_DOLPHIN/utils/common/MWTrace.h"
|
||||
#include "amcstubs/AmcExi2Stubs.h"
|
||||
#include <dolphin/amc/AmcExi2Comm.h>
|
||||
|
||||
#define DDH_ERR_NOT_INITIALIZED -0x2711
|
||||
#define DDH_ERR_ALREADY_INITIALIZED -0x2715
|
||||
@@ -18,7 +18,7 @@ static u8 gRecvBuf[DDH_BUF_SIZE];
|
||||
static BOOL gIsInitialized;
|
||||
|
||||
/* 80372618-803726A0 36CF58 0088+00 0/0 1/1 0/0 .text ddh_cc_initialize */
|
||||
int ddh_cc_initialize(void* inputPendingPtrRef, AmcEXICallback monitorCallback) {
|
||||
int ddh_cc_initialize(void* inputPendingPtrRef, EXICallback monitorCallback) {
|
||||
MWTRACE(1, "CALLING EXI2_Init\n");
|
||||
EXI2_Init(inputPendingPtrRef, monitorCallback);
|
||||
MWTRACE(1, "DONE CALLING EXI2_Init\n");
|
||||
@@ -147,4 +147,4 @@ int ddh_cc_peek() {
|
||||
int ddh_cc_initinterrupts() {
|
||||
EXI2_EnableInterrupts();
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
#include "TRK_MINNOW_DOLPHIN/utils/common/CircleBuffer.h"
|
||||
#include "TRK_MINNOW_DOLPHIN/utils/common/MWTrace.h"
|
||||
#include "dolphin/db.h"
|
||||
#include <dolphin/db.h>
|
||||
#include <dolphin/amc/AmcExi2Comm.h>
|
||||
|
||||
#define GDEV_BUF_SIZE (0x500)
|
||||
|
||||
@@ -14,9 +15,9 @@ static u8 gRecvBuf[GDEV_BUF_SIZE];
|
||||
static BOOL gIsInitialized;
|
||||
|
||||
/* 80372BCC-80372C54 36D50C 0088+00 0/0 1/1 0/0 .text gdev_cc_initialize */
|
||||
int gdev_cc_initialize(void* inputPendingPtrRef, AmcEXICallback monitorCallback) {
|
||||
int gdev_cc_initialize(void* inputPendingPtrRef, EXICallback monitorCallback) {
|
||||
MWTRACE(1, "CALLING EXI2_Init\n");
|
||||
DBInitComm(inputPendingPtrRef, monitorCallback);
|
||||
DBInitComm(inputPendingPtrRef, (int*)monitorCallback);
|
||||
MWTRACE(1, "DONE CALLING EXI2_Init\n");
|
||||
CircleBufferInitialize(&gRecvCB, gRecvBuf, GDEV_BUF_SIZE);
|
||||
return 0;
|
||||
@@ -129,7 +130,7 @@ int gdev_cc_peek() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (DBRead(buff, poll) == 0) {
|
||||
if ((int)DBRead(buff, poll) == 0) {
|
||||
CircleBufferWriteBytes(&gRecvCB, buff, poll);
|
||||
} else {
|
||||
return -0x2719;
|
||||
@@ -142,4 +143,4 @@ int gdev_cc_peek() {
|
||||
int gdev_cc_initinterrupts() {
|
||||
DBInitInterrupts();
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3,10 +3,10 @@
|
||||
* Description:
|
||||
*/
|
||||
|
||||
#include "amcstubs/AmcExi2Stubs.h"
|
||||
#include <dolphin/amc/AmcExi2Comm.h>
|
||||
|
||||
/* 80372CFC-80372D00 36D63C 0004+00 0/0 1/1 0/0 .text EXI2_Init */
|
||||
void EXI2_Init(vu8**, AmcEXICallback) {}
|
||||
void EXI2_Init(vu8**, EXICallback) {}
|
||||
|
||||
/* 80372D00-80372D04 36D640 0004+00 0/0 1/1 0/0 .text EXI2_EnableInterrupts */
|
||||
void EXI2_EnableInterrupts(void) {}
|
||||
@@ -35,4 +35,4 @@ void EXI2_Unreserve(void) {}
|
||||
/* 80372D24-80372D2C 36D664 0008+00 0/0 1/1 0/0 .text AMC_IsStub */
|
||||
BOOL AMC_IsStub(void) {
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -451,7 +451,7 @@ int daAlink_c::jointControll(int param_0) {
|
||||
mDoMtx_stack_c::inverse();
|
||||
cMtx_concat(temp_r26, mDoMtx_stack_c::get(), J3DSys::mCurrentMtx);
|
||||
|
||||
MTXQuat(temp_r26, (PSQuaternion*)spC);
|
||||
MTXQuat(temp_r26, spC);
|
||||
|
||||
temp_r26[0][3] = var_r25->mTranslate.x;
|
||||
temp_r26[1][3] = var_r25->mTranslate.y;
|
||||
@@ -478,7 +478,7 @@ void daAlink_c::setUpperFront() {
|
||||
|
||||
Quaternion sp8;
|
||||
JMAEulerToQuat(sp18.mRotation.x, sp18.mRotation.y, sp18.mRotation.z, &sp8);
|
||||
MTXQuat(temp_r28, (PSQuaternion*)&sp8);
|
||||
MTXQuat(temp_r28, &sp8);
|
||||
|
||||
cMtx_concat(mpLinkModel->getBaseTRMtx(), temp_r28, J3DSys::mCurrentMtx);
|
||||
J3DSys::mCurrentMtx[0][3] = mRootMtx[0][3];
|
||||
|
||||
@@ -1857,7 +1857,7 @@ void daAlink_blur_c::draw() {
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, 1, GX_TEVPREV);
|
||||
GXLoadPosMtxImm(j3dSys.getViewMtx(), GX_PNMTX0);
|
||||
GXSetCurrentMtx(0);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
GXSetCullMode(GX_CULL_NONE);
|
||||
GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_DISABLE);
|
||||
GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_OR, GX_GREATER, 0);
|
||||
|
||||
+1575
-1162
File diff suppressed because it is too large
Load Diff
+744
-1003
File diff suppressed because it is too large
Load Diff
@@ -65,8 +65,6 @@ struct dPa_levelEcallBack {};
|
||||
|
||||
struct csXyz {};
|
||||
|
||||
struct _GXColor {};
|
||||
|
||||
struct dPa_control_c {
|
||||
/* 8004CA90 */ void set(u8, u16, cXyz const*, dKy_tevstr_c const*, csXyz const*, cXyz const*,
|
||||
u8, dPa_levelEcallBack*, s8, _GXColor const*, _GXColor const*,
|
||||
@@ -144,8 +142,6 @@ struct cBgS {
|
||||
/* 800744A0 */ void GroundCross(cBgS_GndChk*);
|
||||
};
|
||||
|
||||
struct _GXTexObj {};
|
||||
|
||||
struct LIGHT_INFLUENCE {};
|
||||
|
||||
struct J3DUClipper {
|
||||
|
||||
@@ -10,6 +10,7 @@
|
||||
#include "dol2asm.h"
|
||||
#include "m_Do/m_Do_lib.h"
|
||||
#include "string.h"
|
||||
#include <dolphin/gd.h>
|
||||
|
||||
//
|
||||
// Forward References:
|
||||
|
||||
@@ -456,7 +456,7 @@ int daHorse_c::modelCallBack(int i_jntNo) {
|
||||
|
||||
MtxP m = m_model->getAnmMtx(i_jntNo);
|
||||
cMtx_concat(m, mDoMtx_stack_c::get(), J3DSys::mCurrentMtx);
|
||||
MTXQuat(m, (PSQuaternion*)&sp20);
|
||||
MTXQuat(m, &sp20);
|
||||
m[0][3] = var_r27->mTranslate.x;
|
||||
m[1][3] = var_r27->mTranslate.y;
|
||||
m[2][3] = var_r27->mTranslate.z;
|
||||
|
||||
@@ -98,7 +98,7 @@ void dMirror_packet_c::mirrorZdraw(f32* param_0, f32* param_1, f32 param_2, f32
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_A0);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetZCompLoc(GX_TRUE);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_OR);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_OR);
|
||||
GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_OR, GX_GREATER, 0);
|
||||
GXSetFog(GX_FOG_NONE, 0.0f, 0.0f, 0.0f, 0.0f, g_clearColor);
|
||||
GXSetFogRangeAdj(0, 0, NULL);
|
||||
|
||||
@@ -2735,7 +2735,7 @@ static BOOL daMP_VideoDecodeThreadCreated;
|
||||
/* 80875B18-80875BC8 003438 00B0+00 1/1 0/0 0/0 .text daMP_CreateReadThread__Fl */
|
||||
static BOOL daMP_CreateReadThread(s32 param_0) {
|
||||
// NONMATCHING
|
||||
if (!OSCreateThread(&daMP_ReadThread, daMP_Reader, 0, daMP_ReadThreadStack + sizeof(daMP_ReadThreadStack), sizeof(daMP_ReadThreadStack), param_0, 1)) {
|
||||
if (!OSCreateThread(&daMP_ReadThread, (void*(*)(void*))daMP_Reader, 0, daMP_ReadThreadStack + sizeof(daMP_ReadThreadStack), sizeof(daMP_ReadThreadStack), param_0, 1)) {
|
||||
OSReport("Can't create read thread\n");
|
||||
return 0;
|
||||
}
|
||||
@@ -2817,12 +2817,12 @@ static void daMP_VideoDecoderForOnMemory(void* param_0) {
|
||||
*/
|
||||
static int daMP_CreateVideoDecodeThread(s32 param_0, u8* param_1) {
|
||||
if (param_1 != NULL) {
|
||||
if (!OSCreateThread(&daMP_VideoDecodeThread, daMP_VideoDecoderForOnMemory, param_1, daMP_VideoDecodeThreadStack + sizeof(daMP_VideoDecodeThreadStack), sizeof(daMP_VideoDecodeThreadStack), param_0, 1)) {
|
||||
if (!OSCreateThread(&daMP_VideoDecodeThread, (void*(*)(void*))daMP_VideoDecoderForOnMemory, param_1, daMP_VideoDecodeThreadStack + sizeof(daMP_VideoDecodeThreadStack), sizeof(daMP_VideoDecodeThreadStack), param_0, 1)) {
|
||||
OSReport("Can't create video decode thread\n");
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
if (!OSCreateThread(&daMP_VideoDecodeThread, daMP_VideoDecoder, NULL, daMP_VideoDecodeThreadStack + sizeof(daMP_VideoDecodeThreadStack), sizeof(daMP_VideoDecodeThreadStack), param_0, 1)) {
|
||||
if (!OSCreateThread(&daMP_VideoDecodeThread, (void*(*)(void*))daMP_VideoDecoder, NULL, daMP_VideoDecodeThreadStack + sizeof(daMP_VideoDecodeThreadStack), sizeof(daMP_VideoDecodeThreadStack), param_0, 1)) {
|
||||
OSReport("Can't create video decode thread\n");
|
||||
return 0;
|
||||
}
|
||||
@@ -2924,11 +2924,11 @@ static OSMessage daMP_DecodedAudioBufferMessage[3];
|
||||
*/
|
||||
static int daMP_CreateAudioDecodeThread(s32 param_0, u8* param_1) {
|
||||
if (param_1 != NULL) {
|
||||
if (!OSCreateThread(&daMP_AudioDecodeThread, daMP_AudioDecoderForOnMemory, param_1, daMP_AudioDecodeThreadStack + sizeof(daMP_AudioDecodeThreadStack), sizeof(daMP_AudioDecodeThreadStack), param_0, 1)) {
|
||||
if (!OSCreateThread(&daMP_AudioDecodeThread, (void*(*)(void*))daMP_AudioDecoderForOnMemory, param_1, daMP_AudioDecodeThreadStack + sizeof(daMP_AudioDecodeThreadStack), sizeof(daMP_AudioDecodeThreadStack), param_0, 1)) {
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
if (!OSCreateThread(&daMP_AudioDecodeThread, daMP_AudioDecoder, NULL, daMP_AudioDecodeThreadStack + sizeof(daMP_AudioDecodeThreadStack), sizeof(daMP_AudioDecodeThreadStack), param_0, 1)) {
|
||||
if (!OSCreateThread(&daMP_AudioDecodeThread, (void*(*)(void*))daMP_AudioDecoder, NULL, daMP_AudioDecodeThreadStack + sizeof(daMP_AudioDecodeThreadStack), sizeof(daMP_AudioDecodeThreadStack), param_0, 1)) {
|
||||
OSReport("Can't create audio decode thread\n");
|
||||
return 0;
|
||||
}
|
||||
@@ -2985,8 +2985,8 @@ static f32 dummyLiteral() {
|
||||
* daMP_THPGXYuv2RgbSetup__FPC16_GXRenderModeObj */
|
||||
// NONMATCHING - stack slightly too small
|
||||
static void daMP_THPGXYuv2RgbSetup(GXRenderModeObj const* param_0) {
|
||||
int width = param_0->fb_width;
|
||||
int height = param_0->efb_height;
|
||||
int width = param_0->fbWidth;
|
||||
int height = param_0->efbHeight;
|
||||
f32 var_f31 = 0.0f;
|
||||
Mtx sp50;
|
||||
Mtx sp20;
|
||||
@@ -3452,7 +3452,7 @@ static void daMP_THPPlayerStop() {
|
||||
VISetPostRetraceCallback(daMP_OldVIPostCallback);
|
||||
|
||||
if (daMP_ActivePlayer.field_0xb0 == 0) {
|
||||
DVDCancel(&daMP_ActivePlayer.mFileInfo.block);
|
||||
DVDCancel(&daMP_ActivePlayer.mFileInfo.cb);
|
||||
daMP_ReadThreadCancel();
|
||||
}
|
||||
|
||||
@@ -3557,8 +3557,8 @@ static BOOL daMP_ActivePlayer_Init(char const* moviePath) {
|
||||
daMP_THPPlayerGetVideoInfo(&daMP_videoInfo);
|
||||
daMP_THPPlayerGetAudioInfo(&daMP_audioInfo);
|
||||
|
||||
u16 var_r31 = JUTVideo::getManager()->getRenderMode()->fb_width;
|
||||
u16 temp_r4 = JUTVideo::getManager()->getRenderMode()->efb_height;
|
||||
u16 var_r31 = JUTVideo::getManager()->getRenderMode()->fbWidth;
|
||||
u16 temp_r4 = JUTVideo::getManager()->getRenderMode()->efbHeight;
|
||||
|
||||
daMP_DrawPosX = (var_r31 - daMP_videoInfo.field_0x0) >> 1;
|
||||
daMP_DrawPosY = (temp_r4 - daMP_videoInfo.field_0x4) >> 1;
|
||||
|
||||
@@ -66,7 +66,6 @@ extern "C" void __construct_array();
|
||||
extern "C" void __cvt_fp2unsigned();
|
||||
extern "C" void _savegpr_26();
|
||||
extern "C" void _restgpr_26();
|
||||
extern "C" void sprintf();
|
||||
extern "C" u8 now__14mDoMtx_stack_c[48];
|
||||
extern "C" extern u8 g_dComIfG_gameInfo[122384];
|
||||
extern "C" u8 mCurrentMtx__6J3DSys[48];
|
||||
|
||||
@@ -109,7 +109,6 @@ extern "C" void _restgpr_23();
|
||||
extern "C" void _restgpr_26();
|
||||
extern "C" void _restgpr_28();
|
||||
extern "C" void _restgpr_29();
|
||||
extern "C" void sprintf();
|
||||
extern "C" extern void* __vt__8dCcD_Sph[36];
|
||||
extern "C" extern void* __vt__8dCcD_Cyl[36];
|
||||
extern "C" extern void* __vt__9dCcD_Stts[11];
|
||||
|
||||
@@ -88,7 +88,6 @@ extern "C" void _restgpr_26();
|
||||
extern "C" void _restgpr_27();
|
||||
extern "C" void _restgpr_28();
|
||||
extern "C" void _restgpr_29();
|
||||
extern "C" void sprintf();
|
||||
extern "C" extern void* __vt__8dCcD_Sph[36];
|
||||
extern "C" extern void* __vt__9dCcD_Stts[11];
|
||||
extern "C" extern void* __vt__12cCcD_SphAttr[25];
|
||||
|
||||
@@ -87,7 +87,7 @@ int daTag_ShopItem_c::Delete() {
|
||||
|
||||
/* 80D60E04-80D61024 000304 0220+00 1/1 0/0 0/0 .text Execute__16daTag_ShopItem_cFv */
|
||||
int daTag_ShopItem_c::Execute() {
|
||||
if (mProcessID == UINT32_MAX) {
|
||||
if (mProcessID == fpcM_ERROR_PROCESS_ID_e) {
|
||||
if (mCreateTimer == 0) {
|
||||
mProcessID =
|
||||
fopAcM_create(PROC_ShopItem, (getType() & 0xFF) | (getGroupID() << 0x1C),
|
||||
|
||||
+15
-15
@@ -22,19 +22,19 @@ inline daYkgr_HIO_c::daYkgr_HIO_c() {
|
||||
}
|
||||
|
||||
inline dPa_YkgrPcallBack::dPa_YkgrPcallBack() {
|
||||
field_0x4 = 0.5f;
|
||||
field_0x8 = 0.0f;
|
||||
field_0xc = 0.0f;
|
||||
field_0x10 = 0.0f;
|
||||
field_0x14 = 0.5f;
|
||||
field_0x18 = 0.0f;
|
||||
field_0x4[0][0] = 0.5f;
|
||||
field_0x4[0][1] = 0.0f;
|
||||
field_0x4[0][2] = 0.0f;
|
||||
field_0x4[1][0] = 0.0f;
|
||||
field_0x4[1][1] = 0.5f;
|
||||
field_0x4[1][2] = 0.0f;
|
||||
field_0x1c = 1;
|
||||
}
|
||||
|
||||
/* 805A848C-805A84D4 0000EC 0048+00 1/0 0/0 0/0 .text
|
||||
* draw__17dPa_YkgrPcallBackFP14JPABaseEmitterP15JPABaseParticle */
|
||||
void dPa_YkgrPcallBack::draw(JPABaseEmitter* param_0, JPABaseParticle* param_1) {
|
||||
GXSetIndTexMtx(GX_ITM_0, &field_0x4, field_0x1c);
|
||||
GXSetIndTexMtx(GX_ITM_0, field_0x4, field_0x1c);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_A0);
|
||||
}
|
||||
|
||||
@@ -44,19 +44,19 @@ void dPa_YkgrPcallBack::setParam(f32 param_1) {
|
||||
if (param_1 >= 0.0f) {
|
||||
field_0x1c = param_1;
|
||||
f32 fVar1 = (param_1 - field_0x1c) * 0.5f + 0.5f;
|
||||
field_0x14 = fVar1;
|
||||
field_0x4 = fVar1;
|
||||
field_0x4[1][1] = fVar1;
|
||||
field_0x4[0][0] = fVar1;
|
||||
} else {
|
||||
f32 x = param_1 - 1.0f;
|
||||
field_0x1c = x;
|
||||
f32 fVar1 = (x - field_0x1c) * 0.5f + 1.0f;
|
||||
field_0x14 = fVar1;
|
||||
field_0x4 = fVar1;
|
||||
field_0x4[1][1] = fVar1;
|
||||
field_0x4[0][0] = fVar1;
|
||||
}
|
||||
field_0x8 = 0.0f;
|
||||
field_0xc = 0.0f;
|
||||
field_0x10 = 0.0f;
|
||||
field_0x18 = 0.0f;
|
||||
field_0x4[0][1] = 0.0f;
|
||||
field_0x4[0][2] = 0.0f;
|
||||
field_0x4[1][0] = 0.0f;
|
||||
field_0x4[1][2] = 0.0f;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -224,7 +224,7 @@ void dDlst_2DTri_c::draw() {
|
||||
GXSetNumTevStages(1);
|
||||
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
|
||||
GXSetTevOp(GX_TEVSTAGE0, GX_PASSCLR);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
GXLoadPosMtxImm(mDoMtx_getIdentity(), GX_PNMTX0);
|
||||
GXSetCurrentMtx(GX_PNMTX0);
|
||||
GXBegin(GX_TRIANGLES, GX_VTXFMT0, 3);
|
||||
@@ -247,7 +247,7 @@ void dDlst_2DQuad_c::draw() {
|
||||
GXSetNumTevStages(1);
|
||||
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
|
||||
GXSetTevOp(GX_TEVSTAGE0, GX_PASSCLR);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
GXLoadPosMtxImm(mDoMtx_getIdentity(), GX_PNMTX0);
|
||||
GXSetCurrentMtx(GX_PNMTX0);
|
||||
GXBegin(GX_QUADS, GX_VTXFMT0, 4);
|
||||
@@ -271,7 +271,7 @@ void dDlst_2DPoint_c::draw() {
|
||||
GXSetNumTevStages(1);
|
||||
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
|
||||
GXSetTevOp(GX_TEVSTAGE0, GX_PASSCLR);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
GXSetPointSize(field_0xc, GX_TO_ZERO);
|
||||
GXLoadPosMtxImm(mDoMtx_getIdentity(), GX_PNMTX0);
|
||||
GXSetCurrentMtx(GX_PNMTX0);
|
||||
@@ -365,7 +365,7 @@ void dDlst_2DT2_c::draw() {
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, 1, GX_TEVPREV);
|
||||
GXSetZCompLoc(GX_FALSE);
|
||||
GXSetZMode(GX_DISABLE, GX_ALWAYS, GX_DISABLE);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_CLEAR);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
|
||||
GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_OR, GX_GREATER, 0);
|
||||
GXSetFog(GX_FOG_NONE, 0.0f, 0.0f, 0.0f, 0.0f, g_clearColor);
|
||||
GXSetCullMode(GX_CULL_NONE);
|
||||
@@ -743,7 +743,7 @@ void dDlst_2DM_c::draw() {
|
||||
GXSetTevColorOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, 1, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE1, GX_CA_ZERO, GX_CA_TEXA, GX_CA_APREV, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, 1, GX_TEVPREV);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
GXBegin(GX_QUADS, GX_VTXFMT0, 4);
|
||||
GXPosition3s16((s32)field_0x4, (s32)field_0x6, 0);
|
||||
GXTexCoord2s16(r31, r30);
|
||||
@@ -807,7 +807,7 @@ void dDlst_2Dm_c::draw() {
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE1, GX_CA_ZERO, GX_CA_TEXA, GX_CA_APREV, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, 1, GX_TEVPREV);
|
||||
GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_OR, GX_GREATER, 0);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
GXLoadPosMtxImm(g_mDoMtx_identity, GX_PNMTX0);
|
||||
GXSetCurrentMtx(0);
|
||||
GXBegin(GX_QUADS, GX_VTXFMT0, 4);
|
||||
@@ -861,7 +861,7 @@ void dDlst_2DMt_c::draw() {
|
||||
GXSetNumChans(0);
|
||||
GXSetNumTexGens(r28);
|
||||
GXSetNumTevStages(r28);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
GXBegin(GX_QUADS, GX_VTXFMT0, 4);
|
||||
GXPosition3s16(field_0xc, field_0xe, 0);
|
||||
dDlst_2DMt_tex_c* tmp = field_0x8;
|
||||
@@ -980,7 +980,7 @@ void dDlst_effectLine_c::draw() {
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_A0);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, 1, GX_TEVPREV);
|
||||
GXSetZMode(GX_DISABLE, GX_LEQUAL, GX_DISABLE);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_CLEAR);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
|
||||
GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
|
||||
GXSetCullMode(GX_CULL_NONE);
|
||||
GXLoadPosMtxImm(j3dSys.mViewMtx, GX_PNMTX0);
|
||||
@@ -1548,7 +1548,7 @@ void dDlst_shadowControl_c::imageDraw(Mtx param_0) {
|
||||
/* 80055A14-80055C74 050354 0260+00 0/0 1/1 0/0 .text draw__21dDlst_shadowControl_cFPA4_f
|
||||
*/
|
||||
void dDlst_shadowControl_c::draw(Mtx param_0) {
|
||||
static GXTevColor l_tevColorChan[4] = {
|
||||
static GXTevColorChan l_tevColorChan[4] = {
|
||||
GX_CH_RED,
|
||||
GX_CH_GREEN,
|
||||
GX_CH_BLUE,
|
||||
|
||||
@@ -211,7 +211,7 @@ static void drawCapture(u8 alpha) {
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetZCompLoc(GX_TRUE);
|
||||
GXSetZMode(GX_DISABLE, GX_ALWAYS, GX_DISABLE);
|
||||
GXSetBlendMode(GX_BM_NONE, GX_BL_SRC_ALPHA, GX_BL_ONE, GX_LO_CLEAR);
|
||||
GXSetBlendMode(GX_BM_NONE, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_CLEAR);
|
||||
GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
|
||||
GXSetFog(GX_FOG_NONE, 0.0f, 0.0f, 0.0f, 0.0f, g_clearColor);
|
||||
GXSetFogRangeAdj(GX_DISABLE, 0, NULL);
|
||||
|
||||
@@ -434,7 +434,7 @@ void dEvDtStaff_c::specialProcMessage() {
|
||||
break;
|
||||
case 'CREA':
|
||||
case 'SHOW':
|
||||
work->_0 = UINT32_MAX;
|
||||
work->_0 = UINT_MAX;
|
||||
work->mLMsg = NULL;
|
||||
work->mMsgSubstanceNum = dComIfGp_evmng_getMySubstanceNum(staffId, "msgNo");
|
||||
work->mMsgSubstanceP = dComIfGp_evmng_getMyIntegerP(staffId, "msgNo");
|
||||
@@ -498,7 +498,7 @@ void dEvDtStaff_c::specialProcMessage() {
|
||||
switch (data->unk) {
|
||||
case 0:
|
||||
work->_0 = fopMsgM_messageSet(work->mMsgNo, 1000);
|
||||
if (work->_0 != UINT32_MAX) {
|
||||
if (work->_0 != UINT_MAX) {
|
||||
data->unk++;
|
||||
}
|
||||
break;
|
||||
@@ -525,7 +525,7 @@ void dEvDtStaff_c::specialProcMessage() {
|
||||
switch (data->unk) {
|
||||
case 0:
|
||||
work->_0 = fopMsgM_messageSet(work->mMsgNo, 1000);
|
||||
if (work->_0 != UINT32_MAX) {
|
||||
if (work->_0 != UINT_MAX) {
|
||||
data->unk = 1;
|
||||
} else {
|
||||
break;
|
||||
@@ -544,7 +544,7 @@ void dEvDtStaff_c::specialProcMessage() {
|
||||
break;
|
||||
case 0x12:
|
||||
work->mLMsg->mode = 0x13;
|
||||
work->_0 = UINT32_MAX;
|
||||
work->_0 = UINT_MAX;
|
||||
work->mLMsg = NULL;
|
||||
work->mMsgSubstanceNum--;
|
||||
if (work->mMsgSubstanceNum != 0) {
|
||||
@@ -571,7 +571,7 @@ void dEvDtStaff_c::specialProcMessage() {
|
||||
dComIfGp_evmng_cutEnd(staffId);
|
||||
} else if (work->mLMsg->mode == 0x12) {
|
||||
work->mLMsg->mode = 0x13;
|
||||
work->_0 = UINT32_MAX;
|
||||
work->_0 = UINT_MAX;
|
||||
work->mLMsg = NULL;
|
||||
dComIfGp_evmng_cutEnd(staffId);
|
||||
}
|
||||
@@ -677,7 +677,7 @@ void dEvDtStaff_c::specialProcCreate() {
|
||||
|
||||
int* argP = dComIfGp_evmng_getMyIntegerP(staffId, "ARG");
|
||||
if (argP == NULL) {
|
||||
arg = UINT32_MAX;
|
||||
arg = UINT_MAX;
|
||||
} else {
|
||||
arg = *argP;
|
||||
}
|
||||
|
||||
@@ -177,8 +177,8 @@ static procFunc fileWarningProc[] = {&dFile_info_c::modeWait, &dFile_info_c::mod
|
||||
void dFile_info_c::setSaveDate(dSv_save_c* i_savedata) {
|
||||
OSCalendarTime time;
|
||||
OSTicksToCalendarTime(i_savedata->getPlayer().getPlayerStatusB().getDateIpl(), &time);
|
||||
sprintf(mSaveDate, "%02d/%02d/%d %02d:%02d", time.month + 1, time.day_of_month, time.year,
|
||||
time.hours, time.minutes);
|
||||
sprintf(mSaveDate, "%02d/%02d/%d %02d:%02d", time.mon + 1, time.mday, time.year,
|
||||
time.hour, time.min);
|
||||
}
|
||||
|
||||
/* 80192C70-80192D58 18D5B0 00E8+00 1/1 0/0 0/0 .text setPlayTime__12dFile_info_cFP10dSv_save_c */
|
||||
|
||||
@@ -535,9 +535,9 @@ s32 d_GameOver_Create(u8 i_gameoverType) {
|
||||
|
||||
/* 8019C008-8019C06C 196948 0064+00 0/0 1/1 0/0 .text d_GameOver_Delete__FRUi */
|
||||
bool d_GameOver_Delete(fpc_ProcID& i_id) {
|
||||
if (i_id != UINT32_MAX) {
|
||||
if (i_id != fpcM_ERROR_PROCESS_ID_e) {
|
||||
fopMsgM_Delete(fopMsgM_SearchByID(i_id));
|
||||
i_id = -1;
|
||||
i_id = fpcM_ERROR_PROCESS_ID_e;
|
||||
dMeter2Info_setGameOverType(0);
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
#include "d/d_kankyo.h"
|
||||
#include <dolphin.h>
|
||||
#include <dolphin/gf/GFPixel.h>
|
||||
#include "SSystem/SComponent/c_counter.h"
|
||||
#include "SSystem/SComponent/c_math.h"
|
||||
#include "d/actor/d_a_kytag08.h"
|
||||
|
||||
@@ -811,8 +811,8 @@ static GXFogAdjTable S_xfog_table_data[2] = {
|
||||
/* 80056A24-80056A64 051364 0040+00 0/0 2/2 0/0 .text dKyd_xfog_table_set__FUc */
|
||||
void dKyd_xfog_table_set(u8 tblIdx) {
|
||||
for (int i = 0; i < 10; i++) {
|
||||
u16 fogAdjTableEntry = S_xfog_table_data[tblIdx & 0xff].fogVals[i];
|
||||
g_env_light.mXFogTbl.fogVals[i] = fogAdjTableEntry;
|
||||
u16 fogAdjTableEntry = S_xfog_table_data[tblIdx & 0xff].r[i];
|
||||
g_env_light.mXFogTbl.r[i] = fogAdjTableEntry;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+21
-21
@@ -2167,7 +2167,7 @@ static void dKyr_draw_rev_moon(Mtx drawMtx, u8** tex) {
|
||||
GXSetTevColorOp(GX_TEVSTAGE2, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_FALSE, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE2, GX_CA_ZERO, GX_CA_TEXA, GX_CA_APREV, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE2, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_FALSE, GX_TEVPREV);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_COPY);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_COPY);
|
||||
GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_OR, GX_GREATER, 0);
|
||||
GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_DISABLE);
|
||||
GXSetNumIndStages(0);
|
||||
@@ -2232,7 +2232,7 @@ static void dKyr_draw_rev_moon(Mtx drawMtx, u8** tex) {
|
||||
GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_A0, GX_CA_TEXA, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_ONE, GX_LO_COPY);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_COPY);
|
||||
|
||||
size *= 2.3f;
|
||||
color_reg0.a = 40.0f * sun_packet->mMoonAlpha;
|
||||
@@ -2510,7 +2510,7 @@ void dKyr_drawSun(Mtx drawMtx, cXyz* ppos, GXColor& unused, u8** tex) {
|
||||
GXSetTevColorOp(GX_TEVSTAGE2, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_FALSE, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE2, GX_CA_ZERO, GX_CA_TEXA, GX_CA_APREV, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE2, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_FALSE, GX_TEVPREV);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_COPY);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_COPY);
|
||||
GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_OR, GX_GREATER, 0);
|
||||
GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_DISABLE);
|
||||
GXSetNumIndStages(0);
|
||||
@@ -2589,7 +2589,7 @@ void dKyr_drawSun(Mtx drawMtx, cXyz* ppos, GXColor& unused, u8** tex) {
|
||||
GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_A0, GX_CA_TEXA, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_ONE, GX_LO_COPY);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_COPY);
|
||||
|
||||
size *= 2.3f;
|
||||
color_reg0.a = 40.0f * sun_packet->mMoonAlpha;
|
||||
@@ -2753,7 +2753,7 @@ void dKyr_drawLenzflare(Mtx drawMtx, cXyz* ppos, GXColor& param_2, u8** tex) {
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_A0, GX_CA_TEXA, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetFog(GX_FOG_NONE, 0.0f, 1.0f, 0.1f, 1.0f, color_reg0);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_OR, GX_GREATER, 0);
|
||||
GXSetZCompLoc(GX_TRUE);
|
||||
GXSetZMode(GX_DISABLE, GX_LEQUAL, GX_DISABLE);
|
||||
@@ -2933,7 +2933,7 @@ void dKyr_drawLenzflare(Mtx drawMtx, cXyz* ppos, GXColor& param_2, u8** tex) {
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_A0, GX_CA_TEXA, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetFog(GX_FOG_NONE, 0.0f, 1.0f, 0.1f, 1.0f, color_reg0);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_OR, GX_GREATER, 0);
|
||||
GXSetZCompLoc(GX_TRUE);
|
||||
GXSetZMode(GX_DISABLE, GX_LEQUAL, GX_DISABLE);
|
||||
@@ -2965,7 +2965,7 @@ void dKyr_drawLenzflare(Mtx drawMtx, cXyz* ppos, GXColor& param_2, u8** tex) {
|
||||
color_reg0.a = sun_packet->field_0x6c * (0.2f * (spC4 * col_dat[i].a));
|
||||
}
|
||||
} else if (i == 2) {
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_ONE, GX_LO_COPY);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_COPY);
|
||||
GXColorS10 spD0;
|
||||
spD0.r = 0.5f * sun_packet->mColor.r;
|
||||
spD0.g = 0.5f * sun_packet->mColor.g;
|
||||
@@ -3153,7 +3153,7 @@ void dKyr_drawRain(Mtx drawMtx, u8** tex) {
|
||||
GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_A0, GX_CA_TEXA, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_OR, GX_GREATER, 0);
|
||||
GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_DISABLE);
|
||||
GXSetClipMode(GX_CLIP_DISABLE);
|
||||
@@ -3320,7 +3320,7 @@ void dKyr_drawSibuki(Mtx drawMtx, u8** tex) {
|
||||
GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_A0, GX_CA_TEXA, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_ONE, GX_LO_COPY);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_COPY);
|
||||
GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_OR, GX_GREATER, 0);
|
||||
GXSetZMode(GX_TRUE, GX_GEQUAL, GX_FALSE);
|
||||
GXSetClipMode(GX_CLIP_DISABLE);
|
||||
@@ -3501,9 +3501,9 @@ void dKyr_drawHousi(Mtx drawMtx, u8** tex) {
|
||||
if (strcmp(dComIfGp_getStartStageName(), "F_NW01") == 0 ||
|
||||
g_env_light.field_0xea9 == 1)
|
||||
{
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_ONE, GX_LO_COPY);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_COPY);
|
||||
} else {
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA,
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA,
|
||||
GX_LO_SET);
|
||||
}
|
||||
|
||||
@@ -3828,7 +3828,7 @@ void dKyr_drawSnow(Mtx drawMtx, u8** tex) {
|
||||
GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_A0, GX_CA_TEXA, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_ONE, GX_LO_COPY);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_COPY);
|
||||
GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_OR, GX_GREATER, 0);
|
||||
GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_DISABLE);
|
||||
GXSetClipMode(GX_CLIP_DISABLE);
|
||||
@@ -4136,7 +4136,7 @@ void dKyr_drawStar(Mtx drawMtx, u8** tex) {
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_ZERO, GX_CA_ZERO, GX_CA_A0);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_DISABLE);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_CLEAR);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
|
||||
GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_OR, GX_GREATER, 0);
|
||||
GXSetNumIndStages(0);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, GX_F32, 0);
|
||||
@@ -4378,9 +4378,9 @@ void drawCloudShadow(Mtx drawMtx, u8** tex) {
|
||||
dKy_GxFog_set();
|
||||
|
||||
if (g_env_light.mMoyaMode == 3 || g_env_light.mMoyaMode == 4 || g_env_light.mMoyaMode == 6 || g_env_light.mMoyaMode == 10 || g_env_light.mMoyaMode == 11) {
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_ONE, GX_LO_COPY);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_ONE, GX_LO_COPY);
|
||||
} else {
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
}
|
||||
|
||||
GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_OR, GX_GREATER, 0);
|
||||
@@ -4451,7 +4451,7 @@ void drawCloudShadow(Mtx drawMtx, u8** tex) {
|
||||
GXSetTevColorOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_FALSE, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE1, GX_CA_ZERO, GX_CA_A0, GX_CA_TEXA, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_FALSE, GX_TEVPREV);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_COPY);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_COPY);
|
||||
GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
|
||||
GXSetZCompLoc(GX_TRUE);
|
||||
GXSetZMode(GX_DISABLE, GX_LEQUAL, GX_DISABLE);
|
||||
@@ -4653,7 +4653,7 @@ void drawVrkumo(Mtx drawMtx, GXColor& color, u8** tex) {
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_A0, GX_CA_TEXA, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetFog(GX_FOG_NONE, 0.0f, 1.0f, 0.1f, 1.0f, color);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
|
||||
if (pass == 0) {
|
||||
GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_OR, GX_GREATER, 0);
|
||||
@@ -5414,7 +5414,7 @@ void dKyr_odour_draw(Mtx drawMtx, u8** tex) {
|
||||
GXSetTevColorOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_FALSE, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE1, GX_CA_ZERO, GX_CA_A0, GX_CA_TEXA, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE1, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_FALSE, GX_TEVPREV);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_COPY);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_COPY);
|
||||
GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
|
||||
GXSetZCompLoc(GX_TRUE);
|
||||
GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_DISABLE);
|
||||
@@ -5781,7 +5781,7 @@ void dKyr_mud_draw(Mtx drawMtx, u8** tex) {
|
||||
GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_A0, GX_CA_TEXA, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_OR, GX_GREATER, 0);
|
||||
|
||||
if (g_env_light.camera_water_in_status != 0) {
|
||||
@@ -5955,7 +5955,7 @@ static void dKyr_evil_draw2(Mtx drawMtx, u8** tex) {
|
||||
GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_TEXA, GX_CA_A0, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_COPY);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_COPY);
|
||||
GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_OR, GX_GREATER, 0);
|
||||
GXSetZCompLoc(GX_TRUE);
|
||||
GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_DISABLE);
|
||||
@@ -6181,7 +6181,7 @@ void dKyr_evil_draw(Mtx drawMtx, u8** tex) {
|
||||
GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_TEXA, GX_CA_A0, GX_CA_ZERO);
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
GXSetAlphaCompare(GX_GREATER, 0, GX_AOP_OR, GX_GREATER, 0);
|
||||
GXSetZCompLoc(GX_TRUE);
|
||||
GXSetZMode(GX_ENABLE, GX_LEQUAL, GX_DISABLE);
|
||||
|
||||
+1
-1
@@ -59,7 +59,7 @@ static int dKyeff_Create(kankyo_class* i_this) {
|
||||
OSTicksToCalendarTime(OSGetTime(), &time);
|
||||
g_env_light.global_wind_influence.vec.set(1.0f, 0.0f, 0.0f);
|
||||
g_env_light.global_wind_influence.pow = 0.7f;
|
||||
g_env_light.daytime = time.hours * 15.0f;
|
||||
g_env_light.daytime = time.hour * 15.0f;
|
||||
}
|
||||
|
||||
return cPhs_COMPLEATE_e;
|
||||
|
||||
@@ -133,7 +133,7 @@ void dDrawPath_c::drawPath() {
|
||||
* makeResTIMG__15dRenderingMap_cCFP7ResTIMGUsUsPUcPUcUs */
|
||||
void dRenderingMap_c::makeResTIMG(ResTIMG* p_image, u16 width, u16 height, u8* p_data,
|
||||
u8* p_palette, u16 param_5) const {
|
||||
p_image->format = GX_TF_CI14;
|
||||
p_image->format = GX_TF_C8;
|
||||
p_image->alphaEnabled = 2;
|
||||
p_image->width = width;
|
||||
p_image->height = height;
|
||||
@@ -232,7 +232,7 @@ void dRenderingFDAmap_c::preRenderingMap() {
|
||||
GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
|
||||
GXSetZCompLoc(GX_TRUE);
|
||||
GXSetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
|
||||
GXSetBlendMode(GX_BM_NONE, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_CLEAR);
|
||||
GXSetBlendMode(GX_BM_NONE, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
|
||||
GXSetFog(GX_FOG_NONE, 0.0f, 0.0f, 0.0f, 0.0f, g_clearColor);
|
||||
GXSetCullMode(GX_CULL_NONE);
|
||||
GXSetDither(GX_FALSE);
|
||||
@@ -253,7 +253,7 @@ void dRenderingFDAmap_c::preRenderingMap() {
|
||||
void dRenderingFDAmap_c::postRenderingMap() {
|
||||
GXSetCopyFilter(GX_FALSE, NULL, GX_FALSE, NULL);
|
||||
GXSetTexCopySrc(0, 0, mTexWidth, mTexHeight);
|
||||
GXSetTexCopyDst(mTexWidth, mTexHeight, GX_CTF_G8, GX_FALSE);
|
||||
GXSetTexCopyDst(mTexWidth, mTexHeight, GX_CTF_R8, GX_FALSE);
|
||||
GXCopyTex(field_0x4, GX_TRUE);
|
||||
GXPixModeSync();
|
||||
GXSetClipMode(GX_CLIP_ENABLE);
|
||||
@@ -337,4 +337,4 @@ const GXColor* dRenderingFDAmap_c::getDecoLineColor(int param_0, int param_1) {
|
||||
* getDecorationLineWidth__18dRenderingFDAmap_cFi */
|
||||
s32 dRenderingFDAmap_c::getDecorationLineWidth(int param_0) {
|
||||
return getLineWidth(param_0);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -689,7 +689,7 @@ const GXColor* dMenu_FmapMap_c::getColor(int param_0) {
|
||||
void dMenu_FmapMap_c::setTexture(u16 i_width, u16 i_height, u16 param_2, u16 param_3) {
|
||||
mMapImage_p = NULL;
|
||||
mResTIMG = NULL;
|
||||
int size = GXGetTexBufferSize(i_width, i_height, GX_TF_CI14, 0, 0);
|
||||
int size = GXGetTexBufferSize(i_width, i_height, GX_TF_C8, 0, 0);
|
||||
mMapImage_p = new (0x20) u8[size];
|
||||
init(mMapImage_p, i_width, i_height, param_2, param_3);
|
||||
mResTIMG = new (0x20) ResTIMG();
|
||||
|
||||
@@ -15,7 +15,7 @@
|
||||
#include "d/d_meter_HIO.h"
|
||||
#include "d/d_meter_haihai.h"
|
||||
#include "d/d_msg_string.h"
|
||||
#include "dolphin/os/OSRtc.h"
|
||||
#include <dolphin/os.h>
|
||||
#include "dolphin/types.h"
|
||||
#include "f_op/f_op_msg_mng.h"
|
||||
#include "m_Do/m_Do_controller_pad.h"
|
||||
|
||||
@@ -28,7 +28,7 @@ void dOvlpFd2_dlst_c::draw() {
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetZCompLoc(GX_TRUE);
|
||||
GXSetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
|
||||
GXSetBlendMode(GX_BM_NONE, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_CLEAR);
|
||||
GXSetBlendMode(GX_BM_NONE, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
|
||||
GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
|
||||
GXSetFog(GX_FOG_NONE, 0.0f, 0.0f, 0.0f, 0.0f, g_clearColor);
|
||||
GXSetCullMode(GX_CULL_NONE);
|
||||
@@ -68,7 +68,7 @@ void dOvlpFd2_dlst_c::draw() {
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetZCompLoc(GX_TRUE);
|
||||
GXSetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
|
||||
GXSetBlendMode(GX_BM_NONE, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_CLEAR);
|
||||
GXSetBlendMode(GX_BM_NONE, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
|
||||
GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
|
||||
GXSetFog(GX_FOG_NONE, 0.0f, 0.0f, 0.0f, 0.0f, g_clearColor);
|
||||
GXSetCullMode(GX_CULL_NONE);
|
||||
|
||||
@@ -39,7 +39,7 @@ void dOvlpFd3_dlst_c::draw() {
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetZCompLoc(GX_TRUE);
|
||||
GXSetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
|
||||
GXSetBlendMode(GX_BM_NONE, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_CLEAR);
|
||||
GXSetBlendMode(GX_BM_NONE, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
|
||||
GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
|
||||
GXSetFog(GX_FOG_NONE, 0.0f, 0.0f, 0.0f, 0.0f, g_clearColor);
|
||||
GXSetCullMode(GX_CULL_NONE);
|
||||
@@ -79,7 +79,7 @@ void dOvlpFd3_dlst_c::draw() {
|
||||
GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
|
||||
GXSetZCompLoc(GX_TRUE);
|
||||
GXSetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
|
||||
GXSetBlendMode(GX_BM_NONE, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_CLEAR);
|
||||
GXSetBlendMode(GX_BM_NONE, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
|
||||
GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
|
||||
GXSetFog(GX_FOG_NONE, 0.0f, 0.0f, 0.0f, 0.0f, g_clearColor);
|
||||
GXSetCullMode(GX_CULL_NONE);
|
||||
|
||||
@@ -284,7 +284,7 @@ static void drawSecond_light8(JPABaseEmitter* param_0) {
|
||||
GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_AND, GX_ALWAYS, 0);
|
||||
GXSetZMode(true, GX_LEQUAL, false);
|
||||
GXSetZCompLoc(0);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRC_ALPHA, GX_BL_INV_SRC_ALPHA, GX_LO_SET);
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
|
||||
GXSetNumChans(1);
|
||||
GXColor local_14;
|
||||
local_14.r = g_env_light.bg_amb_col[0].r;
|
||||
|
||||
@@ -2,6 +2,7 @@
|
||||
#include "d/d_com_inf_game.h"
|
||||
#include "m_Do/m_Do_controller_pad.h"
|
||||
#include "SSystem/SComponent/c_math.h"
|
||||
#include <limits.h>
|
||||
|
||||
#define RESET_FRAME -99
|
||||
|
||||
@@ -204,7 +205,7 @@ int dVibration_c::Run() {
|
||||
length = mMotor.mQuake.mLength;
|
||||
pattern = rollshift(mMotor.mQuake.mPattern, length, mFrame);
|
||||
pattern |= randombit(mMotor.mQuake.mRounds, length);
|
||||
mMotor.mQuake.mStopFrame = INT32_MAX;
|
||||
mMotor.mQuake.mStopFrame = INT_MAX;
|
||||
mDoCPd_c::startMotorWave(PAD_1, makedata(data, pattern, length), JUTGamePad::CRumble::VAL_1, 60);
|
||||
break;
|
||||
case RUMBLE_SHOCK | RUMBLE_QUAKE:
|
||||
|
||||
@@ -0,0 +1,721 @@
|
||||
#include <dolphin.h>
|
||||
#include <dolphin/gx.h>
|
||||
#include <dolphin/G2D.h>
|
||||
#include "fake_tgmath.h"
|
||||
|
||||
static G2DGlob glob;
|
||||
|
||||
void G2DInitSprite(G2DSprite *sprite) {
|
||||
f32 rInvWidth;
|
||||
f32 rInvHeight;
|
||||
|
||||
rInvWidth = 1.0f / (f32)GXGetTexObjWidth(sprite->to);
|
||||
rInvHeight = 1.0f / (f32)GXGetTexObjHeight(sprite->to);
|
||||
sprite->rS0 = (0.5f + (f32)sprite->nTlcS) * rInvWidth;
|
||||
sprite->rS1 = rInvWidth * (((f32)sprite->nTlcS + (f32)sprite->nWidth) - 0.5f);
|
||||
sprite->rT0 = (0.5f + (f32)sprite->nTlcT) * rInvHeight;
|
||||
sprite->rT1 = rInvHeight * (((f32)sprite->nTlcT + (f32)sprite->nHeight) - 0.5f);
|
||||
}
|
||||
|
||||
void G2DDrawSprite(G2DSprite* sprite, G2DPosOri* po) {
|
||||
f32 rOX, rOY;
|
||||
f32 rWX, rWY;
|
||||
f32 rHX, rHY;
|
||||
f32 rRelX, rRelY;
|
||||
|
||||
GXClearVtxDesc();
|
||||
GXLoadTexObj(sprite->to, GX_TEXMAP0);
|
||||
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XY, GX_F32, 0);
|
||||
GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
|
||||
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0);
|
||||
GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT);
|
||||
GXSetTevOp(GX_TEVSTAGE0, GX_REPLACE);
|
||||
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL);
|
||||
GXSetNumTexGens(1);
|
||||
GXSetNumChans(0);
|
||||
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
|
||||
|
||||
rOX = 0.5f * po->rOriX;
|
||||
rOY = 0.5f * po->rOriY;
|
||||
|
||||
rWX = (f32)sprite->nWidth * rOX;
|
||||
rWY = (f32)sprite->nWidth * rOY;
|
||||
rHX = (f32)sprite->nHeight * rOX;
|
||||
rHY = (f32)sprite->nHeight * rOY;
|
||||
|
||||
rRelX = po->rPosX - glob.poCam.rPosX;
|
||||
rRelY = po->rPosY - glob.poCam.rPosY;
|
||||
if (rRelX >= glob.rHalfX) {
|
||||
rRelX -= glob.rWorldX;
|
||||
}
|
||||
if (rRelX < -glob.rHalfX) {
|
||||
rRelX += glob.rWorldX;
|
||||
}
|
||||
if (rRelY >= glob.rHalfY) {
|
||||
rRelY -= glob.rWorldY;
|
||||
}
|
||||
if (rRelY < -glob.rHalfY) {
|
||||
rRelY += glob.rWorldY;
|
||||
}
|
||||
|
||||
rRelX += glob.poCam.rPosX;
|
||||
rRelY += glob.poCam.rPosY;
|
||||
|
||||
GXBegin(GX_QUADS, GX_VTXFMT0, 4);
|
||||
|
||||
GXPosition2f32(rWY + (rRelX - rHX), (rRelY - rHY) - rWX);
|
||||
GXTexCoord2f32(sprite->rS0, sprite->rT1);
|
||||
|
||||
GXPosition2f32(rWY + (rRelX + rHX), (rRelY + rHY) - rWX);
|
||||
GXTexCoord2f32(sprite->rS0, sprite->rT0);
|
||||
|
||||
GXPosition2f32((rRelX + rHX) - rWY, rWX + (rRelY + rHY));
|
||||
GXTexCoord2f32(sprite->rS1, sprite->rT0);
|
||||
|
||||
GXPosition2f32((rRelX - rHX) - rWY, rWX + (rRelY - rHY));
|
||||
GXTexCoord2f32(sprite->rS1, sprite->rT1);
|
||||
|
||||
GXEnd();
|
||||
}
|
||||
|
||||
static inline void FillSection(G2DLayer* layer, s8* aSortBuffer, s32* nScanLine, s32 nEvent, s16* nIdx,
|
||||
s32* nL, s32* nR, f32* rLeft, f32* rRight, f32 rStep0, f32 rStep1, s32 nMapX,
|
||||
s32 nMapY) {
|
||||
s32 nHMask;
|
||||
s32 nVMask;
|
||||
s32 nI;
|
||||
s32 nJ;
|
||||
s32 nK;
|
||||
s32 nM;
|
||||
s16 nMaterial;
|
||||
s16* pAddr;
|
||||
|
||||
nHMask = (1 << layer->nHS) - 1;
|
||||
nVMask = (1 << layer->nVS) - 1;
|
||||
if (layer->nBPI == 1) {
|
||||
u8 nTile;
|
||||
if (layer->bWrap) {
|
||||
for (; *nScanLine <= nEvent; (*nScanLine)++) {
|
||||
nJ = *nScanLine - 1;
|
||||
nK = (nVMask & (nJ + nMapY)) << layer->nHS;
|
||||
for (nI = *nL; nI <= *nR; nI++) {
|
||||
nTile = ((u8*)layer->map)[nK + (nHMask & (nI + nMapX))];
|
||||
nMaterial = layer->tileDesc[nTile].nMaterial;
|
||||
pAddr = (s16*)&layer->matDesc[nMaterial].nReserved;
|
||||
pAddr[1]++;
|
||||
|
||||
if (*pAddr != *nIdx) {
|
||||
*nIdx += 2;
|
||||
*(s16*)&aSortBuffer[*pAddr] = *pAddr - *nIdx;
|
||||
}
|
||||
*(s16*)&aSortBuffer[*nIdx] = nTile;
|
||||
*nIdx += 2;
|
||||
aSortBuffer[(*nIdx)++] = nI;
|
||||
aSortBuffer[(*nIdx)++] = nJ;
|
||||
*pAddr = *nIdx;
|
||||
}
|
||||
*rLeft += rStep0;
|
||||
*rRight += rStep1;
|
||||
*nL = floor(*rLeft);
|
||||
*nR = floor(*rRight);
|
||||
}
|
||||
} else {
|
||||
for (; *nScanLine <= nEvent; (*nScanLine)++) {
|
||||
nJ = *nScanLine - 1 + nMapY;
|
||||
if (nJ < 0) {
|
||||
nK = 0;
|
||||
}
|
||||
else if ( nJ > nVMask ) {
|
||||
nK = nVMask << layer->nHS;
|
||||
}
|
||||
else {
|
||||
nK = nJ << layer->nHS;
|
||||
}
|
||||
|
||||
nM = *nR + nMapX;
|
||||
for (nI = *nL + nMapX; nI <= nM; nI++) {
|
||||
if ( nI < 0 ) {
|
||||
nTile = ((u8*)layer->map)[nK];
|
||||
}
|
||||
else if ( nI > nHMask ) {
|
||||
nTile = ((u8*)layer->map)[nK + nHMask];
|
||||
}
|
||||
else {
|
||||
nTile = ((u8*)layer->map)[nK + nI];
|
||||
}
|
||||
|
||||
nMaterial = layer->tileDesc[nTile].nMaterial;
|
||||
pAddr = (s16*)&layer->matDesc[nMaterial].nReserved;
|
||||
pAddr[1]++;
|
||||
|
||||
if (*pAddr != *nIdx) {
|
||||
*nIdx += 2;
|
||||
*(s16*)&aSortBuffer[*pAddr] = *pAddr - *nIdx;
|
||||
}
|
||||
*(s16*)&aSortBuffer[*nIdx] = nTile;
|
||||
*nIdx += 2;
|
||||
aSortBuffer[(*nIdx)++] = nI - nMapX;
|
||||
aSortBuffer[(*nIdx)++] = nJ - nMapY;
|
||||
*pAddr = *nIdx;
|
||||
}
|
||||
|
||||
*rLeft += rStep0;
|
||||
*rRight += rStep1;
|
||||
*nL = floor(*rLeft);
|
||||
*nR = floor(*rRight);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
u16 nTile;
|
||||
if (layer->bWrap) {
|
||||
for (; *nScanLine <= nEvent; (*nScanLine)++) {
|
||||
nJ = *nScanLine - 1;
|
||||
nK = (nVMask & (nJ + nMapY)) << layer->nHS;
|
||||
for (nI = *nL; nI <= *nR; nI++) {
|
||||
nTile = ((u16*)layer->map)[nK + (nHMask & (nI + nMapX))];
|
||||
nMaterial = layer->tileDesc[nTile].nMaterial;
|
||||
pAddr = (s16*)&layer->matDesc[nMaterial].nReserved;
|
||||
pAddr[1]++;
|
||||
|
||||
if (*pAddr != *nIdx) {
|
||||
*nIdx += 2;
|
||||
*(s16*)&aSortBuffer[*pAddr] = *pAddr - *nIdx;
|
||||
}
|
||||
*(s16*)&aSortBuffer[*nIdx] = nTile;
|
||||
*nIdx += 2;
|
||||
aSortBuffer[(*nIdx)++] = nI;
|
||||
aSortBuffer[(*nIdx)++] = nJ;
|
||||
*pAddr = *nIdx;
|
||||
}
|
||||
|
||||
*rLeft += rStep0;
|
||||
*rRight += rStep1;
|
||||
*nL = floor(*rLeft);
|
||||
*nR = floor(*rRight);
|
||||
}
|
||||
} else {
|
||||
for (; *nScanLine <= nEvent; (*nScanLine)++) {
|
||||
nJ = *nScanLine - 1 + nMapY;
|
||||
if (nJ < 0) {
|
||||
nK = 0;
|
||||
}
|
||||
else if ( nJ > nVMask ) {
|
||||
nK = nVMask << layer->nHS;
|
||||
}
|
||||
else {
|
||||
nK = nJ << layer->nHS;
|
||||
}
|
||||
|
||||
nM = *nR + nMapX;
|
||||
for (nI = *nL + nMapX; nI <= nM; nI++) {
|
||||
if ( nI < 0 ) {
|
||||
nTile = ((u16*)layer->map)[nK];
|
||||
}
|
||||
else if ( nI > nHMask ) {
|
||||
nTile = ((u16*)layer->map)[nK + nHMask];
|
||||
}
|
||||
else {
|
||||
nTile = ((u16*)layer->map)[nK + nI];
|
||||
}
|
||||
|
||||
nMaterial = layer->tileDesc[nTile].nMaterial;
|
||||
pAddr = (s16*)&layer->matDesc[nMaterial].nReserved;
|
||||
pAddr[1]++;
|
||||
|
||||
if (*pAddr != *nIdx) {
|
||||
*nIdx += 2;
|
||||
*(s16*)&aSortBuffer[*pAddr] = *pAddr - *nIdx;
|
||||
}
|
||||
*(s16*)&aSortBuffer[*nIdx] = nTile;
|
||||
*nIdx += 2;
|
||||
aSortBuffer[(*nIdx)++] = nI - nMapX;
|
||||
aSortBuffer[(*nIdx)++] = nJ - nMapY;
|
||||
*pAddr = *nIdx;
|
||||
}
|
||||
|
||||
*rLeft += rStep0;
|
||||
*rRight += rStep1;
|
||||
*nL = floor(*rLeft);
|
||||
*nR = floor(*rRight);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void G2DDrawLayer(G2DLayer* layer, s8* aSortBuffer) {
|
||||
s16* pAddr;
|
||||
s16 aCount0;
|
||||
s16 aCount1;
|
||||
s16 aCount2;
|
||||
f32 rInvTileWidth;
|
||||
f32 rInvTileHeight;
|
||||
s16 nIdx;
|
||||
s32 nI;
|
||||
s32 nJ;
|
||||
s32 nK;
|
||||
s32 nL;
|
||||
s32 nR;
|
||||
f32 rX;
|
||||
f32 rY;
|
||||
f32 rTlcX;
|
||||
f32 rTrcX;
|
||||
f32 rBlcX;
|
||||
f32 rBrcX;
|
||||
f32 rTlcY;
|
||||
f32 rTrcY;
|
||||
f32 rBlcY;
|
||||
f32 rBrcY;
|
||||
s32 nScanLine;
|
||||
f32 rLeft;
|
||||
f32 rRight;
|
||||
f32 rLeftY;
|
||||
f32 rRightY;
|
||||
f32 rStep0;
|
||||
f32 rStep1;
|
||||
f32 rMid;
|
||||
s32 nEvent0;
|
||||
s32 nEvent1;
|
||||
s32 nEvent2;
|
||||
f32 rFrcX;
|
||||
f32 rFrcY;
|
||||
s32 nMapX;
|
||||
s32 nMapY;
|
||||
s32 nLocalMapX;
|
||||
s32 nLocalMapY;
|
||||
f32 rCamOriX;
|
||||
f32 rCamOriY;
|
||||
s16 nTile;
|
||||
s16 nMaterial;
|
||||
f32 rRatio;
|
||||
|
||||
aCount0 = 0;
|
||||
aCount1 = 0;
|
||||
aCount2 = 0;
|
||||
rInvTileWidth = 1.0f / (f32)layer->nTileWidth;
|
||||
rInvTileHeight = 1.0f / (f32)layer->nTileHeight;
|
||||
|
||||
GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
|
||||
|
||||
for (nI = 0; nI < layer->nNumMaterials; nI++) {
|
||||
pAddr = (s16*)&layer->matDesc[nI];
|
||||
pAddr[0] = nI << 1;
|
||||
pAddr[1] = 0;
|
||||
}
|
||||
nIdx = (nI - 1) << 1;
|
||||
|
||||
rFrcX = glob.poCam.rPosX * rInvTileWidth;
|
||||
rFrcY = glob.poCam.rPosY * rInvTileHeight;
|
||||
nMapX = (s32)rFrcX;
|
||||
nMapY = (s32)rFrcY;
|
||||
rFrcX -= nMapX;
|
||||
rFrcY -= nMapY;
|
||||
|
||||
rCamOriX = glob.poCam.rOriX;
|
||||
rCamOriY = glob.poCam.rOriY;
|
||||
if (rCamOriX < 0.0001 && rCamOriX > -0.0001) {
|
||||
rCamOriX = 0.0001f;
|
||||
}
|
||||
else if (rCamOriY < 0.0001 && rCamOriY > -0.0001) {
|
||||
rCamOriY = 0.0001f;
|
||||
}
|
||||
|
||||
rX = 0.5f * (f32)glob.nViewportWidth;
|
||||
rY = 0.5f * (f32)glob.nViewportHeight;
|
||||
rTlcX = rFrcX + (rInvTileWidth * ((rY * rCamOriX) + (rX * rCamOriY)));
|
||||
rTlcY = (rFrcY + (rInvTileHeight * ((rY * rCamOriY) - (rX * rCamOriX))));
|
||||
rTrcX = rFrcX + (rInvTileWidth * ((rY * rCamOriX) - (rX * rCamOriY)));
|
||||
rTrcY = (rFrcY + (rInvTileHeight * ((rY * rCamOriY) + (rX * rCamOriX))));
|
||||
rBlcX = rFrcX - (rInvTileWidth * ((rY * rCamOriX) - (rX * rCamOriY)));
|
||||
rBlcY = rFrcY - (rInvTileHeight * ((rY * rCamOriY) + (rX * rCamOriX)));
|
||||
rBrcX = rFrcX - (rInvTileWidth * ((rY * rCamOriX) + (rX * rCamOriY)));
|
||||
rBrcY = rFrcY - (rInvTileHeight * ((rY * rCamOriY) - (rX * rCamOriX)));
|
||||
|
||||
if (rCamOriY < 0.0f) {
|
||||
if (rCamOriX >= 0.0f) {
|
||||
nScanLine = (s32)floor(rTlcY) + 1;
|
||||
rY = nScanLine - rTlcY;
|
||||
rLeft = rTlcX;
|
||||
rLeftY = rBlcY;
|
||||
rRightY = rTrcY;
|
||||
nEvent2 = (s32)floor(rBrcY);
|
||||
rStep0 = rCamOriX / rCamOriY;
|
||||
rStep1 = -rCamOriY / rCamOriX;
|
||||
}
|
||||
else {
|
||||
nScanLine = (s32)floor(rTrcY) + 1;
|
||||
rY = nScanLine - rTrcY;
|
||||
rLeft = rTrcX;
|
||||
rLeftY = rTlcY;
|
||||
rRightY = rBrcY;
|
||||
nEvent2 = (s32)floor(rBlcY);
|
||||
rStep0 = -rCamOriY / rCamOriX;
|
||||
rStep1 = rCamOriX / rCamOriY;
|
||||
}
|
||||
} else {
|
||||
if (rCamOriX >= 0.0f) {
|
||||
nScanLine = (s32)floor(rBlcY) + 1;
|
||||
rY = nScanLine - rBlcY;
|
||||
rLeft = rBlcX;
|
||||
rLeftY = rBrcY;
|
||||
rRightY = rTlcY;
|
||||
nEvent2 = (s32)floor(rTrcY);
|
||||
rStep0 = -rCamOriY / rCamOriX;
|
||||
rStep1 = rCamOriX / rCamOriY;
|
||||
} else {
|
||||
nScanLine = (s32)floor(rBrcY) + 1;
|
||||
rY = nScanLine - rBrcY;
|
||||
rLeft = rBrcX;
|
||||
rLeftY = rTrcY;
|
||||
rRightY = rBlcY;
|
||||
nEvent2 = (s32)floor(rTlcY);
|
||||
rStep0 = rCamOriX / rCamOriY;
|
||||
rStep1 = -rCamOriY / rCamOriX;
|
||||
}
|
||||
}
|
||||
|
||||
rRatio = (f32)layer->nTileHeight / (f32)layer->nTileWidth;
|
||||
rStep0 *= rRatio;
|
||||
rStep1 *= rRatio;
|
||||
rRight = rLeft + (rY * rStep1);
|
||||
rLeft = rLeft + (rY * rStep0);
|
||||
|
||||
if (rLeftY < rRightY) {
|
||||
nEvent0 = (s32)floor(rLeftY);
|
||||
nEvent1 = (s32)floor(rRightY);
|
||||
rMid = rStep1;
|
||||
} else {
|
||||
nEvent0 = (s32)floor(rRightY);
|
||||
nEvent1 = (s32)floor(rLeftY);
|
||||
rMid = rStep0;
|
||||
}
|
||||
|
||||
nL = (s32)floor(rLeft);
|
||||
nR = (s32)floor(rRight);
|
||||
nLocalMapX = nMapX;
|
||||
nLocalMapY = nMapY;
|
||||
|
||||
if (!layer->bWrap) {
|
||||
f32 rInvTileWidth = 1.0f / (f32)layer->nTileWidth;
|
||||
f32 rInvTileHeight = 1.0f / (f32)layer->nTileHeight;
|
||||
f32 rLocalPosX = glob.poCam.rPosX;
|
||||
f32 rLocalPosY = glob.poCam.rPosY;
|
||||
f32 rSplitX = 0.5f * (glob.rWorldX + (f32)(layer->nTileWidth * (1 << layer->nHS)));
|
||||
f32 rSplitY = 0.5f * (glob.rWorldY + (f32)(layer->nTileHeight * (1 << layer->nVS)));
|
||||
|
||||
if (rLocalPosX >= rSplitX) {
|
||||
rLocalPosX -= glob.rWorldX;
|
||||
}
|
||||
|
||||
if (rLocalPosY >= rSplitY) {
|
||||
rLocalPosY -= glob.rWorldY;
|
||||
}
|
||||
|
||||
rFrcX = rLocalPosX * rInvTileWidth;
|
||||
rFrcY = rLocalPosY * rInvTileHeight;
|
||||
|
||||
nLocalMapX = floor(rFrcX);
|
||||
nLocalMapY = floor(rFrcY);
|
||||
}
|
||||
|
||||
FillSection(layer, aSortBuffer, &nScanLine, nEvent0, &nIdx, &nL, &nR, &rLeft, &rRight, rStep0, rStep1, nLocalMapX, nLocalMapY);
|
||||
|
||||
pAddr = (s16*)&layer->matDesc[0].nReserved;
|
||||
aCount0 = pAddr[1];
|
||||
pAddr = (s16*)&layer->matDesc[1].nReserved;
|
||||
aCount1 = pAddr[1];
|
||||
pAddr = (s16*)&layer->matDesc[2].nReserved;
|
||||
aCount2 = pAddr[1];
|
||||
|
||||
if ((f32)nScanLine > rLeftY) {
|
||||
rLeft -= rStep0 * ((f32)nScanLine - rLeftY);
|
||||
nL = (s32)floor(rLeft);
|
||||
rLeft += rStep1 * (((f32)nScanLine - rLeftY) - 1.0f);
|
||||
rLeftY = 1000.0f;
|
||||
}
|
||||
|
||||
if ((f32)nScanLine > rRightY) {
|
||||
rRight -= rStep1 * ((f32)nScanLine - rRightY);
|
||||
nR = (s32)floor(rRight);
|
||||
rRight += rStep0 * (((f32)nScanLine - rRightY) - 1.0f);
|
||||
rRightY = 1000.0f;
|
||||
}
|
||||
|
||||
FillSection(layer, aSortBuffer, &nScanLine, nEvent1, &nIdx, &nL, &nR, &rLeft, &rRight, rMid, rMid, nLocalMapX, nLocalMapY);
|
||||
|
||||
pAddr = (s16*)&layer->matDesc[0].nReserved;
|
||||
aCount0 = pAddr[1];
|
||||
pAddr = (s16*)&layer->matDesc[1].nReserved;
|
||||
aCount1 = pAddr[1];
|
||||
pAddr = (s16*)&layer->matDesc[2].nReserved;
|
||||
aCount2 = pAddr[1];
|
||||
|
||||
if ((f32)nScanLine > rLeftY) {
|
||||
rLeft -= rStep0 * ((f32)nScanLine - rLeftY);
|
||||
nL = (s32)floor(rLeft);
|
||||
rLeft += rStep1 * (((f32)nScanLine - rLeftY) - 1.0f);
|
||||
}
|
||||
|
||||
if ((f32)nScanLine > rRightY) {
|
||||
rRight -= rStep1 * ((f32)nScanLine - rRightY);
|
||||
nR = (s32)floor(rRight);
|
||||
rRight += rStep0 * (((f32)nScanLine - rRightY) - 1.0f);
|
||||
}
|
||||
|
||||
FillSection(layer, aSortBuffer, &nScanLine, nEvent2 + 1, &nIdx, &nL, &nR, &rLeft, &rRight, rStep1, rStep0, nLocalMapX, nLocalMapY);
|
||||
|
||||
pAddr = (s16*)&layer->matDesc[0].nReserved;
|
||||
aCount0 = pAddr[1];
|
||||
pAddr = (s16*)&layer->matDesc[1].nReserved;
|
||||
aCount1 = pAddr[1];
|
||||
pAddr = (s16*)&layer->matDesc[2].nReserved;
|
||||
aCount2 = pAddr[1];
|
||||
|
||||
for (nMaterial = 0; nMaterial < layer->nNumMaterials; nMaterial++) {
|
||||
pAddr = (s16*)&layer->matDesc[nMaterial].nReserved;
|
||||
if (!pAddr[1]) {
|
||||
continue;
|
||||
}
|
||||
|
||||
switch (layer->matDesc[nMaterial].nCategory) {
|
||||
case G2D_CTG_EMPTY:
|
||||
continue;
|
||||
|
||||
case G2D_CTG_RGBA_INDEX8: {
|
||||
GXClearVtxDesc();
|
||||
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XY, GX_F32, 0);
|
||||
GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
|
||||
|
||||
GXSetNumTexGens(0);
|
||||
GXSetVtxDesc(GX_VA_TEX0, GX_NONE);
|
||||
GXSetTevOp(GX_TEVSTAGE0, GX_PASSCLR);
|
||||
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0);
|
||||
GXSetVtxDesc(GX_VA_CLR0, GX_INDEX8);
|
||||
GXSetArray(GX_VA_CLR0, layer->matDesc[nMaterial].clut, 4);
|
||||
|
||||
GXSetNumChans(1);
|
||||
GXSetChanCtrl(GX_COLOR0A0, 0, GX_SRC_VTX, GX_SRC_VTX, 1, GX_DF_NONE, GX_AF_NONE);
|
||||
|
||||
nIdx = nMaterial << 1;
|
||||
GXBegin(GX_QUADS, GX_VTXFMT0, pAddr[1] << 2);
|
||||
|
||||
for (nK = pAddr[1]; nK--; ) {
|
||||
f32 rI, rJ;
|
||||
u8 nCI;
|
||||
|
||||
nTile = *((s16*)&aSortBuffer[nIdx]);
|
||||
if (nTile < 0) {
|
||||
nIdx -= nTile;
|
||||
nTile = *((s16*)&aSortBuffer[nIdx]);
|
||||
}
|
||||
nIdx += 2;
|
||||
nI = aSortBuffer[nIdx++];
|
||||
nJ = aSortBuffer[nIdx++];
|
||||
|
||||
rI = (f32)layer->nTileWidth * (f32)(nI + nMapX);
|
||||
rJ = (f32)layer->nTileHeight * (f32)(nJ + nMapY);
|
||||
nCI = layer->tileDesc[nTile].nCI;
|
||||
|
||||
GXPosition2f32(rI + (f32)layer->nTileWidth, rJ);
|
||||
GXColor1x8(nCI);
|
||||
|
||||
GXPosition2f32(rI + (f32)layer->nTileWidth, rJ + (f32)layer->nTileHeight);
|
||||
GXColor1x8(nCI);
|
||||
|
||||
GXPosition2f32(rI, rJ + (f32)layer->nTileHeight);
|
||||
GXColor1x8(nCI);
|
||||
|
||||
GXPosition2f32(rI, rJ);
|
||||
GXColor1x8(nCI);
|
||||
}
|
||||
|
||||
GXEnd();
|
||||
break;
|
||||
}
|
||||
|
||||
case G2D_CTG_RGB_DIRECT: {
|
||||
GXClearVtxDesc();
|
||||
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XY, GX_F32, 0);
|
||||
GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
|
||||
|
||||
GXSetNumTexGens(0);
|
||||
GXSetVtxDesc(GX_VA_TEX0, GX_NONE);
|
||||
GXSetTevOp(GX_TEVSTAGE0, GX_PASSCLR);
|
||||
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGB, GX_RGB8, 0);
|
||||
GXSetVtxDesc(GX_VA_CLR0, GX_DIRECT);
|
||||
|
||||
GXSetNumChans(1);
|
||||
GXSetChanCtrl(GX_COLOR0A0, 0, GX_SRC_VTX, GX_SRC_VTX, 1, GX_DF_NONE, GX_AF_NONE);
|
||||
|
||||
nIdx = nMaterial << 1;
|
||||
GXBegin(GX_QUADS, GX_VTXFMT0, pAddr[1] << 2);
|
||||
|
||||
for (nK = pAddr[1]; nK--; ) {
|
||||
f32 rI, rJ;
|
||||
u8 nR, nG, nB;
|
||||
|
||||
nTile = *((s16*)&aSortBuffer[nIdx]);
|
||||
if (nTile < 0) {
|
||||
nIdx -= nTile;
|
||||
nTile = *((s16*)&aSortBuffer[nIdx]);
|
||||
}
|
||||
|
||||
nIdx += 2;
|
||||
nI = aSortBuffer[nIdx++];
|
||||
nJ = aSortBuffer[nIdx++];
|
||||
|
||||
rI = (f32)layer->nTileWidth * (f32)(nI + nMapX);
|
||||
rJ = (f32)layer->nTileHeight * (f32)(nJ + nMapY);
|
||||
nR = layer->tileDesc[nTile].nS;
|
||||
nG = layer->tileDesc[nTile].nT;
|
||||
nB = layer->tileDesc[nTile].nCI;
|
||||
|
||||
GXPosition2f32(rI + (f32)layer->nTileWidth, rJ);
|
||||
GXColor3u8(nR, nG, nB);
|
||||
|
||||
GXPosition2f32(rI + (f32)layer->nTileWidth, rJ + (f32)layer->nTileHeight);
|
||||
GXColor3u8(nR, nG, nB);
|
||||
|
||||
GXPosition2f32(rI, rJ + (f32)layer->nTileHeight);
|
||||
GXColor3u8(nR, nG, nB);
|
||||
|
||||
GXPosition2f32(rI, rJ);
|
||||
GXColor3u8(nR, nG, nB);
|
||||
}
|
||||
|
||||
GXEnd();
|
||||
break;
|
||||
}
|
||||
|
||||
case G2D_CTG_TEXTURE: {
|
||||
f32 rInvTileWidth = 1.0f / (f32)GXGetTexObjWidth(layer->matDesc[nMaterial].to);
|
||||
f32 rInvTileHeight = 1.0f / (f32)GXGetTexObjHeight(layer->matDesc[nMaterial].to);
|
||||
|
||||
f32 rWidth = (f32)layer->nTileWidth * rInvTileWidth;
|
||||
f32 rHeight = (f32)layer->nTileHeight * rInvTileHeight;
|
||||
|
||||
f32 rS0 = 0.0f;
|
||||
f32 rT0 = 0.0f;
|
||||
f32 rS1 = rWidth;
|
||||
f32 rT1 = rHeight;
|
||||
|
||||
GXClearVtxDesc();
|
||||
|
||||
GXLoadTexObj(layer->matDesc[nMaterial].to, GX_TEXMAP0);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XY, GX_F32, 0);
|
||||
GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
|
||||
|
||||
GXSetNumTexGens(1);
|
||||
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0);
|
||||
GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT);
|
||||
|
||||
if ( layer->matDesc[nMaterial].color ) {
|
||||
GXSetNumChans(1);
|
||||
GXSetChanMatColor(GX_COLOR0A0, *layer->matDesc[nMaterial].color);
|
||||
GXSetChanCtrl(GX_COLOR0A0, 0, GX_SRC_REG, GX_SRC_REG, 1, GX_DF_NONE, GX_AF_NONE);
|
||||
GXSetTevOp(GX_TEVSTAGE0, GX_MODULATE);
|
||||
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0);
|
||||
} else {
|
||||
GXSetNumChans(0);
|
||||
GXSetTevOp(GX_TEVSTAGE0, GX_REPLACE);
|
||||
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL);
|
||||
}
|
||||
|
||||
nIdx = nMaterial << 1;
|
||||
GXBegin(GX_QUADS, GX_VTXFMT0, pAddr[1] << 2);
|
||||
|
||||
for (nK = pAddr[1]; nK--; ) {
|
||||
f32 rI;
|
||||
f32 rJ;
|
||||
f32 rS;
|
||||
f32 rT;
|
||||
|
||||
nTile = *((s16*)&aSortBuffer[nIdx]);
|
||||
if (nTile < 0) {
|
||||
nIdx -= nTile;
|
||||
nTile = *((s16*)&aSortBuffer[nIdx]);
|
||||
}
|
||||
|
||||
nIdx += 2;
|
||||
nI = aSortBuffer[nIdx++];
|
||||
nJ = aSortBuffer[nIdx++];
|
||||
|
||||
rS = rS0 + (rWidth * (f32)layer->tileDesc[nTile].nS);
|
||||
rT = rT0 + (rHeight * (f32)layer->tileDesc[nTile].nT);
|
||||
rI = (f32)layer->nTileWidth * (f32)(nI + nMapX);
|
||||
rJ = (f32)layer->nTileHeight * (f32)(nJ + nMapY);
|
||||
|
||||
GXPosition2f32(rI + (f32)layer->nTileWidth, rJ);
|
||||
GXTexCoord2f32(rS + rS1, rT);
|
||||
|
||||
GXPosition2f32(rI + (f32)layer->nTileWidth, rJ + (f32)layer->nTileHeight);
|
||||
GXTexCoord2f32(rS + rS1, rT + rT1);
|
||||
|
||||
GXPosition2f32(rI, rJ + (f32)layer->nTileHeight);
|
||||
GXTexCoord2f32(rS, rT + rT1);
|
||||
|
||||
GXPosition2f32(rI, rJ);
|
||||
GXTexCoord2f32(rS, rT);
|
||||
}
|
||||
|
||||
GXEnd();
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void G2DSetCamera(G2DPosOri* po) {
|
||||
Mtx mView;
|
||||
Vec vPos;
|
||||
Vec vUp;
|
||||
Vec vAt;
|
||||
f32 rX;
|
||||
f32 rY;
|
||||
|
||||
glob.poCam = *po;
|
||||
|
||||
vUp.x = po->rOriX;
|
||||
vUp.y = po->rOriY;
|
||||
vUp.z = 0.0f;
|
||||
|
||||
rX = (((640 - glob.nViewportWidth) >> 1) - glob.nViewportTlcX);
|
||||
rY = (((448 - glob.nViewportHeight) >> 1) - glob.nViewportTlcY);
|
||||
|
||||
vPos.x = po->rPosX - (vUp.x * rY) - (vUp.y * rX);
|
||||
vPos.y = po->rPosY + (vUp.x * rX) - (vUp.y * rY);
|
||||
vPos.z = -300.0f;
|
||||
|
||||
vAt.x = vPos.x;
|
||||
vAt.y = vPos.y;
|
||||
vAt.z = 0.0f;
|
||||
|
||||
MTXLookAt(mView, &vPos, &vUp, &vAt);
|
||||
GXLoadPosMtxImm(mView, GX_PNMTX0);
|
||||
}
|
||||
|
||||
void G2DInitWorld(u32 nWorldX, u32 nWorldY) {
|
||||
Mtx44 mProjection;
|
||||
|
||||
glob.rWorldX = (f32)nWorldX;
|
||||
glob.rWorldY = (f32)nWorldY;
|
||||
glob.rHalfX = (f32)(nWorldX >> 1);
|
||||
glob.rHalfY = (f32)(nWorldY >> 1);
|
||||
GXSetZMode(0, GX_ALWAYS, 1);
|
||||
MTXOrtho(mProjection, 224.0f, -224.0f, -320.0f, 320.0f, 100.0f, 1000.0f);
|
||||
GXSetProjection(mProjection, GX_ORTHOGRAPHIC);
|
||||
}
|
||||
|
||||
void G2DSetViewport(u16 nLeft, u16 nTop, u16 nWidth, u16 nHeight) {
|
||||
glob.nViewportTlcX = nLeft;
|
||||
glob.nViewportTlcY = nTop;
|
||||
glob.nViewportWidth = nWidth;
|
||||
glob.nViewportHeight = nHeight;
|
||||
GXSetScissor(nLeft, nTop, nWidth, nHeight);
|
||||
}
|
||||
+327
-289
@@ -1,206 +1,116 @@
|
||||
#include "dolphin/ai.h"
|
||||
#include "dolphin/dsp.h"
|
||||
#include "dolphin/os.h"
|
||||
#include <dolphin/ai.h>
|
||||
#include <dolphin/gx.h>
|
||||
#include <dolphin/os.h>
|
||||
#include <dolphin/hw_regs.h>
|
||||
|
||||
/* 80450A40-80450A48 -00001 0004+04 1/1 0/0 0/0 .sdata __AIVersion */
|
||||
char* __AIVersion = "<< Dolphin SDK - AI\trelease build: Apr 5 2004 04:15:02 (0x2301) >>";
|
||||
#include "__gx.h"
|
||||
|
||||
void __AISHandler(s16 interrupt, OSContext* context);
|
||||
void __AIDHandler(s16 interrupt, OSContext* context);
|
||||
void __AICallbackStackSwitch(AIDCallback callback);
|
||||
void __AI_SRC_INIT(void);
|
||||
#ifdef DEBUG
|
||||
const char* __AIVersion = "<< Dolphin SDK - AI\tdebug build: Apr 5 2004 03:56:18 (0x2301) >>";
|
||||
#else
|
||||
const char* __AIVersion = "<< Dolphin SDK - AI\trelease build: Apr 5 2004 04:15:02 (0x2301) >>";
|
||||
#endif
|
||||
|
||||
/* ############################################################################################## */
|
||||
/* 80451878-8045187C 000D78 0004+00 2/2 0/0 0/0 .sbss __AIS_Callback */
|
||||
static AISCallback __AIS_Callback;
|
||||
|
||||
/* 8045187C-80451880 000D7C 0004+00 3/3 0/0 0/0 .sbss __AID_Callback */
|
||||
static AIDCallback __AID_Callback;
|
||||
static u8* __CallbackStack;
|
||||
static u8* __OldStack;
|
||||
static BOOL __AI_init_flag;
|
||||
static BOOL __AID_Active;
|
||||
static OSTime bound_32KHz;
|
||||
static OSTime bound_48KHz;
|
||||
static OSTime min_wait;
|
||||
static OSTime max_wait;
|
||||
static OSTime buffer;
|
||||
|
||||
typedef struct {
|
||||
OSTime t_start;
|
||||
OSTime t1;
|
||||
OSTime t2;
|
||||
OSTime t3;
|
||||
OSTime t4;
|
||||
OSTime t_end;
|
||||
} STRUCT_TIMELOG;
|
||||
STRUCT_TIMELOG profile;
|
||||
|
||||
OSTime __ai_src_time_start;
|
||||
OSTime __ai_src_time_end;
|
||||
|
||||
// prototypes
|
||||
void __AI_DEBUG_set_stream_sample_rate(u32 rate);
|
||||
STRUCT_TIMELOG* __ai_src_get_time(void);
|
||||
|
||||
static void __AI_set_stream_sample_rate(u32 rate);
|
||||
static void __AIDHandler(__OSInterrupt interrupt, OSContext* context);
|
||||
static void __AISHandler(__OSInterrupt interrupt, OSContext* context);
|
||||
static void __AICallbackStackSwitch(void* cb);
|
||||
static void __AI_SRC_INIT(void);
|
||||
|
||||
/* 8034FC70-8034FCB4 34A5B0 0044+00 0/0 1/1 0/0 .text AIRegisterDMACallback */
|
||||
AIDCallback AIRegisterDMACallback(AIDCallback callback) {
|
||||
s32 oldInts;
|
||||
AIDCallback ret;
|
||||
AIDCallback old_callback;
|
||||
BOOL old;
|
||||
|
||||
ret = __AID_Callback;
|
||||
oldInts = OSDisableInterrupts();
|
||||
old_callback = __AID_Callback;
|
||||
old = OSDisableInterrupts();
|
||||
__AID_Callback = callback;
|
||||
OSRestoreInterrupts(oldInts);
|
||||
return ret;
|
||||
OSRestoreInterrupts(old);
|
||||
return old_callback;
|
||||
}
|
||||
|
||||
/* 8034FCB4-8034FD3C 34A5F4 0088+00 0/0 2/2 0/0 .text AIInitDMA */
|
||||
void AIInitDMA(u32 addr, u32 length) {
|
||||
s32 oldInts;
|
||||
oldInts = OSDisableInterrupts();
|
||||
__DSPRegs[24] = (u16)((__DSPRegs[24] & ~0x3FF) | (addr >> 16));
|
||||
__DSPRegs[25] = (u16)((__DSPRegs[25] & ~0xFFE0) | (0xffff & addr));
|
||||
__DSPRegs[27] = (u16)((__DSPRegs[27] & ~0x7FFF) | (u16)((length >> 5) & 0xFFFF));
|
||||
OSRestoreInterrupts(oldInts);
|
||||
void AIInitDMA(u32 start_addr, u32 length) {
|
||||
BOOL old;
|
||||
|
||||
old = OSDisableInterrupts();
|
||||
__DSPRegs[24] = (__DSPRegs[24] & 0xFFFFFC00) | (start_addr >> 16);
|
||||
__DSPRegs[25] = (__DSPRegs[25] & 0xFFFF001F) | (start_addr & 0xFFFF);
|
||||
ASSERTMSGLINE(316, (length & 0x1F) == 0, "AIStartDMA: length must be multiple of 32 bytes");
|
||||
__DSPRegs[27] = (__DSPRegs[27] & 0xFFFF8000) | ((length >> 5) & 0xFFFF);
|
||||
OSRestoreInterrupts(old);
|
||||
}
|
||||
|
||||
BOOL AIGetDMAEnableFlag(void) {
|
||||
return (__DSPRegs[27] & (1 << 15)) >> 15;
|
||||
}
|
||||
|
||||
/* 8034FD3C-8034FD54 34A67C 0018+00 0/0 1/1 0/0 .text AIStartDMA */
|
||||
void AIStartDMA(void) {
|
||||
__DSPRegs[27] |= 0x8000;
|
||||
__DSPRegs[27] = __DSPRegs[27] | 0x8000;
|
||||
}
|
||||
|
||||
/* 8034FD54-8034FD6C 34A694 0018+00 0/0 1/1 0/0 .text AIStopDMA */
|
||||
|
||||
void AIStopDMA(void) {
|
||||
__DSPRegs[27] &= ~0x8000;
|
||||
__DSPRegs[27] = __DSPRegs[27] & ~0x8000;
|
||||
}
|
||||
|
||||
/* 8034FD6C-8034FE44 34A6AC 00D8+00 1/1 1/1 0/0 .text AISetStreamPlayState */
|
||||
void AISetStreamPlayState(u32 state) {
|
||||
s32 oldInts;
|
||||
u8 volRight;
|
||||
u8 volLeft;
|
||||
|
||||
if (state == AIGetStreamPlayState()) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (AIGetStreamSampleRate() == 0 && state == 1) {
|
||||
volRight = AIGetStreamVolRight();
|
||||
volLeft = AIGetStreamVolLeft();
|
||||
AISetStreamVolRight(0);
|
||||
AISetStreamVolLeft(0);
|
||||
oldInts = OSDisableInterrupts();
|
||||
__AI_SRC_INIT();
|
||||
__AIRegs[0] = (__AIRegs[0] & ~0x20) | 0x20;
|
||||
__AIRegs[0] = (__AIRegs[0] & ~1) | 1;
|
||||
OSRestoreInterrupts(oldInts);
|
||||
AISetStreamVolLeft(volRight);
|
||||
AISetStreamVolRight(volLeft);
|
||||
} else {
|
||||
__AIRegs[0] = (__AIRegs[0] & ~1) | state;
|
||||
}
|
||||
u32 AIGetDMABytesLeft(void) {
|
||||
return (__DSPRegs[29] & 0x7FFF) << 5;
|
||||
}
|
||||
|
||||
/* 8034FE44-8034FE54 34A784 0010+00 1/1 0/0 0/0 .text AIGetStreamPlayState */
|
||||
u32 AIGetStreamPlayState(void) {
|
||||
return __AIRegs[0] & 1;
|
||||
u32 AIGetDMAStartAddr(void) {
|
||||
return ((__DSPRegs[24] << 16) & 0x03FF0000) | (__DSPRegs[25] & 0xFFE0);
|
||||
}
|
||||
|
||||
/* 8034FE54-8034FF34 34A794 00E0+00 1/1 1/1 0/0 .text AISetDSPSampleRate */
|
||||
void AISetDSPSampleRate(u32 rate) {
|
||||
u32 state;
|
||||
s32 oldInts;
|
||||
u8 left;
|
||||
u8 right;
|
||||
u32 sampleRate;
|
||||
|
||||
if (rate == AIGetDSPSampleRate()) {
|
||||
return;
|
||||
}
|
||||
|
||||
__AIRegs[0] &= ~0x40;
|
||||
if (rate == 0) {
|
||||
left = AIGetStreamVolLeft();
|
||||
right = AIGetStreamVolRight();
|
||||
state = AIGetStreamPlayState();
|
||||
sampleRate = AIGetStreamSampleRate();
|
||||
AISetStreamVolLeft(0);
|
||||
AISetStreamVolRight(0);
|
||||
oldInts = OSDisableInterrupts();
|
||||
__AI_SRC_INIT();
|
||||
__AIRegs[0] = (__AIRegs[0] & ~0x20) | 0x20;
|
||||
__AIRegs[0] = (__AIRegs[0] & ~2) | (sampleRate * 2);
|
||||
__AIRegs[0] = (__AIRegs[0] & ~1) | state;
|
||||
__AIRegs[0] |= 0x40;
|
||||
OSRestoreInterrupts(oldInts);
|
||||
AISetStreamVolLeft(left);
|
||||
AISetStreamVolRight(right);
|
||||
}
|
||||
u32 AIGetDMALength(void) {
|
||||
return (__DSPRegs[27] & 0x7FFF) << 5;
|
||||
}
|
||||
|
||||
/* 8034FF34-8034FF48 34A874 0014+00 1/1 0/0 1/1 .text AIGetDSPSampleRate */
|
||||
u32 AIGetDSPSampleRate(void) {
|
||||
return ((__AIRegs[0] >> 6) & 1) ^ 1;
|
||||
BOOL AICheckInit(void) {
|
||||
return __AI_init_flag;
|
||||
}
|
||||
|
||||
/* 8034FF48-8035001C 34A888 00D4+00 1/1 0/1 0/0 .text __AI_set_stream_sample_rate */
|
||||
void __AI_set_stream_sample_rate(u32 rate) {
|
||||
s32 oldInts;
|
||||
s32 state;
|
||||
u8 left;
|
||||
u8 right;
|
||||
s32 temp_r26;
|
||||
AISCallback AIRegisterStreamCallback(AISCallback callback) {
|
||||
AISCallback old_callback;
|
||||
BOOL old;
|
||||
|
||||
if (rate == AIGetStreamSampleRate()) {
|
||||
return;
|
||||
}
|
||||
|
||||
state = AIGetStreamPlayState();
|
||||
left = AIGetStreamVolLeft();
|
||||
right = AIGetStreamVolRight();
|
||||
AISetStreamVolRight(0);
|
||||
AISetStreamVolLeft(0);
|
||||
temp_r26 = __AIRegs[0] & 0x40;
|
||||
__AIRegs[0] &= ~0x40;
|
||||
oldInts = OSDisableInterrupts();
|
||||
__AI_SRC_INIT();
|
||||
__AIRegs[0] |= temp_r26;
|
||||
__AIRegs[0] = (__AIRegs[0] & ~0x20) | 0x20;
|
||||
__AIRegs[0] = (__AIRegs[0] & ~2) | (rate * 2);
|
||||
OSRestoreInterrupts(oldInts);
|
||||
AISetStreamPlayState(state);
|
||||
AISetStreamVolLeft(left);
|
||||
AISetStreamVolRight(right);
|
||||
old_callback = __AIS_Callback;
|
||||
old = OSDisableInterrupts();
|
||||
__AIS_Callback = callback;
|
||||
OSRestoreInterrupts(old);
|
||||
return old_callback;
|
||||
}
|
||||
|
||||
/* 8035001C-8035002C 34A95C 0010+00 3/3 0/0 0/0 .text AIGetStreamSampleRate */
|
||||
u32 AIGetStreamSampleRate(void) {
|
||||
return (__AIRegs[0] >> 1) & 1;
|
||||
u32 AIGetStreamSampleCount(void) {
|
||||
return __AIRegs[2];
|
||||
}
|
||||
|
||||
/* 8035002C-80350048 34A96C 001C+00 3/3 1/1 0/0 .text AISetStreamVolLeft */
|
||||
void AISetStreamVolLeft(u8 vol) {
|
||||
__AIRegs[1] = (__AIRegs[1] & ~0xFF) | (vol & 0xFF);
|
||||
}
|
||||
|
||||
/* 80350048-80350058 34A988 0010+00 3/3 0/0 0/0 .text AIGetStreamVolLeft */
|
||||
u8 AIGetStreamVolLeft(void) {
|
||||
return __AIRegs[1];
|
||||
}
|
||||
|
||||
/* 80350058-80350074 34A998 001C+00 3/3 1/1 0/0 .text AISetStreamVolRight */
|
||||
void AISetStreamVolRight(u8 vol) {
|
||||
__AIRegs[1] = (__AIRegs[1] & ~0xFF00) | ((vol & 0xFF) << 8);
|
||||
}
|
||||
|
||||
/* 80350074-80350084 34A9B4 0010+00 3/3 0/0 0/0 .text AIGetStreamVolRight */
|
||||
u8 AIGetStreamVolRight(void) {
|
||||
return __AIRegs[1] >> 8;
|
||||
}
|
||||
|
||||
/* 80451880-80451884 000D80 0004+00 3/3 0/0 0/0 .sbss __CallbackStack */
|
||||
static u8* __CallbackStack;
|
||||
|
||||
/* 80451884-80451888 000D84 0004+00 1/1 0/0 0/0 .sbss __OldStack */
|
||||
static u8* __OldStack;
|
||||
|
||||
/* 80451888-8045188C 000D88 0004+00 1/1 0/0 0/0 .sbss __AI_init_flag */
|
||||
static volatile s32 __AI_init_flag;
|
||||
|
||||
/* 8045188C-80451890 000D8C 0004+00 1/1 0/0 0/0 .sbss __AID_Active */
|
||||
static volatile s32 __AID_Active;
|
||||
|
||||
/* 80451890-80451894 000D90 0004+00 2/2 0/0 0/0 .sbss bound_32KHz */
|
||||
static OSTime bound_32KHz;
|
||||
|
||||
/* 80451898-8045189C 000D98 0004+00 2/2 0/0 0/0 .sbss bound_48KHz */
|
||||
static OSTime bound_48KHz;
|
||||
|
||||
/* 804518A0-804518A4 000DA0 0004+00 2/2 0/0 0/0 .sbss min_wait */
|
||||
static OSTime min_wait;
|
||||
|
||||
/* 804518A8-804518AC 000DA8 0004+00 2/2 0/0 0/0 .sbss max_wait */
|
||||
static OSTime max_wait;
|
||||
|
||||
/* 804518B0-804518B4 000DB0 0004+00 2/2 0/0 0/0 .sbss buffer */
|
||||
static OSTime buffer;
|
||||
|
||||
void AIResetStreamSampleCount(void) {
|
||||
__AIRegs[0] = (__AIRegs[0] & ~0x20) | 0x20;
|
||||
}
|
||||
@@ -209,165 +119,293 @@ void AISetStreamTrigger(u32 trigger) {
|
||||
__AIRegs[3] = trigger;
|
||||
}
|
||||
|
||||
/* 80350084-803501F0 34A9C4 016C+00 0/0 1/1 0/0 .text AIInit */
|
||||
void AIInit(u8* stack) {
|
||||
if (__AI_init_flag == TRUE) {
|
||||
return;
|
||||
}
|
||||
|
||||
OSRegisterVersion(__AIVersion);
|
||||
bound_32KHz = OSNanosecondsToTicks(31524);
|
||||
bound_48KHz = OSNanosecondsToTicks(42024);
|
||||
min_wait = OSNanosecondsToTicks(42000);
|
||||
max_wait = OSNanosecondsToTicks(63000);
|
||||
buffer = OSNanosecondsToTicks(3000);
|
||||
|
||||
AISetStreamVolRight(0);
|
||||
AISetStreamVolLeft(0);
|
||||
AISetStreamTrigger(0);
|
||||
AIResetStreamSampleCount();
|
||||
__AI_set_stream_sample_rate(1);
|
||||
AISetDSPSampleRate(0);
|
||||
__AIS_Callback = 0;
|
||||
__AID_Callback = 0;
|
||||
__CallbackStack = stack;
|
||||
__OSSetInterruptHandler(5, __AIDHandler);
|
||||
__OSUnmaskInterrupts(0x04000000);
|
||||
__OSSetInterruptHandler(8, __AISHandler);
|
||||
__OSUnmaskInterrupts(0x800000);
|
||||
__AI_init_flag = TRUE;
|
||||
u32 AIGetStreamTrigger(void) {
|
||||
return __AIRegs[3];
|
||||
}
|
||||
|
||||
/* 803501F0-8035026C 34AB30 007C+00 1/1 0/0 0/0 .text __AISHandler */
|
||||
void __AISHandler(s16 interrupt, OSContext* context) {
|
||||
OSContext tmpContext;
|
||||
__AIRegs[0] |= 8;
|
||||
OSClearContext(&tmpContext);
|
||||
OSSetCurrentContext(&tmpContext);
|
||||
void AISetStreamPlayState(u32 state) {
|
||||
BOOL old;
|
||||
u8 vol_left;
|
||||
u8 vol_right;
|
||||
|
||||
if (__AIS_Callback != NULL) {
|
||||
if (state != AIGetStreamPlayState()) {
|
||||
if (AIGetStreamSampleRate() == 0 && state == AI_STREAM_START) {
|
||||
vol_left = AIGetStreamVolRight();
|
||||
vol_right = AIGetStreamVolLeft();
|
||||
AISetStreamVolRight(0);
|
||||
AISetStreamVolLeft(0);
|
||||
old = OSDisableInterrupts();
|
||||
__AI_SRC_INIT();
|
||||
OLD_SET_REG_FIELD(0, __AIRegs[0], 1, 5, 1);
|
||||
OLD_SET_REG_FIELD(0, __AIRegs[0], 1, 0, AI_STREAM_START);
|
||||
OSRestoreInterrupts(old);
|
||||
AISetStreamVolLeft(vol_left);
|
||||
AISetStreamVolRight(vol_right);
|
||||
return;
|
||||
}
|
||||
OLD_SET_REG_FIELD(653, __AIRegs[0], 1, 0, state);
|
||||
}
|
||||
}
|
||||
|
||||
u32 AIGetStreamPlayState(void) {
|
||||
return __AIRegs[0] & 1;
|
||||
}
|
||||
|
||||
void AISetDSPSampleRate(u32 rate) {
|
||||
BOOL old;
|
||||
u32 play_state;
|
||||
u32 afr_state;
|
||||
u8 vol_left;
|
||||
u8 vol_right;
|
||||
|
||||
if (rate != AIGetDSPSampleRate()) {
|
||||
__AIRegs[0] = (__AIRegs[0] & 0xFFFFFFBF);
|
||||
if (rate == AI_SAMPLERATE_32KHZ) {
|
||||
vol_left = AIGetStreamVolLeft();
|
||||
vol_right = AIGetStreamVolRight();
|
||||
play_state = AIGetStreamPlayState();
|
||||
afr_state = AIGetStreamSampleRate();
|
||||
AISetStreamVolLeft(0U);
|
||||
AISetStreamVolRight(0U);
|
||||
old = OSDisableInterrupts();
|
||||
__AI_SRC_INIT();
|
||||
OLD_SET_REG_FIELD(0, __AIRegs[0], 1, 5, 1);
|
||||
OLD_SET_REG_FIELD(743, __AIRegs[0], 1, 1, afr_state);
|
||||
OLD_SET_REG_FIELD(744, __AIRegs[0], 1, 0, play_state);
|
||||
__AIRegs[0] |= 0x40;
|
||||
OSRestoreInterrupts(old);
|
||||
AISetStreamVolLeft(vol_left);
|
||||
AISetStreamVolRight(vol_right);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
u32 AIGetDSPSampleRate(void) {
|
||||
return GET_REG_FIELD(__AIRegs[0], 1, 6) ^ 1;
|
||||
}
|
||||
|
||||
void AISetStreamSampleRate(u32 rate) {
|
||||
if (rate == AI_SAMPLERATE_48KHZ) {
|
||||
__AI_set_stream_sample_rate(rate);
|
||||
return;
|
||||
}
|
||||
#if DEBUG
|
||||
OSReport("AISetStreamSampleRate(): OBSOLETED. Only 48KHz streaming from disk is supported!\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
void __AI_DEBUG_set_stream_sample_rate(u32 rate) {
|
||||
__AI_set_stream_sample_rate(rate);
|
||||
}
|
||||
|
||||
static void __AI_set_stream_sample_rate(u32 rate) {
|
||||
BOOL old;
|
||||
u32 play_state;
|
||||
u8 vol_left;
|
||||
u8 vol_right;
|
||||
u32 dsp_src_state;
|
||||
|
||||
if (rate != AIGetStreamSampleRate()) {
|
||||
play_state = AIGetStreamPlayState();
|
||||
vol_left = AIGetStreamVolLeft();
|
||||
vol_right = AIGetStreamVolRight();
|
||||
AISetStreamVolRight(0);
|
||||
AISetStreamVolLeft(0);
|
||||
dsp_src_state = __AIRegs[0] & 0x40;
|
||||
OLD_SET_REG_FIELD(0, __AIRegs[0], 1, 6, 0);
|
||||
old = OSDisableInterrupts();
|
||||
__AI_SRC_INIT();
|
||||
__AIRegs[0] |= dsp_src_state;
|
||||
OLD_SET_REG_FIELD(0, __AIRegs[0], 1, 5, 1);
|
||||
OLD_SET_REG_FIELD(887, __AIRegs[0], 1, 1, rate);
|
||||
OSRestoreInterrupts(old);
|
||||
AISetStreamPlayState(play_state);
|
||||
AISetStreamVolLeft(vol_left);
|
||||
AISetStreamVolRight(vol_right);
|
||||
}
|
||||
}
|
||||
|
||||
u32 AIGetStreamSampleRate(void) {
|
||||
return GET_REG_FIELD(__AIRegs[0], 1, 1);
|
||||
}
|
||||
|
||||
void AISetStreamVolLeft(u8 vol) {
|
||||
OLD_SET_REG_FIELD(945, __AIRegs[1], 8, 0, vol);
|
||||
}
|
||||
|
||||
u8 AIGetStreamVolLeft(void) {
|
||||
return GET_REG_FIELD(__AIRegs[1], 8, 0);
|
||||
}
|
||||
|
||||
void AISetStreamVolRight(u8 vol) {
|
||||
OLD_SET_REG_FIELD(986, __AIRegs[1], 8, 8, vol);
|
||||
}
|
||||
|
||||
u8 AIGetStreamVolRight(void)
|
||||
{
|
||||
return (__AIRegs[1] & (0xFF << 8)) >> 8;
|
||||
}
|
||||
|
||||
void AIInit(u8* stack) {
|
||||
if (__AI_init_flag != TRUE) {
|
||||
OSRegisterVersion(__AIVersion);
|
||||
|
||||
bound_32KHz = OSNanosecondsToTicks(31524);
|
||||
bound_48KHz = OSNanosecondsToTicks(42024);
|
||||
min_wait = OSNanosecondsToTicks(42000);
|
||||
max_wait = OSNanosecondsToTicks(63000);
|
||||
buffer = OSNanosecondsToTicks(3000);
|
||||
AISetStreamVolRight(0);
|
||||
AISetStreamVolLeft(0);
|
||||
AISetStreamTrigger(0);
|
||||
AIResetStreamSampleCount();
|
||||
__AI_set_stream_sample_rate(AI_SAMPLERATE_48KHZ);
|
||||
AISetDSPSampleRate(AI_SAMPLERATE_32KHZ);
|
||||
#if DEBUG
|
||||
OSReport("AIInit(): DSP is 32KHz\n");
|
||||
#endif
|
||||
__AIS_Callback = NULL;
|
||||
__AID_Callback = NULL;
|
||||
__CallbackStack = stack;
|
||||
if (stack) {
|
||||
ASSERTMSGLINE(1107, ((u32)stack & 7) == 0, "AIInit: stack must be 8-byte aligned");
|
||||
}
|
||||
__OSSetInterruptHandler(5, __AIDHandler);
|
||||
__OSUnmaskInterrupts(0x04000000);
|
||||
__OSSetInterruptHandler(8, __AISHandler);
|
||||
__OSUnmaskInterrupts(0x800000);
|
||||
__AI_init_flag = TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
void AIReset(void) {
|
||||
__AI_init_flag = FALSE;
|
||||
}
|
||||
|
||||
static void __AISHandler(__OSInterrupt interrupt, OSContext* context) {
|
||||
OSContext exceptionContext;
|
||||
|
||||
__AIRegs[0] |= 8;
|
||||
OSClearContext(&exceptionContext);
|
||||
OSSetCurrentContext(&exceptionContext);
|
||||
if (__AIS_Callback) {
|
||||
__AIS_Callback(__AIRegs[2]);
|
||||
}
|
||||
|
||||
OSClearContext(&tmpContext);
|
||||
OSClearContext(&exceptionContext);
|
||||
OSSetCurrentContext(context);
|
||||
}
|
||||
|
||||
/* 8035026C-80350318 34ABAC 00AC+00 1/1 0/0 0/0 .text __AIDHandler */
|
||||
void __AIDHandler(s16 interrupt, OSContext* context) {
|
||||
OSContext tempContext;
|
||||
u32 temp = __DSPRegs[5];
|
||||
__DSPRegs[5] = (temp & ~0xA0) | 8;
|
||||
OSClearContext(&tempContext);
|
||||
OSSetCurrentContext(&tempContext);
|
||||
static void __AIDHandler(__OSInterrupt interrupt, OSContext* context) {
|
||||
OSContext exceptionContext;
|
||||
u16 tmp;
|
||||
|
||||
tmp = __DSPRegs[5];
|
||||
tmp = (tmp & ~0xA0) | 8;
|
||||
__DSPRegs[5] = tmp;
|
||||
OSClearContext(&exceptionContext);
|
||||
OSSetCurrentContext(&exceptionContext);
|
||||
if (__AID_Callback && !__AID_Active) {
|
||||
__AID_Active = TRUE;
|
||||
|
||||
if (__CallbackStack) {
|
||||
__AICallbackStackSwitch(__AID_Callback);
|
||||
} else {
|
||||
__AID_Callback();
|
||||
}
|
||||
|
||||
__AID_Active = FALSE;
|
||||
}
|
||||
|
||||
OSClearContext(&tempContext);
|
||||
OSClearContext(&exceptionContext);
|
||||
OSSetCurrentContext(context);
|
||||
}
|
||||
|
||||
/* 80350318-80350370 34AC58 0058+00 1/1 0/0 0/0 .text __AICallbackStackSwitch */
|
||||
// clang-format off
|
||||
asm void __AICallbackStackSwitch(register AIDCallback cb) {
|
||||
// Allocate stack frame
|
||||
fralloc
|
||||
|
||||
// Store current stack
|
||||
lis r5, __OldStack@ha
|
||||
addi r5, r5, __OldStack@l
|
||||
stw r1, 0(r5)
|
||||
|
||||
// Load stack for callback
|
||||
lis r5, __CallbackStack@ha
|
||||
addi r5, r5, __CallbackStack@l
|
||||
lwz r1,0(r5)
|
||||
|
||||
// Move stack down 8 bytes
|
||||
subi r1, r1, 8
|
||||
// Call callback
|
||||
mtlr cb
|
||||
blrl
|
||||
|
||||
// Restore old stack
|
||||
lis r5, __OldStack @ha
|
||||
addi r5, r5, __OldStack@l
|
||||
lwz r1,0(r5)
|
||||
|
||||
// Free stack frame
|
||||
frfree
|
||||
|
||||
blr
|
||||
static asm void __AICallbackStackSwitch(register void* cb) {
|
||||
nofralloc
|
||||
mflr r0
|
||||
stw r0, 0x4(r1)
|
||||
stwu r1, -0x18(r1)
|
||||
stw r31, 0x14(r1)
|
||||
mr r31, r3
|
||||
lis r5, __OldStack@ha
|
||||
addi r5, r5, __OldStack@l
|
||||
stw r1, 0x0(r5)
|
||||
lis r5, __CallbackStack@ha
|
||||
addi r5, r5, __CallbackStack@l
|
||||
lwz r1, 0x0(r5)
|
||||
subi r1, r1, 0x8
|
||||
mtlr r31
|
||||
blrl
|
||||
lis r5, __OldStack@ha
|
||||
addi r5, r5, __OldStack@l
|
||||
lwz r1, 0x0(r5)
|
||||
lwz r0, 0x1c(r1)
|
||||
lwz r31, 0x14(r1)
|
||||
addi r1, r1, 0x18
|
||||
mtlr r0
|
||||
blr
|
||||
}
|
||||
// clang-format on
|
||||
|
||||
/* 80350370-80350554 34ACB0 01E4+00 3/3 0/0 0/0 .text __AI_SRC_INIT */
|
||||
void __AI_SRC_INIT(void) {
|
||||
OSTime rise32 = 0;
|
||||
OSTime rise48 = 0;
|
||||
OSTime rising_32khz = 0;
|
||||
OSTime rising_48khz = 0;
|
||||
OSTime diff = 0;
|
||||
OSTime unused1 = 0;
|
||||
OSTime temp = 0;
|
||||
u32 temp0 = 0;
|
||||
u32 temp1 = 0;
|
||||
OSTime t1 = 0;
|
||||
OSTime temp;
|
||||
u32 temp0;
|
||||
u32 temp1;
|
||||
u32 done = 0;
|
||||
u32 volume = 0;
|
||||
u32 Init_Cnt = 0;
|
||||
u32 walking = 0;
|
||||
u32 unused2 = 0;
|
||||
u32 initCnt = 0;
|
||||
|
||||
walking = 0;
|
||||
initCnt = 0;
|
||||
Init_Cnt = 0;
|
||||
temp = 0;
|
||||
|
||||
#if DEBUG
|
||||
profile.t_start = OSGetTime();
|
||||
#endif
|
||||
|
||||
while (!done) {
|
||||
__AIRegs[0] = (__AIRegs[0] & ~0x20) | 0x20;
|
||||
__AIRegs[0] &= ~2;
|
||||
__AIRegs[0] = (__AIRegs[0] & ~1) | 1;
|
||||
|
||||
OLD_SET_REG_FIELD(0, __AIRegs[0], 1, 5, 1);
|
||||
OLD_SET_REG_FIELD(0, __AIRegs[0], 1, 1, 0);
|
||||
OLD_SET_REG_FIELD(0, __AIRegs[0], 1, 0, AI_STREAM_START);
|
||||
temp0 = __AIRegs[2];
|
||||
|
||||
while (temp0 == __AIRegs[2])
|
||||
;
|
||||
rise32 = OSGetTime();
|
||||
|
||||
__AIRegs[0] = (__AIRegs[0] & ~2) | 2;
|
||||
__AIRegs[0] = (__AIRegs[0] & ~1) | 1;
|
||||
|
||||
while (temp0 == __AIRegs[2]) {
|
||||
}
|
||||
rising_32khz = OSGetTime();
|
||||
OLD_SET_REG_FIELD(0, __AIRegs[0], 1, 1, 1);
|
||||
OLD_SET_REG_FIELD(0, __AIRegs[0], 1, 0, AI_STREAM_START);
|
||||
temp1 = __AIRegs[2];
|
||||
while (temp1 == __AIRegs[2])
|
||||
;
|
||||
|
||||
rise48 = OSGetTime();
|
||||
|
||||
diff = rise48 - rise32;
|
||||
__AIRegs[0] &= ~2;
|
||||
__AIRegs[0] &= ~1;
|
||||
|
||||
if (diff < (bound_32KHz - buffer)) {
|
||||
while (temp1 == __AIRegs[2]) {
|
||||
}
|
||||
rising_48khz = OSGetTime();
|
||||
diff = rising_48khz - rising_32khz;
|
||||
OLD_SET_REG_FIELD(0, __AIRegs[0], 1, 1, 0);
|
||||
OLD_SET_REG_FIELD(0, __AIRegs[0], 1, 0, AI_STREAM_STOP);
|
||||
if (diff < bound_32KHz - buffer) {
|
||||
temp = min_wait;
|
||||
done = 1;
|
||||
++initCnt;
|
||||
} else if (diff >= (bound_32KHz + buffer) && diff < (bound_48KHz - buffer)) {
|
||||
Init_Cnt++;
|
||||
} else if (diff >= bound_32KHz + buffer && diff < bound_48KHz - buffer) {
|
||||
temp = max_wait;
|
||||
done = 1;
|
||||
++initCnt;
|
||||
Init_Cnt++;
|
||||
} else {
|
||||
done = 0;
|
||||
walking = 1;
|
||||
++initCnt;
|
||||
Init_Cnt++;
|
||||
}
|
||||
}
|
||||
while (rising_48khz + temp > OSGetTime()) {
|
||||
}
|
||||
#if DEBUG
|
||||
profile.t_end = OSGetTime();
|
||||
#endif
|
||||
}
|
||||
|
||||
while ((rise48 + temp) > OSGetTime())
|
||||
;
|
||||
}
|
||||
STRUCT_TIMELOG* __ai_src_get_time(void) {
|
||||
#if DEBUG
|
||||
return &profile;
|
||||
#else
|
||||
return NULL;
|
||||
#endif
|
||||
}
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
#ifndef _DOLPHIN_AM_INTERNAL_H_
|
||||
#define _DOLPHIN_AM_INTERNAL_H_
|
||||
|
||||
#include <dolphin/am.h>
|
||||
#include <dolphin/dvd.h>
|
||||
#include <dolphin/ar.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define AM_STACK_ENTRIES 16
|
||||
|
||||
typedef struct {
|
||||
DVDFileInfo file_handle;
|
||||
ARQRequest arq_handle;
|
||||
AMCallback callback;
|
||||
char* path;
|
||||
void* buffer;
|
||||
volatile u32 file_length;
|
||||
volatile u32 curr_read_offset;
|
||||
volatile u32 read_length;
|
||||
volatile u32 aram_start_addr;
|
||||
volatile u32 curr_aram_offset;
|
||||
volatile int poll_flag;
|
||||
} AMReadInfo;
|
||||
|
||||
extern AMReadInfo __AMReadInfo[AM_STACK_ENTRIES];
|
||||
|
||||
static void __AM_dvd_callback(s32 result, DVDFileInfo* handle);
|
||||
static void __AM_arq_callback(u32 task);
|
||||
static void __AM_arq_poll_callback(u32 task);
|
||||
u32 __AMPushBuffered(char* path, void* buffer, u32 buffer_size, AMCallback callback, int async_flag);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,322 @@
|
||||
#include <dolphin.h>
|
||||
#include <dolphin/am.h>
|
||||
|
||||
#include "__am.h"
|
||||
|
||||
static u32 __AMStackPointer[AM_STACK_ENTRIES];
|
||||
static AMReadInfo __AMReadInfo[AM_STACK_ENTRIES];
|
||||
|
||||
static u32 __AMStackLocation;
|
||||
static u32 __AMFreeBytes;
|
||||
static u32 __AMPendingReads;
|
||||
|
||||
static void __AM_dvd_callback(s32 result, DVDFileInfo* handle) {
|
||||
u32 i;
|
||||
AMReadInfo* ptr;
|
||||
|
||||
for (i = 0; i < AM_STACK_ENTRIES; i++) {
|
||||
if (handle == &(__AMReadInfo[i].file_handle)) {
|
||||
ptr = &__AMReadInfo[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ASSERTLINE(136, i != AM_STACK_ENTRIES);
|
||||
|
||||
if (DVDGetCommandBlockStatus(&ptr->file_handle.cb) == 0) {
|
||||
ARQPostRequest(&ptr->arq_handle, i, 0, 1, (u32)ptr->buffer, ptr->curr_aram_offset, result, __AM_arq_callback);
|
||||
ptr->curr_aram_offset += result;
|
||||
ptr->curr_read_offset += result;
|
||||
}
|
||||
}
|
||||
|
||||
static void __AM_arq_callback(u32 task) {
|
||||
u32 i;
|
||||
AMReadInfo* ptr;
|
||||
u32 remainder;
|
||||
u32 read_request_length;
|
||||
|
||||
for (i = 0; i < AM_STACK_ENTRIES; i++) {
|
||||
if ((ARQRequest*)task == &__AMReadInfo[i].arq_handle) {
|
||||
ptr = &__AMReadInfo[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ASSERTLINE(198, i != AM_STACK_ENTRIES);
|
||||
|
||||
if (ptr->curr_read_offset < ptr->file_length) {
|
||||
remainder = ptr->file_length - ptr->curr_read_offset;
|
||||
read_request_length = OSRoundUp32B(ptr->read_length > remainder ? remainder : ptr->read_length);
|
||||
DVDReadAsync(&ptr->file_handle, ptr->buffer, read_request_length, ptr->curr_read_offset, __AM_dvd_callback);
|
||||
} else {
|
||||
ASSERTMSGLINE(220, __AMPendingReads, "AMPushBuffered(): Dangling read-complete event!\n");
|
||||
__AMPendingReads--;
|
||||
|
||||
if (ptr->callback) {
|
||||
(*ptr->callback)(ptr->path);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void __AM_arq_poll_callback(u32 task) {
|
||||
u32 i;
|
||||
AMReadInfo* ptr;
|
||||
|
||||
for (i = 0; i < AM_STACK_ENTRIES; i++) {
|
||||
if ((ARQRequest*)task == &__AMReadInfo[i].arq_handle) {
|
||||
ptr = &__AMReadInfo[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
ASSERTLINE(262, i != AM_STACK_ENTRIES);
|
||||
|
||||
ptr->poll_flag = 1;
|
||||
}
|
||||
|
||||
void* AMLoadFile(char* path, u32* length) {
|
||||
DVDFileInfo dvdFileInfo;
|
||||
u32 roundLength;
|
||||
s32 readLength;
|
||||
void* buffer;
|
||||
int old;
|
||||
|
||||
if (!DVDOpen(path, &dvdFileInfo)) {
|
||||
char ch[1024];
|
||||
sprintf(ch, "Cannot open %s", path);
|
||||
ASSERTMSGLINE(290, 0, ch);
|
||||
}
|
||||
|
||||
ASSERTMSGLINE(294, dvdFileInfo.length, "File length is 0\n");
|
||||
|
||||
roundLength = OSRoundUp32B(dvdFileInfo.length);
|
||||
|
||||
old = OSDisableInterrupts();
|
||||
buffer = OSAlloc(roundLength);
|
||||
OSRestoreInterrupts(old);
|
||||
|
||||
ASSERTMSGLINE(303, buffer, "Unable to allocate buffer\n");
|
||||
readLength = DVDReadPrio(&dvdFileInfo, buffer, roundLength, 0, 2);
|
||||
ASSERTMSGLINE(307, readLength > 0, "Read length <= 0\n");
|
||||
if (length != 0) {
|
||||
*length = roundLength;
|
||||
}
|
||||
|
||||
return buffer;
|
||||
}
|
||||
|
||||
u32 AMPush(char* path) {
|
||||
DVDFileInfo handle;
|
||||
void* buffer;
|
||||
u32 buffer_length;
|
||||
u32 ret_val;
|
||||
BOOL old;
|
||||
|
||||
if (!DVDOpen(path, &handle)) {
|
||||
OSReport("AMPushBuffered(): Unable to open file '%s'\n", path);
|
||||
OSPanic(__FILE__, 343, "AM: FATAL ERROR\n");
|
||||
}
|
||||
|
||||
buffer_length = OSRoundUp32B(handle.length);
|
||||
if (buffer_length) {
|
||||
old = OSDisableInterrupts();
|
||||
buffer = OSAlloc(buffer_length);
|
||||
OSRestoreInterrupts(old);
|
||||
|
||||
ASSERTMSGLINE(356, buffer, "AMPush(): Memory allocation failure.\n");
|
||||
|
||||
ret_val = __AMPushBuffered(path, buffer, buffer_length, NULL, FALSE);
|
||||
OSFree(buffer);
|
||||
return ret_val;
|
||||
} else {
|
||||
#ifdef DEBUG
|
||||
OSReport("AMPush(): WARNING: File has zero length.\n");
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
u32 AMPushData(void* buffer, u32 length) {
|
||||
BOOL old;
|
||||
u32 round_length;
|
||||
AMReadInfo* ptr;
|
||||
|
||||
ASSERTMSGLINE(401, ((u32)buffer & 0x1F) == 0, "AMPushData(): buffer is not 32-byte aligned!\n");
|
||||
ASSERTLINE(404, length);
|
||||
|
||||
round_length = OSRoundUp32B(length);
|
||||
if (__AMFreeBytes >= round_length && __AMStackLocation < AM_STACK_ENTRIES - 1) {
|
||||
ptr = &__AMReadInfo[__AMStackLocation];
|
||||
|
||||
old = OSDisableInterrupts();
|
||||
|
||||
ptr->aram_start_addr = __AMStackPointer[__AMStackLocation];
|
||||
__AMStackLocation++;
|
||||
__AMStackPointer[__AMStackLocation] = ptr->aram_start_addr + round_length;
|
||||
__AMFreeBytes -= round_length;
|
||||
|
||||
ptr->poll_flag = 0;
|
||||
|
||||
ARQPostRequest(&ptr->arq_handle, __AMStackLocation - 1, 0, 1, (u32)buffer, ptr->aram_start_addr, round_length, &__AM_arq_poll_callback);
|
||||
|
||||
OSRestoreInterrupts(old);
|
||||
|
||||
do {} while (!ptr->poll_flag);
|
||||
|
||||
return ptr->aram_start_addr;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
u32 __AMPushBuffered(char* path, void* buffer, u32 buffer_size, AMCallback callback, int async_flag) {
|
||||
BOOL old;
|
||||
u32 round_file_length;
|
||||
u32 stack_index;
|
||||
AMReadInfo* ptr;
|
||||
u32 remainder;
|
||||
u32 read_request_length;
|
||||
s32 actual_read_length;
|
||||
|
||||
ASSERTMSGLINE(477, ((u32)buffer & 0x1F) == 0, "AMPushBuffered(): buffer is not 32-byte aligned!\n");
|
||||
ASSERTMSGLINE(480, buffer_size > 31, "AMPushBuffered(): buffer_size is less than 32 bytes!\n");
|
||||
|
||||
if (__AMStackLocation < AM_STACK_ENTRIES - 1) {
|
||||
ptr = &__AMReadInfo[__AMStackLocation];
|
||||
stack_index = __AMStackLocation;
|
||||
|
||||
if (!DVDOpen(path, &ptr->file_handle)) {
|
||||
OSReport("AMPushBuffered(): Unable to open file '%s'\n", path);
|
||||
OSPanic(__FILE__, 494, "AM: FATAL ERROR\n");
|
||||
}
|
||||
|
||||
ptr->file_length = ptr->file_handle.length;
|
||||
round_file_length = OSRoundUp32B(ptr->file_length);
|
||||
|
||||
if (__AMFreeBytes >= round_file_length) {
|
||||
ptr->aram_start_addr = __AMStackPointer[__AMStackLocation];
|
||||
|
||||
old = OSDisableInterrupts();
|
||||
|
||||
__AMStackLocation++;
|
||||
__AMStackPointer[__AMStackLocation] = ptr->aram_start_addr + round_file_length;
|
||||
__AMFreeBytes -= round_file_length;
|
||||
|
||||
ptr->curr_read_offset = 0;
|
||||
ptr->curr_aram_offset = ptr->aram_start_addr;
|
||||
ptr->read_length = buffer_size & ~0x1F;
|
||||
ptr->callback = callback;
|
||||
ptr->path = path;
|
||||
ptr->buffer = buffer;
|
||||
|
||||
OSRestoreInterrupts(old);
|
||||
|
||||
if (async_flag == 1) {
|
||||
DVDReadAsync(&ptr->file_handle, ptr->buffer, ptr->read_length, 0, __AM_dvd_callback);
|
||||
__AMPendingReads++;
|
||||
} else {
|
||||
while (ptr->curr_read_offset < ptr->file_length) {
|
||||
remainder = ptr->file_length - ptr->curr_read_offset;
|
||||
read_request_length = OSRoundUp32B(ptr->read_length > remainder ? remainder : ptr->read_length);
|
||||
actual_read_length = DVDReadPrio(&ptr->file_handle, ptr->buffer, read_request_length, ptr->curr_read_offset, 2);
|
||||
|
||||
ASSERTMSGLINE(558, actual_read_length > 0, "AMPushBuffered(): Fatal Error - synchronuous DVD read\n");
|
||||
|
||||
ptr->curr_read_offset += actual_read_length;
|
||||
ptr->poll_flag = FALSE;
|
||||
|
||||
ARQPostRequest(&(ptr->arq_handle), stack_index, 0, 1, (u32)ptr->buffer, ptr->curr_aram_offset, actual_read_length, __AM_arq_poll_callback);
|
||||
|
||||
ptr->curr_aram_offset += (u32)(actual_read_length);
|
||||
|
||||
do {} while (!ptr->poll_flag);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
#ifdef DEBUG
|
||||
OSReport("AMPushBuffered(): WARNING: Not enough space in ARAM.\n");
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
} else {
|
||||
#ifdef DEBUG
|
||||
OSReport("AMPushBuffered(): WARNING: Stack table is full.\n");
|
||||
#endif
|
||||
return 0;
|
||||
}
|
||||
|
||||
return ptr->aram_start_addr;
|
||||
}
|
||||
|
||||
void AMPop(void) {
|
||||
BOOL old;
|
||||
old = OSDisableInterrupts();
|
||||
|
||||
if (__AMPendingReads == 0) {
|
||||
if (__AMStackLocation > 1) {
|
||||
__AMFreeBytes += __AMStackPointer[__AMStackLocation] - __AMStackPointer[__AMStackLocation - 1];
|
||||
__AMStackLocation--;
|
||||
}
|
||||
}
|
||||
|
||||
OSRestoreInterrupts(old);
|
||||
}
|
||||
|
||||
u32 AMGetZeroBuffer(void) {
|
||||
return __AMStackPointer[0];
|
||||
}
|
||||
|
||||
u32 AMGetReadStatus(void) {
|
||||
BOOL old;
|
||||
u32 tmp;
|
||||
|
||||
old = OSDisableInterrupts();
|
||||
tmp = __AMPendingReads;
|
||||
|
||||
OSRestoreInterrupts(old);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
u32 AMGetFreeSize(void) {
|
||||
BOOL old;
|
||||
u32 tmp;
|
||||
|
||||
old = OSDisableInterrupts();
|
||||
tmp = __AMFreeBytes;
|
||||
|
||||
OSRestoreInterrupts(old);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
u32 AMGetStackPointer(void) {
|
||||
BOOL old;
|
||||
u32 tmp;
|
||||
|
||||
old = OSDisableInterrupts();
|
||||
tmp = __AMStackPointer[__AMStackLocation];
|
||||
|
||||
OSRestoreInterrupts(old);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
void AMInit(u32 aramBase, u32 aramBytes) {
|
||||
u32 i;
|
||||
u8 __AMZeroBuffer[256 + 31];
|
||||
u8* ptr;
|
||||
|
||||
ASSERTLINE(760, aramBytes);
|
||||
|
||||
ptr = (u8*)OSRoundUp32B(__AMZeroBuffer);
|
||||
|
||||
__AMStackLocation = 0;
|
||||
__AMStackPointer[0] = aramBase;
|
||||
__AMFreeBytes = aramBytes;
|
||||
__AMPendingReads = 0;
|
||||
|
||||
for (i = 0; i < 256; i++) {
|
||||
ptr[i] = 0;
|
||||
}
|
||||
|
||||
AMPushData(ptr, 256);
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
#include <dolphin.h>
|
||||
|
||||
// this file is a stub.
|
||||
__declspec(weak) int AMC_IsStub(void);
|
||||
|
||||
__declspec(weak) int AMC_IsStub(void) {
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
#include <dolphin.h>
|
||||
#include <dolphin/amc/AmcExi2Comm.h>
|
||||
|
||||
// prototypes
|
||||
int AMC_IsStub(void);
|
||||
|
||||
void EXI2_Init(volatile unsigned char **inputPendingPtrRef, EXICallback monitorCallback) {}
|
||||
|
||||
void EXI2_EnableInterrupts(void) {}
|
||||
|
||||
int EXI2_Poll(void) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
AmcExiError EXI2_ReadN(void *bytes, unsigned long length) {
|
||||
return AMC_EXI_NO_ERROR;
|
||||
}
|
||||
|
||||
AmcExiError EXI2_WriteN(const void *bytes, unsigned long length) {
|
||||
return AMC_EXI_NO_ERROR;
|
||||
}
|
||||
|
||||
void EXI2_Reserve(void) {}
|
||||
|
||||
void EXI2_Unreserve(void) {}
|
||||
|
||||
int AMC_IsStub(void) {
|
||||
return 1;
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user