sprite_shading.c File Reference

Go to the source code of this file.

Functions
void	appendGfx_shading_palette (Matrix4f mtx, s32 uls, s32 ult, s32 lrs, s32 lrt, s32 alpha, f32 shadowX, f32 shadowY, f32 shadowZ, s32 shadowR, s32 shadowG, s32 shadowB, s32 highlightR, s32 highlightG, s32 highlightB, s32 ambientPower, s32 otherModeLBits)
void	clear_sprite_shading_data (void)
void	init_sprite_shading_data (void)
void	sprite_shading_set_light_source (u32 idx, s8 flags, f32 x, f32 y, f32 z, u8 r, u8 g, u8 b, f32 falloff, s8 arg9)
void	create_shading_palette (Matrix4f mtx, s32 uls, s32 ult, s32 lrs, s32 lrt, s32 alpha, s32 otherModeLBits)
void	func_801491E4 (Matrix4f mtx, s32 arg1, s32 arg2, s32 arg3, s32 arg4, s32 alpha)

Variables
SpriteShadingProfile *	gSpriteShadingProfile
SpriteShadingProfile *	gAuxSpriteShadingProfile
BSS SpriteShadingProfile	wSpriteShadingProfile
BSS SpriteShadingProfile	bSpriteShadingProfile
BSS SpriteShadingProfile	wSpriteShadingProfileAux
BSS SpriteShadingProfile	bSpriteShadingProfileAux
BSS PAL_BIN	SpriteShadingPalette [16]

Function Documentation

appendGfx_shading_palette()

void appendGfx_shading_palette	(	Matrix4f	mtx,
		s32	uls,
		s32	ult,
		s32	lrs,
		s32	lrt,
		s32	alpha,
		f32	shadowX,
		f32	shadowY,
		f32	shadowZ,
		s32	shadowR,
		s32	shadowG,
		s32	shadowB,
		s32	highlightR,
		s32	highlightG,
		s32	highlightB,
		s32	ambientPower,
		s32	otherModeLBits )

Definition at line 276 of file sprite_shading.c.

