/****************************************************************************
* Menu_DrawImg
*
* Draws the specified image on screen using GX
***************************************************************************/
void Menu_DrawImg(f32 xpos, f32 ypos, f32 zpos, f32 width, f32 height, u8 data[], f32 degrees, f32 scaleX, f32 scaleY,
u8 alpha, int XX1, int YY1, int XX2, int YY2, int XX3, int YY3, int XX4, int YY4)
{
if (data == NULL) return;
GX_LoadProjectionMtx(FSProjection2D, GX_ORTHOGRAPHIC);
GXTexObj texObj;
GX_InitTexObj(&texObj, data, width, height, GX_TF_RGBA8, GX_CLAMP, GX_CLAMP, GX_FALSE);
GX_LoadTexObj(&texObj, GX_TEXMAP0);
GX_ClearVtxDesc();
GX_InvVtxCache();
GX_InvalidateTexAll();
GX_SetVtxDesc(GX_VA_POS, GX_DIRECT);
GX_SetVtxDesc(GX_VA_CLR0, GX_DIRECT);
GX_SetVtxDesc(GX_VA_TEX0, GX_DIRECT);
Mtx m, m1, m2, mv;
width *= 0.5f;
height *= 0.5f;
guMtxIdentity(m1);
guMtxScaleApply(m1, m1, scaleX, scaleY, 1.0f);
guVector axis = (guVector) {0 , 0, 1};
guMtxRotAxisDeg (m2, &axis, degrees);
guMtxConcat(m1, m2, m);
guMtxTransApply(m, m, xpos + width + 0.5f, ypos + height + 0.5f, zpos);
guMtxConcat(FSModelView2D, m, mv);
GX_LoadPosMtxImm(mv, GX_PNMTX0);
GX_Begin(GX_QUADS, GX_VTXFMT0, 4);
GX_Position3f32(-width + XX1, -height + YY1, 0);
GX_Color4u8(0xFF, 0xFF, 0xFF, alpha);
GX_TexCoord2f32(0, 0);
GX_Position3f32(width + XX2, -height + YY2, 0);
GX_Color4u8(0xFF, 0xFF, 0xFF, alpha);
GX_TexCoord2f32(1, 0);
GX_Position3f32(width + XX3, height + YY3, 0);
GX_Color4u8(0xFF, 0xFF, 0xFF, alpha);
GX_TexCoord2f32(1, 1);
GX_Position3f32(-width + XX4, height + YY4, 0);
GX_Color4u8(0xFF, 0xFF, 0xFF, alpha);
GX_TexCoord2f32(0, 1);
GX_End();
}
/****************************************************************************
* Menu_DrawImg
*
* Draws the specified image on screen using GX
***************************************************************************/
void Menu_DrawImg(f32 xpos, f32 ypos, u16 width, u16 height, u8 data[],
f32 degrees, f32 scaleX, f32 scaleY, u8 alpha)
{
if(data == NULL)
return;
GXTexObj texObj;
GX_InitTexObj(&texObj, data, width, height, GX_TF_RGBA8, GX_CLAMP, GX_CLAMP, GX_FALSE);
GX_LoadTexObj(&texObj, GX_TEXMAP0);
GX_InvalidateTexAll();
GX_SetTevOp (GX_TEVSTAGE0, GX_MODULATE);
GX_SetVtxDesc (GX_VA_TEX0, GX_DIRECT);
Mtx m,m1,m2, mv;
width >>= 1;
height >>= 1;
guMtxIdentity (m1);
guMtxScaleApply(m1,m1,scaleX,scaleY,1.0);
guVector axis = (guVector) {0 , 0, 1 };
guMtxRotAxisDeg (m2, &axis, degrees);
guMtxConcat(m2,m1,m);
guMtxTransApply(m,m, xpos+width,ypos+height,0);
guMtxConcat (GXmodelView2D, m, mv);
GX_LoadPosMtxImm (mv, GX_PNMTX0);
GX_Begin(GX_QUADS, GX_VTXFMT0,4);
GX_Position3f32(-width, -height, 0);
GX_Color4u8(0xFF,0xFF,0xFF,alpha);
GX_TexCoord2f32(0, 0);
GX_Position3f32(width, -height, 0);
GX_Color4u8(0xFF,0xFF,0xFF,alpha);
GX_TexCoord2f32(1, 0);
GX_Position3f32(width, height, 0);
GX_Color4u8(0xFF,0xFF,0xFF,alpha);
GX_TexCoord2f32(1, 1);
GX_Position3f32(-width, height, 0);
GX_Color4u8(0xFF,0xFF,0xFF,alpha);
GX_TexCoord2f32(0, 1);
GX_End();
GX_LoadPosMtxImm (GXmodelView2D, GX_PNMTX0);
GX_SetTevOp (GX_TEVSTAGE0, GX_PASSCLR);
GX_SetVtxDesc (GX_VA_TEX0, GX_NONE);
}
void QuadPane::Draw(const BannerResources& resources, u8 render_alpha, const float ws_scale, Mtx &modelview, u16 material_index, u8 texture_flip) const
{
if(!header)
return;
if (material_index < resources.materials.size())
{
bool modulate_color = IsModulateColor(header->vertex_colors, render_alpha);
resources.materials[material_index]->Apply(resources, render_alpha, modulate_color);
}
Mtx m, mv;
guMtxIdentity (m);
guMtxTransApply(m,m, -0.5f * GetOriginX(), -0.5f * GetOriginY(), 0.f);
guMtxScaleApply(m,m, GetWidth(), GetHeight(), 1.f);
guMtxConcat (modelview, m, mv);
GX_LoadPosMtxImm (mv, GX_PNMTX0);
GX_ClearVtxDesc();
GX_InvVtxCache();
GX_SetVtxDesc(GX_VA_POS, GX_DIRECT);
GX_SetVtxDesc(GX_VA_CLR0, GX_DIRECT);
for(u32 i = 0; i < header->tex_coord_count; i++)
GX_SetVtxDesc(GX_VA_TEX0+i, GX_DIRECT);
GX_Begin(GX_QUADS, GX_VTXFMT0, 4);
if(texture_flip)
{
SetVertex(0, 0.f, 0.f, render_alpha);
SetVertex(1, 1.f, 0.f, render_alpha);
SetVertex(3, 1.f, 1.f, render_alpha);
SetVertex(2, 0.f, 1.f, render_alpha);
}
else
{
SetVertex(2, 0.f, 0.f, render_alpha);
SetVertex(3, 1.f, 0.f, render_alpha);
SetVertex(1, 1.f, 1.f, render_alpha);
SetVertex(0, 0.f, 1.f, render_alpha);
}
GX_End();
}
void draw_star( f32 scale, f32 angle, f32 x, f32 y, u8 *col, u8 alpha )
{
int i, j;
Mtx m,m1,m2,mv;
guMtxIdentity(m1);
guMtxScaleApply( m1, m1, scale, scale, 1.0f );
guMtxRotAxisRad( m2, &rotax, angle );
guMtxConcat( m2, m1, m);
guMtxTransApply( m, m, x, y, 0 );
guMtxConcat( GXmodelView2D, m, mv );
GX_LoadPosMtxImm( mv, GX_PNMTX0 );
GX_Begin( GX_TRIANGLES, GX_VTXFMT0, 3*NUM_STAR_POLYS );
for( i=0; i<NUM_STAR_POLYS*3; i++ )
{
j = star_polys[i]*2;
GX_Position3f32( star_pts[j], star_pts[j+1], 0.0f );
GX_Color4u8( col[0], col[1], col[2], alpha );
}
GX_End();
GX_Begin( GX_LINESTRIP, GX_VTXFMT0, NUM_STAR_EDGES );
for( i=0; i<NUM_STAR_EDGES; i++ )
{
j = star_edges[i]*2;
GX_Position3f32( star_pts[j], star_pts[j+1], 0.0f );
GX_Color4u8( 0, 0, 0, alpha );
}
GX_End();
GX_LoadPosMtxImm (GXmodelView2D, GX_PNMTX0);
GX_SetTevOp (GX_TEVSTAGE0, GX_PASSCLR);
GX_SetVtxDesc (GX_VA_TEX0, GX_NONE);
}
void BoxCover::Draw()
{
u8 BoxAlpha = (int) (alpha+alphaDyn) & 0xFF;
GX_LoadProjectionMtx(projection, GX_PERSPECTIVE);
GX_ClearVtxDesc();
GX_InvVtxCache();
GX_SetVtxDesc(GX_VA_POS, GX_INDEX8);
GX_SetVtxDesc(GX_VA_CLR0, GX_DIRECT);
GX_SetVtxDesc(GX_VA_TEX0, GX_INDEX8);
//! don't draw inside of the box
GX_SetCullMode(GX_CULL_FRONT);
Mtx modelView;
Mtx modelView2;
Mtx modelView3;
guVector cubeAxis = {0,0,1};
guVector cubeAxis2 = {0,1,0};
guVector cubeAxis3 = {1,0,0};
guMtxIdentity(modelView);
guMtxRotAxisDeg(modelView3, &cubeAxis3, RotX-Animation2);
guMtxRotAxisDeg(modelView2, &cubeAxis2, RotY+Animation2+xoffsetDyn/2.0f);
guMtxRotAxisDeg(modelView, &cubeAxis, RotZ-Animation);
guMtxConcat(modelView3, modelView2, modelView2);
guMtxConcat(modelView2, modelView, modelView);
if(Settings.widescreen)
guMtxScaleApply(modelView, modelView, Settings.WSFactor, 1.0f, 1.0f);
guMtxTransApply(modelView, modelView, PosX+xoffsetDyn/680.0f+movePosX, PosY+yoffsetDyn/680.0f+movePosY, PosZ);
guMtxConcat(view,modelView,modelView);
GX_LoadPosMtxImm(modelView, GX_PNMTX0);
//! Border quads
GX_LoadTexObj(&boxBorderTex, GX_TEXMAP0);
GX_InvalidateTexAll();
GX_SetArray(GX_VA_POS, (void *) &g_boxMeshQ[0].pos, sizeof(g_boxMeshQ[0]));
GX_SetArray(GX_VA_TEX0, (void *) &g_boxMeshQ[0].texCoord, sizeof(g_boxMeshQ[0]));
GX_Begin(GX_QUADS, GX_VTXFMT0, g_boxMeshQSize);
for (u32 j = 0; j < g_boxMeshQSize; ++j)
{
GX_Position1x8(j);
GX_Color4u8(boxColor.r, boxColor.g, boxColor.b, BoxAlpha);
GX_TexCoord1x8(j);
}
GX_End();
//! Border triangles
GX_SetArray(GX_VA_POS, (void *) &g_boxMeshT[0].pos, sizeof(g_boxMeshT[0]));
GX_SetArray(GX_VA_TEX0, (void *) &g_boxMeshT[0].texCoord, sizeof(g_boxMeshT[0]));
GX_Begin(GX_TRIANGLES, GX_VTXFMT0, g_boxMeshTSize);
for (u32 j = 0; j < g_boxMeshTSize; ++j)
{
GX_Position1x8(j);
GX_Color4u8(boxColor.r, boxColor.g, boxColor.b, BoxAlpha);
GX_TexCoord1x8(j);
}
GX_End();
//! Back Cover (Might be flat)
GX_LoadTexObj(flatCover ? &defaultBoxTex : &coverTex, GX_TEXMAP0);
GX_InvalidateTexAll();
GX_SetArray(GX_VA_POS, (void *) &g_boxBackCoverMesh[0].pos, sizeof(g_boxBackCoverMesh[0]));
GX_SetArray(GX_VA_TEX0, (void *) &g_boxBackCoverMesh[0].texCoord, sizeof(g_boxBackCoverMesh[0]));
GX_Begin(GX_QUADS, GX_VTXFMT0, g_boxBackCoverMeshSize);
for (u32 j = 0; j < g_boxBackCoverMeshSize; ++j)
{
GX_Position1x8(j);
if(flatCover)
GX_Color4u8(boxColor.r, boxColor.g, boxColor.b, BoxAlpha);
else
GX_Color4u8(0xff, 0xff, 0xff, BoxAlpha);
GX_TexCoord1x8(j);
}
GX_End();
if(flatCover)
{
//! Front Flat Cover
GX_LoadTexObj(&coverTex, GX_TEXMAP0);
GX_InvalidateTexAll();
GX_SetArray(GX_VA_POS, (void *) &g_flatCoverMesh[0].pos, sizeof(g_flatCoverMesh[0]));
GX_SetArray(GX_VA_TEX0, (void *) &g_flatCoverMesh[0].texCoord, sizeof(g_flatCoverMesh[0]));
GX_Begin(GX_QUADS, GX_VTXFMT0, g_flatCoverMeshSize);
for (u32 j = 0; j < g_flatCoverMeshSize; ++j)
{
GX_Position1x8(j);
GX_Color4u8(0xff, 0xff, 0xff, 0xff);
GX_TexCoord1x8(j);
}
GX_End();
}
else
{
//! Front Cover
GX_SetArray(GX_VA_POS, (void *) &g_boxCoverMesh[0].pos, sizeof(g_boxCoverMesh[0]));
GX_SetArray(GX_VA_TEX0, (void *) &g_boxCoverMesh[0].texCoord, sizeof(g_boxCoverMesh[0]));
GX_Begin(GX_QUADS, GX_VTXFMT0, g_boxCoverMeshSize);
for (u32 j = 0; j < g_boxCoverMeshSize; ++j)
{
GX_Position1x8(j);
GX_Color4u8(0xff, 0xff, 0xff, BoxAlpha);
GX_TexCoord1x8(j);
}
GX_End();
}
//! stop cull
GX_SetCullMode(GX_CULL_NONE);
UpdateEffects();
}
void MilkdropWaveform::Draw(RenderContext &context)
{
WaveformMath(context);
#ifdef _WII_
#else
glMatrixMode( GL_MODELVIEW );
//glPushMatrix();
glLoadIdentity();
#endif
if(modulateAlphaByVolume) ModulateOpacityByVolume(context);
else temp_a = a;
MaximizeColors(context);
#ifndef _WII_
if(dots==1) glEnable(GL_LINE_STIPPLE);
#else
u8 format = GX_TO_ZERO;
if(dots==1) format = GX_TO_ONE; // ??? correct ???
#endif
#ifdef _WII_
//Thick wave drawing
if (thick==1) WII_SetLineWidth( (context.texsize < 512 ) ? 2 : 2*context.texsize/512,format);
else WII_SetLineWidth( (context.texsize < 512 ) ? 1 : context.texsize/512,format);
//Additive wave drawing (vice overwrite)
if (additive)GX_SetBlendMode(GX_BM_BLEND,GX_BL_SRCALPHA, GX_BL_ONE,GX_LO_CLEAR);
else GX_SetBlendMode(GX_BM_BLEND,GX_BL_SRCALPHA, GX_BL_INVSRCALPHA,GX_LO_CLEAR);
#else
//Thick wave drawing
if (thick==1) glLineWidth( (context.texsize < 512 ) ? 2 : 2*context.texsize/512);
else glLineWidth( (context.texsize < 512 ) ? 1 : context.texsize/512);
//Additive wave drawing (vice overwrite)
if (additive)glBlendFunc(GL_SRC_ALPHA, GL_ONE);
else glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
#endif
#ifdef _WII_
guMtxIdentity(modelview);
guVector cubeAxis = {0, 0, 1};
guMtxTransApply(modelview, modelview, .5, .5, 0);
guMtxRotAxisDeg(modelview, &cubeAxis, rot);
guMtxScaleApply(modelview,modelview,aspectScale, 1.0, 1.0);
guMtxTransApply(modelview, modelview, -.5, -.5, 0);
if (loop)
WII_VertArrays(GX_LINESTRIP,&wavearray[0][0],0,0,0,samples,2);
else
WII_VertArrays(GX_LINESTRIP,&wavearray[0][0],0,0,0,samples,2);
if (two_waves)
{
if (loop)
WII_VertArrays(GX_LINESTRIP,&wavearray2[0][0],0,0,0,samples,2);
else
WII_VertArrays(GX_LINESTRIP,&wavearray2[0][0],0,0,0,samples,2);
}
// glPopMatrix();
#else
glTranslatef(.5, .5, 0);
glRotatef(rot, 0, 0, 1);
glScalef(aspectScale, 1.0, 1.0);
glTranslatef(-.5, -.5, 0);
glEnableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glVertexPointer(2,GL_FLOAT,0,wavearray);
if (loop)
glDrawArrays(GL_LINE_LOOP,0,samples);
else
glDrawArrays(GL_LINE_STRIP,0,samples);
if (two_waves)
{
glVertexPointer(2,GL_FLOAT,0,wavearray2);
if (loop)
glDrawArrays(GL_LINE_LOOP,0,samples);
else
glDrawArrays(GL_LINE_STRIP,0,samples);
}
#ifndef USE_GLES1
if(dots==1) glDisable(GL_LINE_STIPPLE);
#endif
//glPopMatrix();
#endif
}
void Pane::Render(const Resources& resources, u8 parent_alpha, Mtx &modelview,
bool widescreen, bool modify_alpha) const
{
if (!GetVisible() || GetHide())
return;
u8 render_alpha = header->alpha;
if(RootPane && parent_alpha != 0xFF)
{
render_alpha = MultiplyAlpha(header->alpha, parent_alpha);
modify_alpha = true;
}
else if(!RootPane && modify_alpha)
{
render_alpha = MultiplyAlpha(header->alpha, parent_alpha);
}
else if(GetInfluencedAlpha() && header->alpha != 0xff)
{
modify_alpha = true;
parent_alpha = MultiplyAlpha(header->alpha, parent_alpha);
}
float ws_scale = 1.0f;
if( widescreen && GetWidescren() )
{
ws_scale *= 0.82f; // should actually be 0.75?
widescreen = false;
}
Mtx m1,m2,m3,m4;
guMtxIdentity (m1);
// Scale
guMtxScaleApply(m1,m1, header->scale.x * ws_scale, header->scale.y, 1.f);
// Rotate
guMtxRotDeg ( m2, 'x', header->rotate.x );
guMtxRotDeg ( m3, 'y', header->rotate.y );
guMtxRotDeg ( m4, 'z', header->rotate.z );
guMtxConcat(m2, m3, m2);
guMtxConcat(m2, m4, m2);
guMtxConcat(m1, m2, m1);
// Translate
guMtxTransApply(m1,m1, header->translate.x, header->translate.y, header->translate.z);
guMtxConcat (modelview, m1, pane_view);
bool scissor = gxScissorForBindedLayouts;
u32 scissorX = 0;
u32 scissorY = 0;
u32 scissorW = 0;
u32 scissorH = 0;
// calculate scissors if they will be used
if( scissor )
{
Mtx mv2, mv3;
guMtxIdentity (mv2);
guMtxIdentity (mv3);
guMtxTransApply(mv2,mv2, -0.5f * GetOriginX() * GetWidth(), -0.5f * GetOriginY() * GetHeight(), 0.f);
guMtxTransApply(mv3,mv3, 0.5f * GetOriginX() * GetWidth(), 0.5f * GetOriginY() * GetHeight(), 0.f);
guMtxScaleApply(mv2, mv2, 1.0f, -1.0f, 1.0f);
guMtxScaleApply(mv3, mv3, 1.0f, -1.0f, 1.0f);
guMtxConcat (pane_view, mv2, mv2);
guMtxConcat (pane_view, mv3, mv3);
f32 viewport[6];
f32 projection[7];
GX_GetViewportv(viewport);
GX_GetProjectionv(MainProjection, projection, GX_ORTHOGRAPHIC);
guVector vecTL;
guVector vecBR;
GX_Project(0.0f, 0.0f, 0.0f, mv2, projection, viewport, &vecTL.x, &vecTL.y, &vecTL.z);
GX_Project(0.0f, 0.0f, 0.0f, mv3, projection, viewport, &vecBR.x, &vecBR.y, &vecBR.z);
// round up scissor box offset and round down the size
scissorX = (u32)(0.5f + std::max(vecTL.x, 0.0f));
scissorY = (u32)(0.5f + std::max(vecTL.y, 0.0f));
scissorW = (u32)std::max(vecBR.x - vecTL.x, 0.0f);
scissorH = (u32)std::max(vecBR.y - vecTL.y, 0.0f);
GX_SetScissor( scissorX, scissorY, scissorW, scissorH );
}
// binded layouts dont inheiret the modified widescreen setting
bool realWS = ( _CONF_GetAspectRatio() == CONF_ASPECT_16_9 );
// draw binded layouts that appear under this one
foreach( Layout *l, bindedLayoutsUnder )
{
l->RenderWithCurrentMtx( pane_view, realWS );
}
void Menu_DrawDiskCover(f32 xpos, f32 ypos, f32 zpos, u16 width, u16 height, u16 distance, u8 data[], f32 deg_alpha,
f32 deg_beta, f32 scaleX, f32 scaleY, u8 alpha, bool shadow)
{
if (data == NULL) return;
GX_LoadProjectionMtx(FSProjection2D, GX_ORTHOGRAPHIC);
GXTexObj texObj;
GX_InitTexObj(&texObj, data, width, height, GX_TF_RGBA8, GX_CLAMP, GX_CLAMP, GX_FALSE);
GX_LoadTexObj(&texObj, GX_TEXMAP0);
GX_ClearVtxDesc();
GX_InvVtxCache();
GX_InvalidateTexAll();
GX_SetVtxDesc(GX_VA_POS, GX_DIRECT);
GX_SetVtxDesc(GX_VA_CLR0, GX_DIRECT);
GX_SetVtxDesc(GX_VA_TEX0, GX_DIRECT);
f32 cos_beta = cos(DegToRad( deg_beta ));
f32 s_offset_y = (zpos + (cos_beta * distance)) * tan(DegToRad( 5 ));
f32 s_offset_x = (cos_beta < 0 ? -cos_beta : cos_beta) * s_offset_y;
f32 s_offset_z = (s_offset_y < 0 ? 0 : s_offset_y) * 2;
Mtx m, m1, m2, m3, m4, mv;
width *= .5;
height *= .5;
guMtxIdentity(m4);
guMtxTransApply(m4, m4, 0, 0, distance);
guMtxIdentity(m1);
guMtxScaleApply(m1, m1, scaleX, scaleY, 1.0);
guVector axis2 = (guVector) {0 , 1, 0};
guMtxRotAxisDeg ( m2, &axis2, deg_beta );
guVector axis = (guVector) {0 , 0, 1};
guMtxRotAxisDeg ( m3, &axis, deg_alpha );
guMtxConcat(m3, m4, m3); // move distance then rotate z-axis
guMtxConcat(m2, m3, m2); // rotate y-axis
guMtxConcat(m1, m2, m); // scale
if (shadow)
guMtxTransApply(m, m, xpos + width + 0.5 + s_offset_x, ypos + height + 0.5 + s_offset_y, zpos - s_offset_z);
else
guMtxTransApply(m, m, xpos + width + 0.5, ypos + height + 0.5, zpos);
guMtxConcat(FSModelView2D, m, mv);
GX_LoadPosMtxImm(mv, GX_PNMTX0);
GX_Begin(GX_QUADS, GX_VTXFMT0, 4);
if (shadow)
{
GX_Position3f32(-width, -height, 0);
GX_Color4u8(0, 0, 0, alpha);
GX_TexCoord2f32(0, 0);
GX_Position3f32(width, -height, 0);
GX_Color4u8(0, 0, 0, alpha);
GX_TexCoord2f32(1, 0);
GX_Position3f32(width, height, 0);
GX_Color4u8(0, 0, 0, alpha);
GX_TexCoord2f32(1, 1);
GX_Position3f32(-width, height, 0);
GX_Color4u8(0, 0, 0, alpha);
GX_TexCoord2f32(0, 1);
}
else
{
GX_Position3f32(-width, -height, 0);
GX_Color4u8(0xFF, 0xFF, 0xFF, alpha);
GX_TexCoord2f32(0, 0);
GX_Position3f32(width, -height, 0);
GX_Color4u8(0xFF, 0xFF, 0xFF, alpha);
GX_TexCoord2f32(1, 0);
GX_Position3f32(width, height, 0);
GX_Color4u8(0xFF, 0xFF, 0xFF, alpha);
GX_TexCoord2f32(1, 1);
GX_Position3f32(-width, height, 0);
GX_Color4u8(0xFF, 0xFF, 0xFF, alpha);
GX_TexCoord2f32(0, 1);
}
GX_End();
}
void BannerWindow::Draw(void)
{
if(!ShowBanner)
return;
// draw a black background image first
if(AnimStep >= MaxAnimSteps)
DrawRectangle(0.0f, 0.0f, m_vid.width(), m_vid.height(), (GXColor) {0, 0, 0, 0xFF});
if(changing)
return;
// Run window animation
Animate();
// cut the unneeded crap
Mtx mv1, mv2, mv3;
guMtxIdentity(mv2);
guMtxIdentity(mv3);
guMtxScaleApply(modelview,mv1, 1.f, -1.f, 1.f);
guMtxTransApply(mv1,mv1, 0.5f * ScreenProps.x, 0.5f * ScreenProps.y, 0.f);
guMtxTransApply(mv2,mv2, -0.5f * fBannerWidth, 0.5f * fBannerHeight, 0.f);
guMtxTransApply(mv3,mv3, 0.5f * fBannerWidth, -0.5f * fBannerHeight + 104.f, 0.f);
guMtxConcat(mv1, mv2, mv2);
guMtxConcat(mv1, mv3, mv3);
f32 viewportv[6];
f32 projectionv[7];
GX_GetViewportv(viewportv, m_vid.vid_mode());
GX_GetProjectionv(projectionv, projection, GX_ORTHOGRAPHIC);
guVector vecTL;
guVector vecBR;
GX_Project(0.0f, 0.0f, 0.0f, mv2, projectionv, viewportv, &vecTL.x, &vecTL.y, &vecTL.z);
GX_Project(0.0f, 0.0f, 0.0f, mv3, projectionv, viewportv, &vecBR.x, &vecBR.y, &vecBR.z);
// round up scissor box offset and round down the size
u32 scissorX = (u32)(0.5f + std::max(vecTL.x, 0.0f));
u32 scissorY = (u32)(0.5f + std::max(vecTL.y, 0.0f));
u32 scissorW = (u32)std::max(vecBR.x - vecTL.x, 0.0f);
u32 scissorH = (u32)std::max(vecBR.y - vecTL.y, 0.0f);
GX_SetScissor(scissorX, scissorY, scissorW, scissorH);
// load projection matrix
GX_LoadProjectionMtx(projection, GX_ORTHOGRAPHIC);
if(gameBanner.getBanner())
{
gameBanner.getBanner()->Render(modelview, ScreenProps, m_vid.wide(), 255.f);
gameBanner.getBanner()->AdvanceFrame();
}
// Setup GX
ReSetup_GX();
GX_SetScissor(0, 0, m_vid.width(), m_vid.height());
// Clear and back to previous projection
m_vid.setup2DProjection();
// If wanted
if(Brightness == 200)
DrawRectangle(0.0f, 0.0f, m_vid.width(), m_vid.height(), (GXColor) {0, 0, 0, Brightness});
}
void BannerWindow::Draw(void)
{
bool btnAGrow = (settingsBtn->GetState() == STATE_SELECTED || backBtn->GetState() == STATE_SELECTED);
bannerFrame.SetButtonAGrow(btnAGrow);
bannerFrame.SetButtonBGrow(startBtn->GetState() == STATE_SELECTED);
//! Start playing banner sound after last animation frame if animation after zoom is enabled
//! or on first frame if during zoom is enable
if( AnimZoomIn && gameSound && (((Settings.BannerAnimStart == BANNER_START_ON_ZOOM) && AnimStep == 0)
|| ((Settings.BannerAnimStart == BANNER_START_AFTER_ZOOM) && ((AnimStep + 1) == MaxAnimSteps))))
{
reducedVol = true;
gameSound->Play();
}
// Run window animation
Animate();
// draw a black background image first
Menu_DrawRectangle(0.0f, 0.0f, ScreenProps.x, ScreenProps.y, (GXColor) {0, 0, 0, BGAlpha}, true);
// no banner alpha means its the start of the animation
if(BannerAlpha == 0)
return;
// cut the unneeded stuff
Mtx mv1, mv2, mv3;
guMtxIdentity (mv2);
guMtxIdentity (mv3);
guMtxScaleApply(modelview,mv1, 1.f, -1.f, 1.f);
guMtxTransApply(mv1,mv1, 0.5f * ScreenProps.x, 0.5f * ScreenProps.y, 0.f);
guMtxTransApply(mv2,mv2, -0.5f * fBannerWidth, 0.5f * fBannerHeight, 0.f);
guMtxTransApply(mv3,mv3, 0.5f * fBannerWidth, -0.5f * fBannerHeight, 0.f);
guMtxConcat (mv1, mv2, mv2);
guMtxConcat (mv1, mv3, mv3);
f32 viewportv[6];
f32 projectionv[7];
GX_GetViewportv(viewportv, vmode);
GX_GetProjectionv(projectionv, projection, GX_ORTHOGRAPHIC);
guVector vecTL;
guVector vecBR;
GX_Project(0.0f, 0.0f, 0.0f, mv2, projectionv, viewportv, &vecTL.x, &vecTL.y, &vecTL.z);
GX_Project(0.0f, 0.0f, 0.0f, mv3, projectionv, viewportv, &vecBR.x, &vecBR.y, &vecBR.z);
// round up scissor box offset and round down the size
u32 scissorX = (u32)(0.5f + std::max(vecTL.x, 0.0f));
u32 scissorY = (u32)(0.5f + std::max(vecTL.y, 0.0f));
u32 scissorW = (u32)std::max(vecBR.x - vecTL.x, 0.0f);
u32 scissorH = (u32)std::max(vecBR.y - vecTL.y, 0.0f);
GX_SetScissor( scissorX, scissorY, scissorW, scissorH );
// load projection matrix
GX_LoadProjectionMtx(projection, GX_ORTHOGRAPHIC);
if(gameBanner->getBanner())
{
gameBanner->getBanner()->Render(modelview, ScreenProps, Settings.widescreen, BannerAlpha);
// advance only when animation isnt running on certain options
if(Settings.BannerAnimStart != BANNER_START_AFTER_ZOOM || !AnimationRunning)
{
gameBanner->getBanner()->AdvanceFrame();
// skip every 6th frame on PAL50 since all banners are 60 Hz
if(Settings.PAL50 && (frameCount % 6 == 0)) {
gameBanner->getBanner()->AdvanceFrame();
}
}
}
// render big frame and animate button over effects
bannerFrame.Render(modelview, ScreenProps, Settings.widescreen, BannerAlpha);
bannerFrame.AdvanceFrame();
// Setup GX
ReSetup_GX();
if(AnimationRunning) {
// remove scissors again as we draw the background layout too
GX_SetScissor(0, 0, vmode->fbWidth, vmode->efbHeight);
// only render gui stuff when animation is done
return;
}
GuiWindow::Draw();
}
