mirror/oot
1
0
Fork 0
mirror of https://github.com/zeldaret/oot.git synced 2025-07-13 19:35:28 +00:00
Code Issues Projects Releases Wiki Activity

Merge branch 'master' into doc_pause_menu

Browse source
This commit is contained in:
Dragorn421 2022-08-28 22:52:31 +02:00
commit a02cbf5d12
No known key found for this signature in database
GPG key ID: 32B53D2D16FC4118
26 changed files with 812 additions and 532 deletions
Download patch file Download diff file Expand all files Collapse all files

609
src/code/PreRender.c
View file

@ -1,3 +1,10 @@
/**
* @file PreRender.c
*
* This file implements various routines important to framebuffer effects, such as RDP accelerated color and depth
* buffer copies and coverage drawing. Also contains software implementations of the Video Interface anti-aliasing and
* divot filters.
*/
#include "global.h"
#include "alloca.h"
@ -33,11 +40,18 @@ void PreRender_Destroy(PreRender* this) {
ListAlloc_FreeAll(&this->alloc);
}
void func_800C0F28(PreRender* this, Gfx** gfxp, void* buf, void* bufSave) {
/**
* Copies RGBA16 image `img` to `imgDst`
*
* @param gfxp Display list pointer
* @param img Image to copy from
* @param imgDst Buffer to copy to
*/
void PreRender_CopyImage(PreRender* this, Gfx** gfxp, void* img, void* imgDst) {
Gfx* gfx;
s32 x;
s32 x2;
s32 dx;
s32 rowsRemaining;
s32 curRow;
s32 nRows;
LogUtils_CheckNullPointer("this", this, "../PreRender.c", 215);
LogUtils_CheckNullPointer("glistpp", gfxp, "../PreRender.c", 216);
@ -45,35 +59,44 @@ void func_800C0F28(PreRender* this, Gfx** gfxp, void* buf, void* bufSave) {
LogUtils_CheckNullPointer("glistp", gfx, "../PreRender.c", 218);
gDPPipeSync(gfx++);
// Configure the cycle type to COPY mode, disable blending
gDPSetOtherMode(gfx++,
G_AD_PATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_CONV | G_TF_POINT | G_TT_NONE | G_TL_TILE |
G_TD_CLAMP | G_TP_NONE | G_CYC_COPY | G_PM_NPRIMITIVE,
G_AC_NONE | G_ZS_PIXEL | G_RM_NOOP | G_RM_NOOP2);
gDPSetColorImage(gfx++, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, bufSave);
// Set the destination buffer as the color image and set the scissoring region to the entire image
gDPSetColorImage(gfx++, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, imgDst);
gDPSetScissor(gfx++, G_SC_NON_INTERLACE, 0, 0, this->width, this->height);
dx = 0x1000 / (this->width * 2);
// Calculate the max number of rows that can fit into TMEM at once
nRows = TMEM_SIZE / (this->width * G_IM_SIZ_16b_BYTES);
x = this->height;
x2 = 0;
while (x > 0) {
rowsRemaining = this->height;
curRow = 0;
while (rowsRemaining > 0) {
s32 uls = 0;
s32 lrs = this->width - 1;
s32 ult;
s32 lrt;
dx = CLAMP_MAX(dx, x);
ult = x2;
lrt = (ult + dx) - 1;
// Make sure that we don't load past the end of the source image
nRows = MIN(rowsRemaining, nRows);
gDPLoadTextureTile(gfx++, buf, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, this->height, uls, ult, lrs, lrt, 0,
// Determine the upper and lower bounds of the rect to draw
ult = curRow;
lrt = ult + nRows - 1;
// Load a horizontal strip of the source image in RGBA16 format
gDPLoadTextureTile(gfx++, img, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, this->height, uls, ult, lrs, lrt, 0,
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
G_TX_NOLOD);
// Draw that horizontal strip to the destination image, dsdx is 4 << 10 for COPY mode
gSPTextureRectangle(gfx++, uls << 2, ult << 2, lrs << 2, lrt << 2, G_TX_RENDERTILE, uls << 5, ult << 5, 4 << 10,
1 << 10);
x -= dx;
x2 += dx;
rowsRemaining -= nRows;
curRow += nRows;
}
gDPPipeSync(gfx++);
@ -81,11 +104,15 @@ void func_800C0F28(PreRender* this, Gfx** gfxp, void* buf, void* bufSave) {
*gfxp = gfx;
}
void func_800C1258(PreRender* this, Gfx** gfxp) {
/**
* Copies part of `this->fbufSave` in the region (this->ulx, this->uly), (this->lrx, this->lry) to the same location in
* `this->fbuf`.
*/
void PreRender_CopyImageRegionImpl(PreRender* this, Gfx** gfxp) {
Gfx* gfx;
s32 y;
s32 y2;
s32 dy;
s32 rowsRemaining;
s32 curRow;
s32 nRows;
LogUtils_CheckNullPointer("this", this, "../PreRender.c", 278);
LogUtils_CheckNullPointer("glistpp", gfxp, "../PreRender.c", 279);
@ -93,49 +120,62 @@ void func_800C1258(PreRender* this, Gfx** gfxp) {
LogUtils_CheckNullPointer("glistp", gfx, "../PreRender.c", 281);
gDPPipeSync(gfx++);
// Configure the cycle type to COPY mode, disable blending
gDPSetOtherMode(gfx++,
G_AD_PATTERN | G_CD_MAGICSQ | G_CK_NONE | G_TC_CONV | G_TF_POINT | G_TT_NONE | G_TL_TILE |
G_TD_CLAMP | G_TP_NONE | G_CYC_COPY | G_PM_NPRIMITIVE,
G_AC_NONE | G_ZS_PIXEL | G_RM_NOOP | G_RM_NOOP2);
// Set the destination buffer as the color image and set the scissoring region to the destination region
gDPSetColorImage(gfx++, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, this->fbuf);
gDPSetScissor(gfx++, G_SC_NON_INTERLACE, this->ulx, this->uly, this->lrx + 1, this->lry + 1);
dy = 0x1000 / ((this->lrxSave - this->ulxSave + 1) * 2);
// Calculate the max number of rows that can fit into TMEM at once
nRows = TMEM_SIZE / ((this->lrxSave - this->ulxSave + 1) * G_IM_SIZ_16b_BYTES);
y = (this->lrySave - this->ulySave) + 1;
y2 = 0;
while (y > 0) {
rowsRemaining = (this->lrySave - this->ulySave) + 1;
curRow = 0;
while (rowsRemaining > 0) {
s32 ult;
s32 lrt;
s32 uly;
dy = CLAMP_MAX(dy, y);
// Make sure that we don't load past the end of the source image
nRows = MIN(rowsRemaining, nRows);
ult = this->ulySave + y2;
lrt = (ult + dy) - 1;
uly = this->uly + y2;
// Determine the upper and lower bounds of the rect to draw
ult = this->ulySave + curRow;
lrt = ult + nRows - 1;
uly = this->uly + curRow;
// Load a horizontal strip of the source image in RGBA16 format
gDPLoadTextureTile(gfx++, this->fbufSave, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->widthSave, this->height - 1,
this->ulxSave, ult, this->lrxSave, lrt, 0, G_TX_NOMIRROR | G_TX_WRAP,
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
gSPTextureRectangle(gfx++, this->ulx << 2, uly << 2, this->lrx << 2, (uly + dy - 1) << 2, G_TX_RENDERTILE,
// Draw that horizontal strip to the destination image, dsdx is 4 << 10 for COPY mode
gSPTextureRectangle(gfx++, this->ulx << 2, uly << 2, this->lrx << 2, (uly + nRows - 1) << 2, G_TX_RENDERTILE,
this->ulxSave << 5, ult << 5, 4 << 10, 1 << 10);
y -= dy;
y2 += dy;
rowsRemaining -= nRows;
curRow += nRows;
}
// Reset the color image and scissor
gDPPipeSync(gfx++);
gDPSetColorImage(gfx++, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, this->fbuf);
gDPSetScissor(gfx++, G_SC_NON_INTERLACE, 0, 0, this->width, this->height);
*gfxp = gfx;
}
void func_800C170C(PreRender* this, Gfx** gfxp, void* fbuf, void* fbufSave, u32 r, u32 g, u32 b, u32 a) {
/**
* Copies `buf` to `bufSave`, discarding the alpha channel and modulating the RGB channel by
* the color ('r', 'g', 'b', 'a')
*/
void func_800C170C(PreRender* this, Gfx** gfxp, void* buf, void* bufSave, u32 r, u32 g, u32 b, u32 a) {
Gfx* gfx;
s32 x;
s32 x2;
s32 dx;
s32 rowsRemaining;
s32 curRow;
s32 nRows;
LogUtils_CheckNullPointer("this", this, "../PreRender.c", 343);
LogUtils_CheckNullPointer("glistpp", gfxp, "../PreRender.c", 344);
@ -143,39 +183,51 @@ void func_800C170C(PreRender* this, Gfx** gfxp, void* fbuf, void* fbufSave, u32
LogUtils_CheckNullPointer("glistp", gfx, "../PreRender.c", 346);
gDPPipeSync(gfx++);
// Set the cycle type to 1-cycle mode to use the color combiner
gDPSetOtherMode(gfx++,
G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_POINT | G_TT_NONE | G_TL_TILE |
G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
G_AC_NONE | G_ZS_PRIM | G_RM_OPA_SURF | G_RM_OPA_SURF2);
gDPSetEnvColor(gfx++, r, g, b, a);
// Redundant setting of color combiner, overwritten immediately
// Would preserve rgb exactly while replacing the alpha channel with full alpha
gDPSetCombineLERP(gfx++, 0, 0, 0, TEXEL0, 0, 0, 0, 1, 0, 0, 0, TEXEL0, 0, 0, 0, 1);
// Modulate TEXEL0 by ENVIRONMENT, replace alpha with full alpha
gDPSetCombineLERP(gfx++, TEXEL0, 0, ENVIRONMENT, 0, 0, 0, 0, 1, TEXEL0, 0, ENVIRONMENT, 0, 0, 0, 0, 1);
gDPSetColorImage(gfx++, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, fbufSave);
// Set the destination buffer as the color image and set the scissoring region to the entire image
gDPSetColorImage(gfx++, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, bufSave);
gDPSetScissor(gfx++, G_SC_NON_INTERLACE, 0, 0, this->width, this->height);
dx = 0x1000 / (this->width * 2);
// Calculate the max number of rows that can fit into TMEM at once
nRows = TMEM_SIZE / (this->width * G_IM_SIZ_16b_BYTES);
x = this->height;
x2 = 0;
while (x > 0) {
rowsRemaining = this->height;
curRow = 0;
while (rowsRemaining > 0) {
s32 uls = 0;
s32 lrs = this->width - 1;
s32 ult;
s32 lrt;
dx = CLAMP_MAX(dx, x);
ult = x2;
lrt = x2 + dx - 1;
// Make sure that we don't load past the end of the source image
nRows = MIN(rowsRemaining, nRows);
gDPLoadTextureTile(gfx++, fbuf, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, this->height, uls, ult, lrs, lrt, 0,
// Determine the upper and lower bounds of the rect to draw
ult = curRow;
lrt = curRow + nRows - 1;
// Load a horizontal strip of the source image in RGBA16 format
gDPLoadTextureTile(gfx++, buf, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, this->height, uls, ult, lrs, lrt, 0,
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
G_TX_NOLOD);
// Draw that horizontal strip to the destination image
gSPTextureRectangle(gfx++, uls << 2, ult << 2, (lrs + 1) << 2, (lrt + 1) << 2, G_TX_RENDERTILE, uls << 5,
ult << 5, 1 << 10, 1 << 10);
x -= dx;
x2 += dx;
rowsRemaining -= nRows;
curRow += nRows;
}
gDPPipeSync(gfx++);
@ -183,15 +235,26 @@ void func_800C170C(PreRender* this, Gfx** gfxp, void* fbuf, void* fbufSave, u32
*gfxp = gfx;
}
/**
* Copies `fbuf` to `fbufSave`, discarding the alpha channel and leaving the rgb channel unchanged
*/
void func_800C1AE8(PreRender* this, Gfx** gfxp, void* fbuf, void* fbufSave) {
func_800C170C(this, gfxp, fbuf, fbufSave, 255, 255, 255, 255);
}
void func_800C1B24(PreRender* this, Gfx** gfxp, void* fbuf, void* cvgSave) {
/**
* Reads the coverage values stored in the RGBA16 format `img` with dimensions `this->width`, `this->height` and
* converts it to an 8-bpp intensity image.
*
* @param gfxp Display list pointer
* @param img Image to read coverage from
* @param cvgDst Buffer to store coverage into
*/
void PreRender_CoverageRgba16ToI8(PreRender* this, Gfx** gfxp, void* img, void* cvgDst) {
Gfx* gfx;
s32 x;
s32 x2;
s32 dx;
s32 rowsRemaining;
s32 curRow;
s32 nRows;
LogUtils_CheckNullPointer("this", this, "../PreRender.c", 422);
LogUtils_CheckNullPointer("glistpp", gfxp, "../PreRender.c", 423);
@ -203,49 +266,85 @@ void func_800C1B24(PreRender* this, Gfx** gfxp, void* fbuf, void* cvgSave) {
G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_POINT | G_TT_NONE | G_TL_TILE |
G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
G_AC_NONE | G_ZS_PRIM | G_RM_PASS | G_RM_OPA_CI2);
// Set the combiner to draw the texture as-is, discarding alpha channel
gDPSetCombineLERP(gfx++, 0, 0, 0, TEXEL0, 0, 0, 0, 0, 0, 0, 0, TEXEL0, 0, 0, 0, 0);
gDPSetColorImage(gfx++, G_IM_FMT_I, G_IM_SIZ_8b, this->width, cvgSave);
// Set the destination color image to the provided address
gDPSetColorImage(gfx++, G_IM_FMT_I, G_IM_SIZ_8b, this->width, cvgDst);
// Set up a scissor based on the source image
gDPSetScissor(gfx++, G_SC_NON_INTERLACE, 0, 0, this->width, this->height);
dx = 0x1000 / (this->width * 2);
// Calculate the max number of rows that can fit into TMEM at once
nRows = TMEM_SIZE / (this->width * G_IM_SIZ_16b_BYTES);
x = this->height;
x2 = 0;
while (x > 0) {
// Set up the number of remaining rows
rowsRemaining = this->height;
curRow = 0;
while (rowsRemaining > 0) {
s32 uls = 0;
s32 lrs = this->width - 1;
s32 ult;
s32 lrt;
dx = CLAMP_MAX(dx, x);
ult = x2;
lrt = x2 + dx - 1;
// Make sure that we don't load past the end of the source image
nRows = MIN(rowsRemaining, nRows);
gDPLoadTextureTile(gfx++, fbuf, G_IM_FMT_IA, G_IM_SIZ_16b, this->width, this->height, uls, ult, lrs, lrt, 0,
// Determine the upper and lower bounds of the rect to draw
ult = curRow;
lrt = curRow + nRows - 1;
// Load a horizontal strip of the source image in IA16 format. Since the source image is stored in memory as
// RGBA16, the bits are reinterpreted into IA16:
//
// r g b a
// 11111 111 11 11111 1
// i a
// 11111 111 11 11111 1
//
// I = (r << 3) | (g >> 2)
// A = (g << 6) | (b << 1) | a
//
// Since it is expected that r = g = b = cvg in the source image, this results in
// I = (cvg << 3) | (cvg >> 2)
// This expands the 5-bit coverage into an 8-bit value
gDPLoadTextureTile(gfx++, img, G_IM_FMT_IA, G_IM_SIZ_16b, this->width, this->height, uls, ult, lrs, lrt, 0,
G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD,
G_TX_NOLOD);
// Draw that horizontal strip to the destination image. With the combiner and blender configuration set above,
// the intensity (I) channel of the loaded IA16 texture will be written as-is to the I8 color image, each pixel
// in the final image is
// I = (cvg << 3) | (cvg >> 2)
gSPTextureRectangle(gfx++, uls << 2, ult << 2, (lrs + 1) << 2, (lrt + 1) << 2, G_TX_RENDERTILE, uls << 5,
ult << 5, 1 << 10, 1 << 10);
x -= dx;
x2 += dx;
// Update the number of rows remaining and index of the row being drawn
rowsRemaining -= nRows;
curRow += nRows;
}
// Reset the color image to the current framebuffer
gDPPipeSync(gfx++);
gDPSetColorImage(gfx++, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width, this->fbuf);
*gfxp = gfx;
}
void func_800C1E9C(PreRender* this, Gfx** gfxp) {
/**
* Saves zbuf to zbufSave
*/
void PreRender_SaveZBuffer(PreRender* this, Gfx** gfxp) {
LogUtils_CheckNullPointer("this->zbuf_save", this->zbufSave, "../PreRender.c", 481);
LogUtils_CheckNullPointer("this->zbuf", this->zbuf, "../PreRender.c", 482);
if ((this->zbufSave != NULL) && (this->zbuf != NULL)) {
func_800C0F28(this, gfxp, this->zbuf, this->zbufSave);
PreRender_CopyImage(this, gfxp, this->zbuf, this->zbufSave);
}
}
void func_800C1F20(PreRender* this, Gfx** gfxp) {
/**
* Saves fbuf to fbufSave
*/
void PreRender_SaveFramebuffer(PreRender* this, Gfx** gfxp) {
LogUtils_CheckNullPointer("this->fbuf_save", this->fbufSave, "../PreRender.c", 495);
LogUtils_CheckNullPointer("this->fbuf", this->fbuf, "../PreRender.c", 496);
@ -254,40 +353,71 @@ void func_800C1F20(PreRender* this, Gfx** gfxp) {
}
}
void func_800C1FA4(PreRender* this, Gfx** gfxp) {
/**
* Fetches the coverage of the current framebuffer into an image of the same format as the current color image, storing
* it over the framebuffer in memory.
*/
void PreRender_FetchFbufCoverage(PreRender* this, Gfx** gfxp) {
Gfx* gfx = *gfxp;
gDPPipeSync(gfx++);
// Set the blend color to full white and set maximum depth
gDPSetBlendColor(gfx++, 255, 255, 255, 8);
gDPSetPrimDepth(gfx++, 0xFFFF, 0xFFFF);
// Uses G_RM_VISCVG to blit the coverage values to the framebuffer
//
// G_RM_VISCVG is the following special render mode:
// IM_RD : Allow read-modify-write operations on the framebuffer
// FORCE_BL : Apply the blender to all pixels rather than just edges
// (G_BL_CLR_IN * G_BL_0 + G_BL_CLR_BL * G_BL_A_MEM) / (G_BL_0 + G_BL_CLR_BL) = G_BL_A_MEM
//
// G_BL_A_MEM ("memory alpha") is coverage, therefore this blender configuration emits only the coverage
// and discards any pixel colors. For an RGBA16 framebuffer, each of the three color channels r,g,b will
// receive the coverage value individually.
//
// Also disables other modes such as alpha compare and texture perspective correction
gDPSetOtherMode(gfx++,
G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_POINT | G_TT_NONE | G_TL_TILE |
G_TD_CLAMP | G_TP_NONE | G_CYC_1CYCLE | G_PM_NPRIMITIVE,
G_AC_NONE | G_ZS_PRIM | G_RM_VISCVG | G_RM_VISCVG2);
// Set up a scissor with the same dimensions as the framebuffer
gDPSetScissor(gfx++, G_SC_NON_INTERLACE, 0, 0, this->width, this->height);
// Fill rectangle to obtain the coverage values as an RGBA16 image
gDPFillRectangle(gfx++, 0, 0, this->width, this->height);
gDPPipeSync(gfx++);
*gfxp = gfx;
}
void func_800C20B4(PreRender* this, Gfx** gfxp) {
func_800C1FA4(this, gfxp);
/**
* Draws the coverage of the current framebuffer `this->fbuf` to an I8 image at `this->cvgSave`. Overwrites
* `this->fbuf` in the process.
*/
void PreRender_DrawCoverage(PreRender* this, Gfx** gfxp) {
PreRender_FetchFbufCoverage(this, gfxp);
LogUtils_CheckNullPointer("this->cvg_save", this->cvgSave, "../PreRender.c", 532);
if (this->cvgSave != NULL) {
func_800C1B24(this, gfxp, this->fbuf, this->cvgSave);
PreRender_CoverageRgba16ToI8(this, gfxp, this->fbuf, this->cvgSave);
}
}
void func_800C2118(PreRender* this, Gfx** gfxp) {
func_800C0F28(this, gfxp, this->zbufSave, this->zbuf);
/**
* Restores zbufSave to zbuf
*/
void PreRender_RestoreZBuffer(PreRender* this, Gfx** gfxp) {
PreRender_CopyImage(this, gfxp, this->zbufSave, this->zbuf);
}
/**
* Draws a full-screen image to the current framebuffer, that sources the rgb channel from `this->fbufSave` and
* the alpha channel from `this->cvgSave` modulated by environment color.
*/
void func_800C213C(PreRender* this, Gfx** gfxp) {
Gfx* gfx;
s32 y;
s32 y2;
s32 dy;
s32 rowsRemaining;
s32 curRow;
s32 nRows;
s32 rtile = 1;
if (this->cvgSave != NULL) {
@ -298,42 +428,52 @@ void func_800C213C(PreRender* this, Gfx** gfxp) {
gDPPipeSync(gfx++);
gDPSetEnvColor(gfx++, 255, 255, 255, 32);
// Effectively disable blending in both cycles. It's 2-cycle so that TEXEL1 can be used to point to a different
// texture tile.
gDPSetOtherMode(gfx++,
G_AD_DISABLE | G_CD_DISABLE | G_CK_NONE | G_TC_FILT | G_TF_POINT | G_TT_NONE | G_TL_TILE |
G_TD_CLAMP | G_TP_NONE | G_CYC_2CYCLE | G_PM_NPRIMITIVE,
G_AC_NONE | G_ZS_PRIM | AA_EN | CVG_DST_CLAMP | ZMODE_OPA | CVG_X_ALPHA |
GBL_c1(G_BL_CLR_IN, G_BL_0, G_BL_CLR_IN, G_BL_1) |
GBL_c2(G_BL_CLR_IN, G_BL_0, G_BL_CLR_IN, G_BL_1));
// Set up the color combiner: first cycle: TEXEL0, TEXEL1 + ENVIRONMENT; second cycle: G_CC_PASS2
gDPSetCombineLERP(gfx++, 0, 0, 0, TEXEL0, 1, 0, TEXEL1, ENVIRONMENT, 0, 0, 0, COMBINED, 0, 0, 0, COMBINED);
dy = 4;
nRows = 4;
y = this->height;
y2 = 0;
while (y > 0) {
rowsRemaining = this->height;
curRow = 0;
while (rowsRemaining > 0) {
s32 uls = 0;
s32 lrs = this->width - 1;
s32 ult;
s32 lrt;
dy = CLAMP_MAX(dy, y);
// Make sure that we don't load past the end of the source image
nRows = MIN(rowsRemaining, nRows);
ult = y2;
lrt = (y2 + dy - 1);
// Determine the upper and lower bounds of the rect to draw
ult = curRow;
lrt = curRow + nRows - 1;
// Load the frame buffer line
gDPLoadMultiTile(gfx++, this->fbufSave, 0x0000, G_TX_RENDERTILE, G_IM_FMT_RGBA, G_IM_SIZ_16b, this->width,
this->height, uls, ult, lrs, lrt, 0, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP,
G_TX_NOMASK, G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
// Load the coverage line
gDPLoadMultiTile(gfx++, this->cvgSave, 0x0160, rtile, G_IM_FMT_I, G_IM_SIZ_8b, this->width, this->height,
uls, ult, lrs, lrt, 0, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMIRROR | G_TX_WRAP, G_TX_NOMASK,
G_TX_NOMASK, G_TX_NOLOD, G_TX_NOLOD);
// Draw a texture for which the rgb channels come from the framebuffer and the alpha channel comes from
// coverage, modulated by env color
gSPTextureRectangle(gfx++, uls << 2, ult << 2, (lrs + 1) << 2, (lrt + 1) << 2, G_TX_RENDERTILE, uls << 5,
ult << 5, 1 << 10, 1 << 10);
y -= dy;
y2 += dy;
rowsRemaining -= nRows;
curRow += nRows;
}
gDPPipeSync(gfx++);
@ -341,135 +481,207 @@ void func_800C213C(PreRender* this, Gfx** gfxp) {
}
}
void func_800C24BC(PreRender* this, Gfx** gfxp) {
func_800C0F28(this, gfxp, this->fbufSave, this->fbuf);
/**
* Copies fbufSave to fbuf
*/
void PreRender_RestoreFramebuffer(PreRender* this, Gfx** gfxp) {
PreRender_CopyImage(this, gfxp, this->fbufSave, this->fbuf);
}
void func_800C24E0(PreRender* this, Gfx** gfxp) {
func_800C1258(this, gfxp);
/**
* Copies part of `this->fbufSave` in the region (this->ulx, this->uly), (this->lrx, this->lry) to the same location in
* `this->fbuf`.
*/
void PreRender_CopyImageRegion(PreRender* this, Gfx** gfxp) {
PreRender_CopyImageRegionImpl(this, gfxp);
}
void func_800C2500(PreRender* this, s32 x, s32 y) {
/**
* Applies the Video Interface anti-aliasing of silhouette edges to an image.
*
* This filter performs a linear interpolation on partially covered pixels between the current pixel color (called
* foreground color) and a "background" pixel color obtained by sampling fully covered pixels at the six highlighted
* points in the following 5x3 neighborhood:
* _ _ _ _ _
* | o o |
* | o X o |
* | o o |
* ‾ ‾ ‾ ‾ ‾
* Whether a pixel is partially covered is determined by reading the coverage values associated with the image.
* Coverage is a measure of how many subpixels the last drawn primitive covered. A fully covered pixel is one with a
* full coverage value, the entire pixel was covered by the primitive.
* The background color is calculated as the average of the "penultimate" minimum and maximum colors in the 5x3
* neighborhood.
*
* The final color is calculated by interpolating the foreground and background color weighted by the coverage:
* OutputColor = cvg * ForeGround + (1.0 - cvg) * BackGround
*
* This is a software implementation of the same algorithm used in the Video Interface hardware when Anti-Aliasing is
* enabled in the VI Control Register.
*
* Patent describing the algorithm:
*
* Gossett, C. P., & van Hook, T. J. (Filed 1995, Published 1998)
* Antialiasing of silhouette edges (USOO5742277A)
* U.S. Patent and Trademark Office
* Expired 2015-10-06
* https://patents.google.com/patent/US5742277A/en
*
* @param this PreRender instance
* @param x Center pixel x
* @param y Center pixel y
*/
void PreRender_AntiAliasFilter(PreRender* this, s32 x, s32 y) {
s32 i;
s32 j;
s32 buffA[3 * 5];
s32 buffR[3 * 5];
s32 buffG[3 * 5];
s32 buffB[3 * 5];
s32 x1;
s32 y1;
s32 buffCvg[5 * 3];
s32 buffR[5 * 3];
s32 buffG[5 * 3];
s32 buffB[5 * 3];
s32 xi;
s32 yi;
s32 pad;
s32 pxR;
s32 pxG;
s32 pxB;
s32 pxR2;
s32 pxG2;
s32 pxB2;
s32 pmaxR;
s32 pmaxG;
s32 pmaxB;
s32 pminR;
s32 pminG;
s32 pminB;
Color_RGBA16 pxIn;
Color_RGBA16 pxOut;
u32 pxR3;
u32 pxG3;
u32 pxB3;
u32 outR;
u32 outG;
u32 outB;
/*
Picture this as a 3x5 rectangle where the middle pixel (index 7) correspond to (x, y)
_ _ _ _ _
| 0 1 2 3 4 |
| 5 6 7 8 9 |
| A B C D E |
‾ ‾ ‾ ‾ ‾
*/
for (i = 0; i < 3 * 5; i++) {
x1 = (i % 5) + x - 2;
y1 = (i / 5) + y - 1;
// Extract pixels in the 5x3 neighborhood
for (i = 0; i < 5 * 3; i++) {
xi = x + (i % 5) - 2;
yi = y + (i / 5) - 1;
if (x1 < 0) {
x1 = 0;
} else if (x1 > (this->width - 1)) {
x1 = this->width - 1;
// Clamp coordinates to the edges of the image
if (xi < 0) {
xi = 0;
} else if (xi > (this->width - 1)) {
xi = this->width - 1;
}
if (y1 < 0) {
y1 = 0;
} else if (y1 > (this->height - 1)) {
y1 = this->height - 1;
if (yi < 0) {
yi = 0;
} else if (yi > (this->height - 1)) {
yi = this->height - 1;
}
pxIn.rgba = this->fbufSave[x1 + y1 * this->width];
// Extract color channels for each pixel, convert 5-bit color channels to 8-bit
pxIn.rgba = this->fbufSave[xi + yi * this->width];
buffR[i] = (pxIn.r << 3) | (pxIn.r >> 2);
buffG[i] = (pxIn.g << 3) | (pxIn.g >> 2);
buffB[i] = (pxIn.b << 3) | (pxIn.b >> 2);
buffA[i] = this->cvgSave[x1 + y1 * this->width] >> 5; // A
buffCvg[i] = this->cvgSave[xi + yi * this->width] >> 5;
}
if (buffA[7] == 7) {
if (buffCvg[7] == 7) {
osSyncPrintf("Error, should not be in here \n");
return;
}
pxR = pxR2 = buffR[7];
pxG = pxG2 = buffG[7];
pxB = pxB2 = buffB[7];
pmaxR = pminR = buffR[7];
pmaxG = pminG = buffG[7];
pmaxB = pminB = buffB[7];
for (i = 1; i < 3 * 5; i += 2) {
if (buffA[i] == 7) {
if (pxR < buffR[i]) {
for (j = 1; j < 15; j += 2) {
if ((i != j) && (buffR[j] >= buffR[i]) && (buffA[j] == 7)) {
pxR = buffR[i];
// For each neighbor
for (i = 1; i < 5 * 3; i += 2) {
// Only sample fully covered pixels
if (buffCvg[i] == 7) {
// Determine "Penultimate Maximum" Value
// If current maximum is less than this neighbor
if (pmaxR < buffR[i]) {
// For each neighbor (again)
for (j = 1; j < 5 * 3; j += 2) {
// If not the neighbor we were at before, and this neighbor has a larger value and this pixel is
// fully covered, that means the neighbor at `i` is the "penultimate maximum"
if ((i != j) && (buffR[j] >= buffR[i]) && (buffCvg[j] == 7)) {
pmaxR = buffR[i];
}
}
}
if (pxG < buffG[i]) {
for (j = 1; j < 15; j += 2) {
if ((i != j) && (buffG[j] >= buffG[i]) && (buffA[j] == 7)) {
pxG = buffG[i];
if (pmaxG < buffG[i]) {
for (j = 1; j < 5 * 3; j += 2) {
if ((i != j) && (buffG[j] >= buffG[i]) && (buffCvg[j] == 7)) {
pmaxG = buffG[i];
}
}
}
if (pxB < buffB[i]) {
for (j = 1; j < 15; j += 2) {
if ((i != j) && (buffB[j] >= buffB[i]) && (buffA[j] == 7)) {
pxB = buffB[i];
if (pmaxB < buffB[i]) {
for (j = 1; j < 5 * 3; j += 2) {
if ((i != j) && (buffB[j] >= buffB[i]) && (buffCvg[j] == 7)) {
pmaxB = buffB[i];
}
}
}
if (1) {}
if (pxR2 > buffR[i]) {
for (j = 1; j < 15; j += 2) {
if ((i != j) && (buffR[j] <= buffR[i]) && (buffA[j] == 7)) {
pxR2 = buffR[i];
// Determine "Penultimate Minimum" Value
// Same as above with inverted conditions
if (pminR > buffR[i]) {
for (j = 1; j < 5 * 3; j += 2) {
if ((i != j) && (buffR[j] <= buffR[i]) && (buffCvg[j] == 7)) {
pminR = buffR[i];
}
}
}
if (pxG2 > buffG[i]) {
for (j = 1; j < 15; j += 2) {
if ((i != j) && (buffG[j] <= buffG[i]) && (buffA[j] == 7)) {
pxG2 = buffG[i];
if (pminG > buffG[i]) {
for (j = 1; j < 5 * 3; j += 2) {
if ((i != j) && (buffG[j] <= buffG[i]) && (buffCvg[j] == 7)) {
pminG = buffG[i];
}
}
}
if (pxB2 > buffB[i]) {
for (j = 1; j < 15; j += 2) {
if ((i != j) && (buffB[j] <= buffB[i]) && (buffA[j] == 7)) {
pxB2 = buffB[i];
if (pminB > buffB[i]) {
for (j = 1; j < 5 * 3; j += 2) {
if ((i != j) && (buffB[j] <= buffB[i]) && (buffCvg[j] == 7)) {
pminB = buffB[i];
}
}
}
}
}
pxR3 = buffR[7] + ((s32)((7 - buffA[7]) * ((pxR + pxR2) - (buffR[7] << 1)) + 4) >> 3);
pxG3 = buffG[7] + ((s32)((7 - buffA[7]) * ((pxG + pxG2) - (buffG[7] << 1)) + 4) >> 3);
pxB3 = buffB[7] + ((s32)((7 - buffA[7]) * ((pxB + pxB2) - (buffB[7] << 1)) + 4) >> 3);
// The background color is determined by averaging the penultimate minimum and maximum pixels, and subtracting the
// ForeGround color:
// BackGround = (pMax + pMin) - (ForeGround) * 2
pxOut.r = pxR3 >> 3;
pxOut.g = pxG3 >> 3;
pxOut.b = pxB3 >> 3;
// OutputColor = cvg * ForeGround + (1.0 - cvg) * BackGround
outR = buffR[7] + ((s32)((7 - buffCvg[7]) * (pmaxR + pminR - (buffR[7] * 2)) + 4) >> 3);
outG = buffG[7] + ((s32)((7 - buffCvg[7]) * (pmaxG + pminG - (buffG[7] * 2)) + 4) >> 3);
outB = buffB[7] + ((s32)((7 - buffCvg[7]) * (pmaxB + pminB - (buffB[7] * 2)) + 4) >> 3);
pxOut.r = outR >> 3;
pxOut.g = outG >> 3;
pxOut.b = outB >> 3;
pxOut.a = 1;
this->fbufSave[x + y * this->width] = pxOut.rgba;
}
void func_800C2FE4(PreRender* this) {
// Selects the median value from a1, a2, a3
#define MEDIAN3(a1, a2, a3) \
(((a2) >= (a1)) ? (((a3) >= (a2)) ? (a2) : (((a1) >= (a3)) ? (a1) : (a3))) \
: (((a2) >= (a3)) ? (a2) : (((a3) >= (a1)) ? (a1) : (a3))))
/**
* Applies the Video Interface divot filter to an image.
*
* This filter removes "divots" in an anti-aliased image, single-pixel holes created when many boundary edges all
* occupy a single pixel. The algorithm removes these by sliding a 3-pixel-wide window across each row of pixels and
* replaces the center pixel color with the median pixel color in the window.
*
* This is a software implementation of the same algorithm used in the Video Interface hardware when OS_VI_DIVOT_ON is
* set in the VI Control Register.
*
* @param this PreRender instance
*/
void PreRender_DivotFilter(PreRender* this) {
s32 x;
s32 y;
s32 pad1;
@ -482,6 +694,9 @@ void func_800C2FE4(PreRender* this) {
s32 pxB;
for (y = 0; y < this->height; y++) {
// The divot filter is applied row-by-row as it only needs to use pixels that are horizontally adjacent
// Decompose each pixel into color channels
for (x = 0; x < this->width; x++) {
Color_RGBA16 pxIn;
@ -491,42 +706,52 @@ void func_800C2FE4(PreRender* this) {
buffB[x] = pxIn.b;
}
// Apply the divot filter itself. For pixels with partial coverage, the filter selects the median value from a
// window of 3 pixels in a horizontal row and uses that as the value for the center pixel.
for (x = 1; x < this->width - 1; x++) {
Color_RGBA16 pxOut;
s32 a = this->cvgSave[x + y * this->width];
s32 cvg = this->cvgSave[x + y * this->width];
a >>= 5;
if (a == 7) {
// Reject pixels with full coverage. The hardware video filter divot circuit checks if all 3 pixels in the
// window have partial coverage, here only the center pixel is checked.
cvg >>= 5;
if (cvg == 7) {
continue;
}
if (((HREG(80) == 0xF) ? HREG(81) : 0) != 0) {
if (((HREG(80) == 0xF) ? HREG(81) : 0) != 0) {}
// This condition is checked before entering this function, it will always pass if it runs.
if ((HREG(80) == 15 ? HREG(81) : 0) != 0) {
if ((HREG(80) == 15 ? HREG(81) : 0) != 0) {}
if (((HREG(80) == 0xF) ? HREG(81) : 0) == 5) {
if ((HREG(80) == 15 ? HREG(81) : 0) == 5) {
// Fill the pixel with full red, likely for debugging
pxR = 31;
pxG = 0;
pxB = 0;
} else {
u8* temp_s0 = &buffR[x - 1];
u8* temp_s1 = &buffG[x - 1];
u8* temp_s2 = &buffB[x - 1];
// Prepare sampling window
u8* windowR = &buffR[x - 1];
u8* windowG = &buffG[x - 1];
u8* windowB = &buffB[x - 1];
if (((HREG(80) == 0xF) ? HREG(81) : 0) == 3) {
osSyncPrintf("red=%3d %3d %3d %3d grn=%3d %3d %3d %3d blu=%3d %3d %3d %3d \n", temp_s0[0],
temp_s0[1], temp_s0[2], MEDIAN3(temp_s0[0], temp_s0[1], temp_s0[2]), temp_s1[0],
temp_s1[1], temp_s1[2], MEDIAN3(temp_s1[0], temp_s1[1], temp_s1[2]), temp_s2[0],
temp_s2[1], temp_s2[2], MEDIAN3(temp_s2[0], temp_s2[1], temp_s2[2]));
if ((HREG(80) == 15 ? HREG(81) : 0) == 3) {
osSyncPrintf("red=%3d %3d %3d %3d grn=%3d %3d %3d %3d blu=%3d %3d %3d %3d \n", windowR[0],
windowR[1], windowR[2], MEDIAN3(windowR[0], windowR[1], windowR[2]), windowG[0],
windowG[1], windowG[2], MEDIAN3(windowG[0], windowG[1], windowG[2]), windowB[0],
windowB[1], windowB[2], MEDIAN3(windowB[0], windowB[1], windowB[2]));
}
if (((HREG(80) == 0xF) ? HREG(81) : 0) == 1) {
pxR = MEDIAN3(temp_s0[0], temp_s0[1], temp_s0[2]);
pxG = MEDIAN3(temp_s1[0], temp_s1[1], temp_s1[2]);
pxB = MEDIAN3(temp_s2[0], temp_s2[1], temp_s2[2]);
// Sample the median value from the 3 pixel wide window
// (Both blocks contain the same code)
if ((HREG(80) == 15 ? HREG(81) : 0) == 1) {
pxR = MEDIAN3(windowR[0], windowR[1], windowR[2]);
pxG = MEDIAN3(windowG[0], windowG[1], windowG[2]);
pxB = MEDIAN3(windowB[0], windowB[1], windowB[2]);
} else {
pxR = MEDIAN3(temp_s0[0], temp_s0[1], temp_s0[2]);
pxG = MEDIAN3(temp_s1[0], temp_s1[1], temp_s1[2]);
pxB = MEDIAN3(temp_s2[0], temp_s2[1], temp_s2[2]);
pxR = MEDIAN3(windowR[0], windowR[1], windowR[2]);
pxG = MEDIAN3(windowG[0], windowG[1], windowG[2]);
pxB = MEDIAN3(windowB[0], windowB[1], windowB[2]);
}
}
pxOut.r = pxR;
@ -539,26 +764,32 @@ void func_800C2FE4(PreRender* this) {
}
}
void PreRender_Calc(PreRender* this) {
/**
* Applies the Video Interface anti-aliasing filter and (optionally) the divot filter to `this->fbufSave` using
* `this->cvgSave`
*/
void PreRender_ApplyFilters(PreRender* this) {
s32 x;
s32 y;
if ((this->cvgSave != NULL) && (this->fbufSave != NULL)) {
// Apply AA filter
for (y = 0; y < this->height; y++) {
for (x = 0; x < this->width; x++) {
s32 a = this->cvgSave[x + y * this->width];
s32 cvg = this->cvgSave[x + y * this->width];
a >>= 5;
a++;
if (a != 8) {
func_800C2500(this, x, y);
cvg >>= 5;
cvg++;
if (cvg != 8) {
// If this pixel has only partial coverage, perform the Video Filter interpolation on it
PreRender_AntiAliasFilter(this, x, y);
}
}
}
if (HREG(80) == 0xF ? HREG(81) : 0) {
func_800C2FE4(this);
if ((HREG(80) == 15 ? HREG(81) : 0) != 0) {
// Apply divot filter
PreRender_DivotFilter(this);
}
}
}

2
src/code/audio_data.c
View file

@ -556,7 +556,7 @@ NoteSubEu gDefaultNoteSub = {
{ 1, 1, 0, 0, 0, 0, 0, 0 }, { 0 }, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
};
u16 gHeadsetPanQuantization[64] = {
u16 gHaasEffectDelaySizes[64] = {
30 * SAMPLE_SIZE,
29 * SAMPLE_SIZE,
28 * SAMPLE_SIZE,

26
src/code/audio_playback.c
View file

@ -1,8 +1,9 @@
#include "global.h"
void Audio_InitNoteSub(Note* note, NoteSubEu* sub, NoteSubAttributes* attrs) {
f32 volRight, volLeft;
s32 smallPanIndex;
f32 volLeft;
f32 volRight;
s32 halfPanIndex;
u64 pad;
u8 strongLeft;
u8 strongRight;
@ -31,22 +32,22 @@ void Audio_InitNoteSub(Note* note, NoteSubEu* sub, NoteSubAttributes* attrs) {
sub->bitField0.stereoHeadsetEffects = stereoData.stereoHeadsetEffects;
sub->bitField0.usesHeadsetPanEffects = stereoData.usesHeadsetPanEffects;
if (stereoHeadsetEffects && (gAudioContext.soundMode == SOUNDMODE_HEADSET)) {
smallPanIndex = pan >> 1;
if (smallPanIndex > 0x3F) {
smallPanIndex = 0x3F;
halfPanIndex = pan >> 1;
if (halfPanIndex > 0x3F) {
halfPanIndex = 0x3F;
}
sub->headsetPanLeft = gHeadsetPanQuantization[smallPanIndex];
sub->headsetPanRight = gHeadsetPanQuantization[0x3F - smallPanIndex];
sub->bitField1.usesHeadsetPanEffects2 = true;
sub->haasEffectRightDelaySize = gHaasEffectDelaySizes[halfPanIndex];
sub->haasEffectLeftDelaySize = gHaasEffectDelaySizes[0x3F - halfPanIndex];
sub->bitField1.useHaasEffect = true;
volLeft = gHeadsetPanVolume[pan];
volRight = gHeadsetPanVolume[0x7F - pan];
} else if (stereoHeadsetEffects && (gAudioContext.soundMode == SOUNDMODE_STEREO)) {
strongLeft = strongRight = 0;
sub->headsetPanRight = 0;
sub->headsetPanLeft = 0;
sub->bitField1.usesHeadsetPanEffects2 = false;
sub->haasEffectLeftDelaySize = 0;
sub->haasEffectRightDelaySize = 0;
sub->bitField1.useHaasEffect = false;
volLeft = gStereoPanVolume[pan];
volRight = gStereoPanVolume[0x7F - pan];
@ -945,6 +946,7 @@ void Audio_NoteInitAll(void) {
note->playbackState.portamento.speed = 0;
note->playbackState.stereoHeadsetEffects = false;
note->startSamplePos = 0;
note->synthesisState.synthesisBuffers = AudioHeap_AllocDmaMemory(&gAudioContext.miscPool, 0x1E0);
note->synthesisState.synthesisBuffers =
AudioHeap_AllocDmaMemory(&gAudioContext.miscPool, sizeof(NoteSynthesisBuffers));
}
}

181
src/code/audio_synthesis.c
View file

@ -4,7 +4,7 @@
// DMEM Addresses for the RSP
#define DMEM_TEMP 0x3C0
#define DMEM_UNCOMPRESSED_NOTE 0x580
#define DMEM_NOTE_PAN_TEMP 0x5C0
#define DMEM_HAAS_TEMP 0x5C0
#define DMEM_SCRATCH2 0x760 // = DMEM_TEMP + DMEM_2CH_SIZE + a bit more
#define DMEM_COMPRESSED_ADPCM_DATA 0x940 // = DMEM_LEFT_CH
#define DMEM_LEFT_CH 0x940
@ -14,6 +14,12 @@
#define DMEM_WET_LEFT_CH 0xC80
#define DMEM_WET_RIGHT_CH 0xE20 // = DMEM_WET_LEFT_CH + DMEM_1CH_SIZE
typedef enum {
/* 0 */ HAAS_EFFECT_DELAY_NONE,
/* 1 */ HAAS_EFFECT_DELAY_LEFT, // Delay left channel so that right channel is heard first
/* 2 */ HAAS_EFFECT_DELAY_RIGHT // Delay right channel so that left channel is heard first
} HaasEffectDelaySide;
Acmd* AudioSynth_LoadRingBufferPart(Acmd* cmd, u16 dmem, u16 startPos, s32 size, SynthesisReverb* reverb);
Acmd* AudioSynth_SaveBufferOffset(Acmd* cmd, u16 dmem, u16 offset, s32 size, s16* buf);
Acmd* AudioSynth_SaveRingBufferPart(Acmd* cmd, u16 dmem, u16 startPos, s32 size, SynthesisReverb* reverb);
@ -21,17 +27,25 @@ Acmd* AudioSynth_DoOneAudioUpdate(s16* aiBuf, s32 aiBufLen, Acmd* cmd, s32 updat
Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisState* synthState, s16* aiBuf,
s32 aiBufLen, Acmd* cmd, s32 updateIndex);
Acmd* AudioSynth_LoadWaveSamples(Acmd* cmd, NoteSubEu* noteSubEu, NoteSynthesisState* synthState, s32 numSamplesToLoad);
Acmd* AudioSynth_NoteApplyHeadsetPanEffects(Acmd* cmd, NoteSubEu* noteSubEu, NoteSynthesisState* synthState, s32 bufLen,
s32 flags, s32 side);
Acmd* AudioSynth_ApplyHaasEffect(Acmd* cmd, NoteSubEu* noteSubEu, NoteSynthesisState* synthState, s32 size, s32 flags,
s32 haasEffectDelaySide);
Acmd* AudioSynth_ProcessEnvelope(Acmd* cmd, NoteSubEu* noteSubEu, NoteSynthesisState* synthState, s32 aiBufLen,
u16 inBuf, s32 headsetPanSettings, s32 flags);
u16 dmemSrc, s32 haasEffectDelaySide, s32 flags);
Acmd* AudioSynth_FinalResample(Acmd* cmd, NoteSynthesisState* synthState, s32 size, u16 pitch, u16 inpDmem,
s32 resampleFlags);
u32 D_801304A0 = _SHIFTL(A_ENVMIXER, 24, 8);
u32 D_801304A4 = MK_CMD(DMEM_NOTE_PAN_TEMP >> 4, DMEM_RIGHT_CH >> 4, DMEM_WET_LEFT_CH >> 4, DMEM_WET_RIGHT_CH >> 4);
u32 D_801304A8 = MK_CMD(DMEM_LEFT_CH >> 4, DMEM_NOTE_PAN_TEMP >> 4, DMEM_WET_LEFT_CH >> 4, DMEM_WET_RIGHT_CH >> 4);
u32 D_801304AC = MK_CMD(DMEM_LEFT_CH >> 4, DMEM_RIGHT_CH >> 4, DMEM_WET_LEFT_CH >> 4, DMEM_WET_RIGHT_CH >> 4);
u32 sEnvMixerOp = _SHIFTL(A_ENVMIXER, 24, 8);
// Store the left dry channel in a temp space to be delayed to produce the haas effect
u32 sEnvMixerLeftHaasDmemDests =
MK_CMD(DMEM_HAAS_TEMP >> 4, DMEM_RIGHT_CH >> 4, DMEM_WET_LEFT_CH >> 4, DMEM_WET_RIGHT_CH >> 4);
// Store the right dry channel in a temp space to be delayed to produce the haas effect
u32 sEnvMixerRightHaasDmemDests =
MK_CMD(DMEM_LEFT_CH >> 4, DMEM_HAAS_TEMP >> 4, DMEM_WET_LEFT_CH >> 4, DMEM_WET_RIGHT_CH >> 4);
u32 sEnvMixerDefaultDmemDests =
MK_CMD(DMEM_LEFT_CH >> 4, DMEM_RIGHT_CH >> 4, DMEM_WET_LEFT_CH >> 4, DMEM_WET_RIGHT_CH >> 4);
u16 D_801304B0[] = {
0x7FFF, 0xD001, 0x3FFF, 0xF001, 0x5FFF, 0x9001, 0x7FFF, 0x8001,
@ -723,7 +737,7 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
s32 nParts;
s32 curPart;
s32 sampleDataStartPad;
s32 side;
s32 haasEffectDelaySide;
s32 resampledTempLen;
u16 sampleDmemBeforeResampling;
s32 sampleDataOffset;
@ -752,8 +766,8 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
synthState->samplePosFrac = 0;
synthState->curVolLeft = 0;
synthState->curVolRight = 0;
synthState->prevHeadsetPanRight = 0;
synthState->prevHeadsetPanLeft = 0;
synthState->prevHaasEffectLeftDelaySize = 0;
synthState->prevHaasEffectRightDelaySize = 0;
synthState->reverbVol = noteSubEu->reverbVol;
synthState->numParts = 0;
synthState->unk_1A = 1;
@ -1078,7 +1092,7 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
unk7 = noteSubEu->unk_07;
unkE = noteSubEu->unk_0E;
buf = &synthState->synthesisBuffers->panSamplesBuffer[0x18];
buf = synthState->synthesisBuffers->unkState;
if (unk7 != 0 && noteSubEu->unk_0E != 0) {
AudioSynth_DMemMove(cmd++, DMEM_TEMP, DMEM_SCRATCH2, aiBufLen * SAMPLE_SIZE);
thing = DMEM_SCRATCH2 - unk7;
@ -1095,21 +1109,24 @@ Acmd* AudioSynth_ProcessNote(s32 noteIndex, NoteSubEu* noteSubEu, NoteSynthesisS
synthState->unk_1A = 1;
}
if (noteSubEu->headsetPanRight != 0 || synthState->prevHeadsetPanRight != 0) {
side = 1;
} else if (noteSubEu->headsetPanLeft != 0 || synthState->prevHeadsetPanLeft != 0) {
side = 2;
if ((noteSubEu->haasEffectLeftDelaySize != 0) || (synthState->prevHaasEffectLeftDelaySize != 0)) {
haasEffectDelaySide = HAAS_EFFECT_DELAY_LEFT;
} else if ((noteSubEu->haasEffectRightDelaySize != 0) || (synthState->prevHaasEffectRightDelaySize != 0)) {
haasEffectDelaySide = HAAS_EFFECT_DELAY_RIGHT;
} else {
side = 0;
haasEffectDelaySide = HAAS_EFFECT_DELAY_NONE;
}
cmd = AudioSynth_ProcessEnvelope(cmd, noteSubEu, synthState, aiBufLen, DMEM_TEMP, side, flags);
if (noteSubEu->bitField1.usesHeadsetPanEffects2) {
cmd = AudioSynth_ProcessEnvelope(cmd, noteSubEu, synthState, aiBufLen, DMEM_TEMP, haasEffectDelaySide, flags);
if (noteSubEu->bitField1.useHaasEffect) {
if (!(flags & A_INIT)) {
flags = A_CONTINUE;
}
cmd =
AudioSynth_NoteApplyHeadsetPanEffects(cmd, noteSubEu, synthState, aiBufLen * (s32)SAMPLE_SIZE, flags, side);
cmd = AudioSynth_ApplyHaasEffect(cmd, noteSubEu, synthState, aiBufLen * (s32)SAMPLE_SIZE, flags,
haasEffectDelaySide);
}
return cmd;
}
@ -1125,8 +1142,8 @@ Acmd* AudioSynth_FinalResample(Acmd* cmd, NoteSynthesisState* synthState, s32 si
}
Acmd* AudioSynth_ProcessEnvelope(Acmd* cmd, NoteSubEu* noteSubEu, NoteSynthesisState* synthState, s32 aiBufLen,
u16 inBuf, s32 headsetPanSettings, s32 flags) {
u32 phi_a1;
u16 dmemSrc, s32 haasEffectDelaySide, s32 flags) {
u32 dmemDests;
u16 curVolLeft;
u16 targetVolLeft;
s32 phi_t1;
@ -1171,30 +1188,36 @@ Acmd* AudioSynth_ProcessEnvelope(Acmd* cmd, NoteSubEu* noteSubEu, NoteSynthesisS
synthState->curVolLeft = curVolLeft + (rampLeft * (aiBufLen >> 3));
synthState->curVolRight = curVolRight + (rampRight * (aiBufLen >> 3));
if (noteSubEu->bitField1.usesHeadsetPanEffects2) {
AudioSynth_ClearBuffer(cmd++, DMEM_NOTE_PAN_TEMP, DMEM_1CH_SIZE);
if (noteSubEu->bitField1.useHaasEffect) {
AudioSynth_ClearBuffer(cmd++, DMEM_HAAS_TEMP, DMEM_1CH_SIZE);
AudioSynth_EnvSetup1(cmd++, phi_t1 * 2, rampReverb, rampLeft, rampRight);
AudioSynth_EnvSetup2(cmd++, curVolLeft, curVolRight);
switch (headsetPanSettings) {
case 1:
phi_a1 = D_801304A4;
switch (haasEffectDelaySide) {
case HAAS_EFFECT_DELAY_LEFT:
// Store the left dry channel in a temp space to be delayed to produce the haas effect
dmemDests = sEnvMixerLeftHaasDmemDests;
break;
case 2:
phi_a1 = D_801304A8;
case HAAS_EFFECT_DELAY_RIGHT:
// Store the right dry channel in a temp space to be delayed to produce the haas effect
dmemDests = sEnvMixerRightHaasDmemDests;
break;
default:
phi_a1 = D_801304AC;
default: // HAAS_EFFECT_DELAY_NONE
dmemDests = sEnvMixerDefaultDmemDests;
break;
}
} else {
aEnvSetup1(cmd++, phi_t1 * 2, rampReverb, rampLeft, rampRight);
aEnvSetup2(cmd++, curVolLeft, curVolRight);
phi_a1 = D_801304AC;
dmemDests = sEnvMixerDefaultDmemDests;
}
aEnvMixer(cmd++, inBuf, aiBufLen, (sourceReverbVol & 0x80) >> 7, noteSubEu->bitField0.stereoHeadsetEffects,
aEnvMixer(cmd++, dmemSrc, aiBufLen, (sourceReverbVol & 0x80) >> 7, noteSubEu->bitField0.stereoHeadsetEffects,
noteSubEu->bitField0.usesHeadsetPanEffects, noteSubEu->bitField0.stereoStrongRight,
noteSubEu->bitField0.stereoStrongLeft, phi_a1, D_801304A0);
noteSubEu->bitField0.stereoStrongLeft, dmemDests, sEnvMixerOp);
return cmd;
}
@ -1242,61 +1265,75 @@ Acmd* AudioSynth_LoadWaveSamples(Acmd* cmd, NoteSubEu* noteSubEu, NoteSynthesisS
return cmd;
}
Acmd* AudioSynth_NoteApplyHeadsetPanEffects(Acmd* cmd, NoteSubEu* noteSubEu, NoteSynthesisState* synthState, s32 bufLen,
s32 flags, s32 side) {
u16 dest;
/**
* The Haas Effect gives directionality to sound by appling a small (< 35ms) delay to either the left or right channel.
* The delay is small enough that the sound is still perceived as one sound, but the channel that is not delayed will
* reach our ear first and give a sense of directionality. The sound is directed towards the opposite side of the delay.
*/
Acmd* AudioSynth_ApplyHaasEffect(Acmd* cmd, NoteSubEu* noteSubEu, NoteSynthesisState* synthState, s32 size, s32 flags,
s32 haasEffectDelaySide) {
u16 dmemDest;
u16 pitch;
u8 prevPanShift;
u8 panShift;
u8 prevHaasEffectDelaySize;
u8 haasEffectDelaySize;
switch (side) {
case 1:
dest = DMEM_LEFT_CH;
panShift = noteSubEu->headsetPanRight;
prevPanShift = synthState->prevHeadsetPanRight;
synthState->prevHeadsetPanLeft = 0;
synthState->prevHeadsetPanRight = panShift;
switch (haasEffectDelaySide) {
case HAAS_EFFECT_DELAY_LEFT:
// Delay the sample on the left channel
// This allows the right channel to be heard first
dmemDest = DMEM_LEFT_CH;
haasEffectDelaySize = noteSubEu->haasEffectLeftDelaySize;
prevHaasEffectDelaySize = synthState->prevHaasEffectLeftDelaySize;
synthState->prevHaasEffectRightDelaySize = 0;
synthState->prevHaasEffectLeftDelaySize = haasEffectDelaySize;
break;
case 2:
dest = DMEM_RIGHT_CH;
panShift = noteSubEu->headsetPanLeft;
prevPanShift = synthState->prevHeadsetPanLeft;
synthState->prevHeadsetPanLeft = panShift;
synthState->prevHeadsetPanRight = 0;
case HAAS_EFFECT_DELAY_RIGHT:
// Delay the sample on the right channel
// This allows the left channel to be heard first
dmemDest = DMEM_RIGHT_CH;
haasEffectDelaySize = noteSubEu->haasEffectRightDelaySize;
prevHaasEffectDelaySize = synthState->prevHaasEffectRightDelaySize;
synthState->prevHaasEffectRightDelaySize = haasEffectDelaySize;
synthState->prevHaasEffectLeftDelaySize = 0;
break;
default:
default: // HAAS_EFFECT_DELAY_NONE
return cmd;
}
if (flags != A_INIT) {
// Slightly adjust the sample rate in order to fit a change in pan shift
if (panShift != prevPanShift) {
pitch = (((bufLen << 0xF) / 2) - 1) / ((bufLen + panShift - prevPanShift - 2) / 2);
aSetBuffer(cmd++, 0, DMEM_NOTE_PAN_TEMP, DMEM_TEMP, bufLen + panShift - prevPanShift);
// Slightly adjust the sample rate in order to fit a change in sample delay
if (haasEffectDelaySize != prevHaasEffectDelaySize) {
pitch = (((size << 0xF) / 2) - 1) / ((size + haasEffectDelaySize - prevHaasEffectDelaySize - 2) / 2);
aSetBuffer(cmd++, 0, DMEM_HAAS_TEMP, DMEM_TEMP, size + haasEffectDelaySize - prevHaasEffectDelaySize);
aResampleZoh(cmd++, pitch, 0);
} else {
aDMEMMove(cmd++, DMEM_NOTE_PAN_TEMP, DMEM_TEMP, bufLen);
aDMEMMove(cmd++, DMEM_HAAS_TEMP, DMEM_TEMP, size);
}
if (prevPanShift != 0) {
aLoadBuffer(cmd++, &synthState->synthesisBuffers->panResampleState[0x8], DMEM_NOTE_PAN_TEMP,
ALIGN16(prevPanShift));
aDMEMMove(cmd++, DMEM_TEMP, DMEM_NOTE_PAN_TEMP + prevPanShift, bufLen + panShift - prevPanShift);
if (prevHaasEffectDelaySize != 0) {
aLoadBuffer(cmd++, synthState->synthesisBuffers->haasEffectDelayState, DMEM_HAAS_TEMP,
ALIGN16(prevHaasEffectDelaySize));
aDMEMMove(cmd++, DMEM_TEMP, DMEM_HAAS_TEMP + prevHaasEffectDelaySize,
size + haasEffectDelaySize - prevHaasEffectDelaySize);
} else {
aDMEMMove(cmd++, DMEM_TEMP, DMEM_NOTE_PAN_TEMP, bufLen + panShift);
aDMEMMove(cmd++, DMEM_TEMP, DMEM_HAAS_TEMP, size + haasEffectDelaySize);
}
} else {
// Just shift right
aDMEMMove(cmd++, DMEM_NOTE_PAN_TEMP, DMEM_TEMP, bufLen);
aClearBuffer(cmd++, DMEM_NOTE_PAN_TEMP, panShift);
aDMEMMove(cmd++, DMEM_TEMP, DMEM_NOTE_PAN_TEMP + panShift, bufLen);
// Just apply a delay directly
aDMEMMove(cmd++, DMEM_HAAS_TEMP, DMEM_TEMP, size);
aClearBuffer(cmd++, DMEM_HAAS_TEMP, haasEffectDelaySize);
aDMEMMove(cmd++, DMEM_TEMP, DMEM_HAAS_TEMP + haasEffectDelaySize, size);
}
if (panShift) {
if (haasEffectDelaySize) { // != 0
// Save excessive samples for next iteration
aSaveBuffer(cmd++, DMEM_NOTE_PAN_TEMP + bufLen, &synthState->synthesisBuffers->panResampleState[0x8],
ALIGN16(panShift));
aSaveBuffer(cmd++, DMEM_HAAS_TEMP + size, synthState->synthesisBuffers->haasEffectDelayState,
ALIGN16(haasEffectDelaySize));
}
aAddMixer(cmd++, ALIGN64(bufLen), DMEM_NOTE_PAN_TEMP, dest, 0x7FFF);
aAddMixer(cmd++, ALIGN64(size), DMEM_HAAS_TEMP, dmemDest, 0x7FFF);
return cmd;
}

12
src/code/z_play.c
View file

@ -357,8 +357,8 @@ void Play_Init(GameState* thisx) {
SREG(91) = -1;
R_PAUSE_MENU_MODE = PAUSE_MENU_REG_MODE_0;
PreRender_Init(&this->pauseBgPreRender);
PreRender_SetValuesSave(&this->pauseBgPreRender, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0, 0);
PreRender_SetValues(&this->pauseBgPreRender, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0);
PreRender_SetValuesSave(&this->pauseBgPreRender, SCREEN_WIDTH, SCREEN_HEIGHT, NULL, NULL, NULL);
PreRender_SetValues(&this->pauseBgPreRender, SCREEN_WIDTH, SCREEN_HEIGHT, NULL, NULL);
gTrnsnUnkState = 0;
this->transitionMode = TRANS_MODE_OFF;
FrameAdvance_Init(&this->frameAdvCtx);
@ -1112,7 +1112,7 @@ void Play_Draw(PlayState* this) {
if (R_PAUSE_MENU_MODE == PAUSE_MENU_REG_MODE_2) {
Sched_FlushTaskQueue();
PreRender_Calc(&this->pauseBgPreRender);
PreRender_ApplyFilters(&this->pauseBgPreRender);
R_PAUSE_MENU_MODE = PAUSE_MENU_REG_MODE_3;
} else if (R_PAUSE_MENU_MODE >= PAUSE_MENU_REG_MODE_MAX) {
R_PAUSE_MENU_MODE = PAUSE_MENU_REG_MODE_0;
@ -1121,7 +1121,7 @@ void Play_Draw(PlayState* this) {
if (R_PAUSE_MENU_MODE == PAUSE_MENU_REG_MODE_3) {
Gfx* sp84 = POLY_OPA_DISP;
func_800C24BC(&this->pauseBgPreRender, &sp84);
PreRender_RestoreFramebuffer(&this->pauseBgPreRender, &sp84);
POLY_OPA_DISP = sp84;
goto Play_Draw_DrawOverlayElements;
} else {
@ -1238,10 +1238,10 @@ void Play_Draw(PlayState* this) {
this->pauseBgPreRender.fbuf = gfxCtx->curFrameBuffer;
this->pauseBgPreRender.fbufSave = (u16*)gZBuffer;
func_800C1F20(&this->pauseBgPreRender, &sp70);
PreRender_SaveFramebuffer(&this->pauseBgPreRender, &sp70);
if (R_PAUSE_MENU_MODE == PAUSE_MENU_REG_MODE_1) {
this->pauseBgPreRender.cvgSave = (u8*)gfxCtx->curFrameBuffer;
func_800C20B4(&this->pauseBgPreRender, &sp70);
PreRender_DrawCoverage(&this->pauseBgPreRender, &sp70);
R_PAUSE_MENU_MODE = PAUSE_MENU_REG_MODE_2;
} else {
gTrnsnUnkState = 2;