{
    Camera* camera = &gCameras[gCurrentCameraID];
    f32 mtx01;
    f32 mtx11;
    f32 mtx21;
    f32 offsetX;
    f32 offsetY;
    f32 shadowMag;
    f32 var_f12_2;
    f32 shadowXZ;
    f32 facingDir;
    f32 ex, ey, ez;
    f32 pm02, pm12, pm22;
 
    shadowMag = SQ(shadowX) + SQ(shadowY) + SQ(shadowZ);
 
    if (shadowMag < 1.0) {
        ambientPower *= shadowMag;
    }
    if (shadowMag != 0.0f) {
        shadowMag = 1.0f / sqrtf(shadowMag);
    }
    shadowX *= shadowMag;
    shadowY *= shadowMag;
    shadowZ *= shadowMag;
 
    if (((-mtx[0][2] * camera->mtxPerspective[0][2]) + (mtx[2][2] * camera->mtxPerspective[2][2])) < 0.0f) {
        facingDir = 1.0f;
    } else {
        facingDir = -1.0f;
    }
 
    if (facingDir < 0.0f) {
        ex = mtx[0][2];
        ey = mtx[1][2];
        ez = -mtx[2][2];
    } else {
        ex = -mtx[0][2];
        ey = mtx[1][2];
        ez = mtx[2][2];
    }
 
    pm02 = camera->mtxPerspective[0][2];
    pm12 = camera->mtxPerspective[1][2];
    pm22 = camera->mtxPerspective[2][2];
 
    offsetX = ambientPower * ((shadowX * -pm22) + (shadowZ * pm02));
 
    shadowXZ = SQ(shadowX) + SQ(shadowZ);
    if (shadowXZ != 0.0f) {
        shadowXZ = sqrtf(shadowXZ);
    }
    mtx01 = mtx[0][1];
    mtx11 = mtx[1][1];
    mtx21 = mtx[2][1];
    var_f12_2 = SQ(mtx01) + SQ(mtx21);
    if (var_f12_2 != 0.0f) {
        var_f12_2 = sqrtf(var_f12_2);
    }
    offsetY = -((shadowXZ * var_f12_2) + (shadowY * mtx11)) * ambientPower;
 
    if (shadowR > 255) {
        shadowR = 255;
    }
    if (shadowG > 255) {
        shadowG = 255;
    }
    if (shadowB > 255) {
        shadowB = 255;
    }
    if (highlightR > 255) {
        highlightR = 255;
    }
    if (highlightG > 255) {
        highlightG = 255;
    }
    if (highlightB > 255) {
        highlightB = 255;
    }
 
    gDPSetPrimColor(gMainGfxPos++, 0, 0, shadowR, shadowG, shadowB, alpha);
    gDPSetCombineMode(gMainGfxPos++, PM_CC_53, PM_CC_54);
    gDPSetColorImage(gMainGfxPos++, G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_WIDTH, SpriteShadingPalette);
    gDPSetScissor(gMainGfxPos++, G_SC_NON_INTERLACE, 0, 0, 16, 1);
 
    gSPSetOtherMode(gMainGfxPos++, G_SETOTHERMODE_H, 4, 18,
                    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);
 
    gDPSetRenderMode(gMainGfxPos++, G_RM_OPA_SURF, G_RM_OPA_SURF2);
 
    gDPSetPrimColor(gMainGfxPos++, 0, 0, shadowR, shadowG, shadowB, alpha);
    gDPSetEnvColor(gMainGfxPos++, highlightR, highlightG, highlightB, 0);
    gDPSetCombineMode(gMainGfxPos++, PM_CC_55, PM_CC_55);
    gSPTextureRectangle(gMainGfxPos++, 0, 0, 16 << 2, 1 << 2, 2, 0, 0, 4 << 10, 1 << 10);
    gDPPipeSync(gMainGfxPos++);
    gDPSetColorImage(gMainGfxPos++, G_IM_FMT_RGBA, G_IM_SIZ_16b, SCREEN_WIDTH, osVirtualToPhysical(nuGfxCfb_ptr));
 
    gDPSetScissor(
        gMainGfxPos++, 0,
        camera->viewportStartX,
        camera->viewportStartY,
        camera->viewportStartX + camera->viewportW,
        camera->viewportStartY + camera->viewportH
    );
 
    gDPLoadTLUT_pal16(gMainGfxPos++, 1, SpriteShadingPalette);
 
    gSPSetOtherMode(gMainGfxPos++, G_SETOTHERMODE_H, 4, 18,
                    G_AD_DISABLE | G_CD_MAGICSQ | G_CK_NONE | G_TC_FILT | G_TF_BILERP | G_TT_RGBA16 | G_TL_TILE |
                    G_TD_CLAMP | G_TP_PERSP | G_CYC_2CYCLE | G_PM_NPRIMITIVE);
 
    gDPSetRenderMode(gMainGfxPos++, G_RM_PASS, renderMode);
    gDPSetEnvColor(gMainGfxPos++, 100, 100, 100, 255);
 
    if (alpha == 255) {
        gDPSetCombineMode(gMainGfxPos++, PM_CC_50, PM_CC_52);
    } else {
        gDPSetCombineMode(gMainGfxPos++, PM_CC_51, PM_CC_52);
    }
 
    gDPSetTileSize(
        gMainGfxPos++,
        0,
        ((uls + 0x100) << 2) + (s32)(offsetX * facingDir),
        ((ult + 0x100) << 2) + (s32)offsetY,
        ((lrs + 0x100 - 1) << 2) + (s32)(offsetX * facingDir),
        ((lrt + 0x100 - 1) << 2) + (s32)offsetY
    );
}

Referenced by create_shading_palette().

clear_sprite_shading_data()

void clear_sprite_shading_data

(

void

)

Definition at line 20 of file sprite_shading.c.

                                     {
    s32 i;
 
    init_sprite_shading_data();
 
    for (i = 0; i < ARRAY_COUNT(gSpriteShadingProfile->sources); i++) {
        gSpriteShadingProfile->sources[i].flags = LIGHT_SOURCE_DISABLED;
        gAuxSpriteShadingProfile->sources[i].flags = LIGHT_SOURCE_DISABLED;
    }
 
    gSpriteShadingProfile->flags = 0;
    gSpriteShadingProfile->ambientColor.r = gSpriteShadingProfile->ambientColor.g = gSpriteShadingProfile->ambientColor.b = 50;
    gSpriteShadingProfile->ambientPower = 10;
 
    gAuxSpriteShadingProfile->flags = 0;
    gAuxSpriteShadingProfile->ambientColor.r = gAuxSpriteShadingProfile->ambientColor.g = gAuxSpriteShadingProfile->ambientColor.b = 50;
    gAuxSpriteShadingProfile->ambientPower = 20;
}

Referenced by load_demo_battle(), load_engine_data(), load_map_by_IDs(), state_step_battle(), state_step_demo(), state_step_intro(), state_step_pause(), and state_step_startup().

init_sprite_shading_data()

void init_sprite_shading_data

(

void

)

Definition at line 39 of file sprite_shading.c.

                                    {
    if (gGameStatusPtr->context == CONTEXT_WORLD) {
        gSpriteShadingProfile = &wSpriteShadingProfile;
        gAuxSpriteShadingProfile = &wSpriteShadingProfileAux;
    } else {
        gSpriteShadingProfile = &bSpriteShadingProfile;
        gAuxSpriteShadingProfile = &bSpriteShadingProfileAux;
    }
}

Referenced by clear_sprite_shading_data(), state_step_end_battle(), and state_step_unpause().

sprite_shading_set_light_source()

void sprite_shading_set_light_source	(	u32	idx,
		s8	flags,
		f32	x,
		f32	y,
		f32	z,
		u8	r,
		u8	g,
		u8	b,
		f32	falloff,
		s8	arg9 )

Definition at line 49 of file sprite_shading.c.

                                                                                                                     {
    SpriteShadingLightSource* lightSource;
 
    if (idx < ARRAY_COUNT(gSpriteShadingProfile->sources)) {
        lightSource = &gSpriteShadingProfile->sources[idx];
        lightSource->flags = flags;
        lightSource->pos.x = x;
        lightSource->pos.y = y;
        lightSource->pos.z = z;
        lightSource->rgb.r = r;
        lightSource->rgb.g = g;
        lightSource->rgb.b = b;
        lightSource->falloff = falloff;
        lightSource->unk_14 = arg9;
    }
}

create_shading_palette()

void create_shading_palette	(	Matrix4f	mtx,
		s32	uls,
		s32	ult,
		s32	lrs,
		s32	lrt,
		s32	alpha,
		s32	otherModeLBits )

Definition at line 66 of file sprite_shading.c.

                                                                                                             {
    Camera* camera = &gCameras[gCurrentCameraID];
    SpriteShadingLightSource* lightSource;
    f32 shadowDirX, shadowDirY, shadowDirZ;
    f32 posX, posY, posZ;
    f32 facingDir;
    f32 Mxz, Myz, Mzz;
    f32 shadowColorR, shadowColorG, shadowColorB;
    f32 commonColorR, commonColorG, commonColorB;
    f32 backColorR, backColorG, backColorB;
    f32 frontColorR, frontColorG, frontColorB;
    f32 shadowIntensity;
    f32 lightIntensity;
    f32 intensityScale;
    f32 temp_f10;
    f32 temp_f16;
    f32 distSq;
    f32 dx, dy, dz;
    f32 dist;
    f32 invDist;
    f32 qx, qy, qz;
    f32 wx, wy, wz;
    f32 ex, ey, ez;
    f32 Pxz, Pzz;
    s32 i;
 
    shadowDirX = 0.0f;
    shadowDirY = 0.0f;
    shadowDirZ = 0.0f;
 
    posX = mtx[3][0];
    posY = mtx[3][1];
    posZ = mtx[3][2];
 
    Mxz = mtx[0][2];
    Myz = mtx[1][2];
    Mzz = mtx[2][2];
 
    commonColorR = 0.0f;
    commonColorG = 0.0f;
    commonColorB = 0.0f;
 
    backColorR = 0.0f;
    backColorG = 0.0f;
    backColorB = 0.0f;
 
    frontColorR = 0.0f;
    frontColorG = 0.0f;
    frontColorB = 0.0f;
 
    shadowColorR = gSpriteShadingProfile->ambientColor.r;
    shadowColorG = gSpriteShadingProfile->ambientColor.g;
    shadowColorB = gSpriteShadingProfile->ambientColor.b;
 
    Pxz = camera->mtxPerspective[0][2];
    Pzz = camera->mtxPerspective[2][2];
 
    if ((-Mxz * Pxz + Mzz * Pzz) < 0.0f) {
        facingDir = 1.0f;
    } else {
        facingDir = -1.0f;
    }
 
    for (i = 0; i < ARRAY_COUNT(gSpriteShadingProfile->sources); i++) {
        lightSource = &gSpriteShadingProfile->sources[i];
        if (lightSource->flags & LIGHT_SOURCE_ENABLED) {
            dx = posX - lightSource->pos.x;
            dy = posY - lightSource->pos.y;
            dz = posZ - lightSource->pos.z;
 
            distSq = SQ(dx) + SQ(dy) + SQ(dz);
 
            if (distSq != 0.0f) {
                dist = sqrtf(distSq);
                invDist = 1.0f / dist;
            } else {
                dist = 0.0f;
                invDist = 0.0f;
            }
 
            // normalize dx/dy/dz
            // they now form a normal vector pointing from light source to sprite
            dx *= invDist;
            dy *= invDist;
            dz *= invDist;
 
            // apply falloff from light source
            if (lightSource->flags & LIGHT_SOURCE_LINEAR_FALLOFF) {
                if ((dist == 0.0f) && (lightSource->falloff == 0.0f)) {
                    intensityScale = 1.0f;
                } else {
                    intensityScale = 1.0f / (dist * lightSource->falloff);
                    dx *= intensityScale;
                    dy *= intensityScale;
                    dz *= intensityScale;
                }
            } else if (lightSource->flags & LIGHT_SOURCE_QUADRATIC_FALLOFF) {
                if ((distSq == 0.0f) && (lightSource->falloff == 0.0f)) {
                    intensityScale = 1.0f;
                } else {
                    intensityScale = 1.0f / (distSq * lightSource->falloff);
                    dx *= intensityScale;
                    dy *= intensityScale;
                    dz *= intensityScale;
                }
            } else {
                intensityScale = 1.0f;
            }
 
            if (intensityScale > 1.0f) {
                intensityScale = 1.0f;
            }
 
            shadowDirX += dx;
            shadowDirY += dy;
            shadowDirZ += dz;
 
            if (facingDir < 0.0f) {
                ex = Mxz;
                ey = Myz;
                ez = -Mzz;
            } else {
                ex = -Mxz;
                ey = Myz;
                ez = Mzz;
            }
            temp_f10 = ex * dx + ey * dy + ez * dz;
 
            if (facingDir < 0.0f) {
                wx = Mzz;
                wy = Myz;
                wz = Mxz;
            } else {
                wx = -Mzz;
                wy = Myz;
                wz = -Mxz;
            }
            temp_f16 = wx * dx + wy * dy + wz * dz;
 
            shadowIntensity = intensityScale * fabsf(temp_f10);
            lightIntensity  = intensityScale * fabsf(temp_f16);
            if (temp_f10 > 0.0f) {
                commonColorR += lightSource->rgb.r * shadowIntensity;
                commonColorG += lightSource->rgb.g * shadowIntensity;
                commonColorB += lightSource->rgb.b * shadowIntensity;
                if (temp_f16 > 0.0f) {
                    backColorR += lightSource->rgb.r * lightIntensity;
                    backColorG += lightSource->rgb.g * lightIntensity;
                    backColorB += lightSource->rgb.b * lightIntensity;
                } else {
                    frontColorR += lightSource->rgb.r * lightIntensity;
                    frontColorG += lightSource->rgb.g * lightIntensity;
                    frontColorB += lightSource->rgb.b * lightIntensity;
                }
            } else {
                shadowColorR += lightSource->rgb.r * shadowIntensity;
                shadowColorG += lightSource->rgb.g * shadowIntensity;
                shadowColorB += lightSource->rgb.b * shadowIntensity;
                if (temp_f16 > 0.0f) {
                    backColorR += lightSource->rgb.r * lightIntensity;
                    backColorG += lightSource->rgb.g * lightIntensity;
                    backColorB += lightSource->rgb.b * lightIntensity;
                } else {
                    frontColorR += lightSource->rgb.r * lightIntensity;
                    frontColorG += lightSource->rgb.g * lightIntensity;
                    frontColorB += lightSource->rgb.b * lightIntensity;
                }
            }
        }
    }
 
    if (facingDir < 0.0f) {
        qx = Mzz;
        qy = Myz;
        qz = Mxz;
    } else {
        qx = -Mzz;
        qy = Myz;
        qz = -Mxz;
    }
 
    if (qx * shadowDirX + qy * shadowDirY + qz * shadowDirZ > 0.0f) {
        appendGfx_shading_palette(
            mtx,
            uls, ult, lrs, lrt,
            alpha,
            shadowDirX, shadowDirY, shadowDirZ,
            shadowColorR, shadowColorG, shadowColorB,
            gSpriteShadingProfile->ambientColor.r + commonColorR + backColorR,
            gSpriteShadingProfile->ambientColor.g + commonColorG + backColorG,
            gSpriteShadingProfile->ambientColor.b + commonColorB + backColorB,
            gSpriteShadingProfile->ambientPower,
            otherModeLBits
        );
    } else {
        appendGfx_shading_palette(
            mtx,
            uls, ult, lrs, lrt,
            alpha,
            shadowDirX, shadowDirY, shadowDirZ,
            shadowColorR, shadowColorG, shadowColorB,
            gSpriteShadingProfile->ambientColor.r + commonColorR + frontColorR,
            gSpriteShadingProfile->ambientColor.g + commonColorG + frontColorG,
            gSpriteShadingProfile->ambientColor.b + commonColorB + frontColorB,
            gSpriteShadingProfile->ambientPower,
            otherModeLBits
        );
    }
}

Referenced by imgfx_appendGfx_mesh_anim(), imgfx_appendGfx_mesh_basic(), imgfx_appendGfx_mesh_grid(), and spr_appendGfx_component_flat().

func_801491E4()

void func_801491E4	(	Matrix4f	mtx,
		s32	arg1,
		s32	arg2,
		s32	arg3,
		s32	arg4,
		s32	alpha )

Definition at line 415 of file sprite_shading.c.

                                                                                    {
    gDPSetPrimColor(gMainGfxPos++, 0, 0, 0, 0, 0, alpha);
 
    if (alpha == 255) {
        gDPSetCombineMode(gMainGfxPos++, PM_CC_WINDOW_5, G_CC_PASS2);
    } else {
        gDPSetCombineMode(gMainGfxPos++, PM_CC_02, G_CC_PASS2);
    }
}

Referenced by appendGfx_item_entity(), and render_item_entities().

Variable Documentation

gSpriteShadingProfile

SpriteShadingProfile* gSpriteShadingProfile

Definition at line 5 of file sprite_shading.c.

Referenced by appendGfx_item_entity(), clear_sprite_shading_data(), create_shading_palette(), imgfx_appendGfx_mesh_anim(), imgfx_appendGfx_mesh_basic(), imgfx_appendGfx_mesh_grid(), init_sprite_shading_data(), render_item_entities(), spr_appendGfx_component(), spr_appendGfx_component_flat(), and sprite_shading_set_light_source().

gAuxSpriteShadingProfile

SpriteShadingProfile* gAuxSpriteShadingProfile

Definition at line 6 of file sprite_shading.c.

Referenced by clear_sprite_shading_data(), and init_sprite_shading_data().

wSpriteShadingProfile

BSS SpriteShadingProfile wSpriteShadingProfile

Definition at line 8 of file sprite_shading.c.

Referenced by init_sprite_shading_data().

bSpriteShadingProfile

BSS SpriteShadingProfile bSpriteShadingProfile

Definition at line 9 of file sprite_shading.c.

Referenced by init_sprite_shading_data().

wSpriteShadingProfileAux

BSS SpriteShadingProfile wSpriteShadingProfileAux

Definition at line 10 of file sprite_shading.c.

Referenced by init_sprite_shading_data().

bSpriteShadingProfileAux

BSS SpriteShadingProfile bSpriteShadingProfileAux

Definition at line 11 of file sprite_shading.c.

Referenced by init_sprite_shading_data().

SpriteShadingPalette

BSS PAL_BIN SpriteShadingPalette[16]

Definition at line 12 of file sprite_shading.c.

Referenced by appendGfx_shading_palette().