xref: /RvlSDK-3.3/vcmv/src/vcmv_test.c

/*---------------------------------------------------------------------------*
Project:  Virtual Console Manual Viewer Shell Program
File:     vcmv_test.c

Copyright 1998-2009 Nintendo.  All rights reserved.

These coded instructions, statements, and computer programs contain
proprietary information of Nintendo of America Inc. and/or Nintendo
Company Ltd., and are protected by Federal copyright law.  They may
not be disclosed to third parties or copied or duplicated in any form,
in whole or in part, without the prior written consent of Nintendo.

// This program should be adapted to each Virtual Console game engine

*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*
  Macro definitions
*---------------------------------------------------------------------------*/

#if 0
#define verbose(s); s
#else
#define verbose(s);
#endif

#define USE_FOR_MANUAL
#define HOME_BUTTON_MENU_3            1
#define PAL_MODE                      0
#define PAL_MODE_SUPPORTS_PROGRESSIVE 0   // Set to 1 if the game supports 60Hz in PAL region (Most VC titles do not)
#define GAME_SUPPORTS_NON_INTERLACE   1

#define USE_MEMORY_PROTOCOL           1   // Determines whether to keep the html contents in memory, or copy to NAND /tmp directory
#define INITIALIZE_IN_THREAD          1
#define GAME_HARDWARE_WIDTH           256 // Choose from: 256, 320, 336, 512
#define GAME_HARDWARE_HEIGHT          224 // Choose from: 224, 240
#define GAME_TEXTURE_HEIGHT           GAME_HARDWARE_HEIGHT
#define SIMULATE_GAME_MEMORY_USAGE    0
#define MANUALLY_ADJUSTED_TWEAK       0
#define TEST_BAN_ICON                 0

#if defined REGION_KOR
      #define IGNORE_TV_ASPECT_RATIO        1
#else
      #define IGNORE_TV_ASPECT_RATIO        0
#endif

#define GAME_USES_NW4R                0
#define BROWSER_RSO_CIDX              2
#define FONT_CIDX                     3

#define GX_FIFO_SIZE                  (1024 * 1024)
#define FILTER_KPAD                   1

/*---------------------------------------------------------------------------*
  Header files
*---------------------------------------------------------------------------*/

#include "vcmv.h"
#include <revolution.h>
#include <revolution/sc.h>
#include <revolution/vi.h>
#include <revolution/wpad.h>
#include <revolution/ax.h>
#include <revolution/mix.h>
#include <revolution/kpad.h>
#include <revolution/cx.h>
#include <revolution/tpl.h>
#include <revolution/nand.h>
#include <string.h>
#include <stdio.h>
#if GAME_USES_NW4R
#include <nw4r/snd.h>
#endif

/*---------------------------------------------------------------------------*
  Game Hardware definitions and data
*---------------------------------------------------------------------------*/

typedef struct {
    s32 nGameXFB;
    s32 nGameVI;
    s32 nCurrentXFB;
    s32 nCurrentVI;
    f32 rTweakR;
} TweakEntry;

#if   ( GAME_HARDWARE_WIDTH == 256 )
#define GAME_TEXTURE_WIDTH     256
#define GAME_EFB_WIDTH_FULL    512
#define GAME_XFB_WIDTH_FULL    512
#define GAME_VI_WIDTH_FULL     640
#define GAME_EFB_WIDTH_SQUASH  512
#define GAME_XFB_WIDTH_SQUASH  512
#define GAME_VI_WIDTH_SQUASH   512
TweakEntry aTweakTbl[] = {
    { 512, 512, 512, 512,  0.0 },
    { 512, 512, 608, 670,  0.9 },
    { 512, 512, 608, 672,  0.7 },
    { 512, 512, 640, 686,  0.3 },
    { 512, 512, 640, 688,  1.3 },
    { 512, 640, 608, 670,  0.6 },
    { 512, 640, 608, 672,  0.2 },
    { 512, 640, 640, 686,  0.1 },
    { 512, 640, 640, 688,  0.9 },
};

#elif ( GAME_HARDWARE_WIDTH == 320 )
#define GAME_TEXTURE_WIDTH     320
#define GAME_EFB_WIDTH_FULL    640
#define GAME_XFB_WIDTH_FULL    640
#define GAME_VI_WIDTH_FULL     640
#define GAME_EFB_WIDTH_SQUASH  320
#define GAME_XFB_WIDTH_SQUASH  320
#define GAME_VI_WIDTH_SQUASH   480
TweakEntry aTweakTbl[] = {
    { 320, 480, 512, 512, -0.9 },
    { 320, 480, 608, 670,  0.7 },
    { 320, 480, 608, 672,  0.4 },
    { 320, 480, 640, 686, -0.2 },
    { 320, 480, 640, 688,  1.2 },
    { 640, 640, 608, 670,  0.9 },
    { 640, 640, 608, 672,  0.7 },
    { 640, 640, 640, 686,  0.3 },
    { 640, 640, 640, 688,  1.2 },
};

#elif ( GAME_HARDWARE_WIDTH == 336 )
#define GAME_TEXTURE_WIDTH     336
#define GAME_EFB_WIDTH_FULL    336
#define GAME_XFB_WIDTH_FULL    336
#define GAME_VI_WIDTH_FULL     672 // Maybe 640?  672 Assumes 336 resolution of original hardware was designed to eliminate L/R borders
#define GAME_EFB_WIDTH_SQUASH  336
#define GAME_XFB_WIDTH_SQUASH  336
#define GAME_VI_WIDTH_SQUASH   504 // Maybe 480?  504 Assumes 336 resolution of original hardware was designed to eliminate L/R borders
TweakEntry aTweakTbl[] = {
    { 336, 504, 512, 512, -0.7 },
    { 336, 504, 608, 670,  0.8 },
    { 336, 504, 608, 672,  0.0 },
    { 336, 504, 640, 686, -0.4 },
    { 336, 504, 640, 688,  1.0 },
    { 336, 670, 608, 670, -0.5 },
    { 336, 672, 608, 670,  1.0 },
    { 336, 672, 608, 672,  0.6 },
    { 336, 672, 640, 686,  0.2 },
    { 336, 672, 640, 688,  1.2 },
};

#elif ( GAME_HARDWARE_WIDTH == 512 )
#define GAME_TEXTURE_WIDTH     512
#define GAME_EFB_WIDTH_FULL    512
#define GAME_XFB_WIDTH_FULL    512
#define GAME_VI_WIDTH_FULL     640
#define GAME_EFB_WIDTH_SQUASH  512
#define GAME_XFB_WIDTH_SQUASH  512
#define GAME_VI_WIDTH_SQUASH   512
TweakEntry aTweakTbl[] = {
    { 512, 512, 512, 512,  0.0 },
    { 512, 512, 608, 670,  2.0 },
    { 512, 512, 608, 672,  0.8 },
    { 512, 512, 640, 686,  0.3 },
    { 512, 512, 640, 688,  2.5 },
    { 512, 640, 608, 670,  1.1 },
    { 512, 640, 608, 672,  0.1 },
    { 512, 640, 640, 686,  0.1 },
    { 512, 640, 640, 688,  1.7 },
};
#endif

/*---------------------------------------------------------------------------*
  TV Mode definitions
*---------------------------------------------------------------------------*/

#define BLACKOUT_TIME           3

#if PAL_MODE
#define GAME_VI_HEIGHT          542
#define HBM_VI_HEIGHT           542
#define MANUAL_VI_HEIGHT        542
#define PROG_MODE               VI_TVMODE_EURGB60_PROG
#define INT_MODE                VI_TVMODE_PAL_INT
#define DS_MODE                 VI_TVMODE_PAL_DS
#define VI_MAX_WIDTH            VI_MAX_WIDTH_PAL
#define VI_MAX_HEIGHT           VI_MAX_HEIGHT_PAL
#else
#define GAME_VI_HEIGHT          (GAME_HARDWARE_HEIGHT<<1)
#define HBM_VI_HEIGHT           456
#define MANUAL_VI_HEIGHT        456
#define PROG_MODE               VI_TVMODE_NTSC_PROG
#define INT_MODE                VI_TVMODE_NTSC_INT
#define DS_MODE                 VI_TVMODE_NTSC_DS
#define VI_MAX_WIDTH            VI_MAX_WIDTH_NTSC
#define VI_MAX_HEIGHT           VI_MAX_HEIGHT_NTSC
#endif

#define HBM_EFB_WIDTH_WIDE      640   // 16:9 mode
#define HBM_EFB_WIDTH_NORMAL    608   // 4:3 mode
#define HBM_EFB_HEIGHT          456
#define HBM_VI_WIDTH_WIDE       688   // Multiple of 16, may be better than 686 for VI resampling
#define HBM_VI_WIDTH_NORMAL     672   // Multiple of 16, may be better than 670 for VI resampling
#define MANUAL_FB_HEIGHT        456
#define BROWSER_FB_HEIGHT       456

// Widescreen TV with 16:9 aspect ratio. TV should be set to display "Full" signal.
#define W_BROWSER_FB_WIDTH        808
#define W_MANUAL_FB_WIDTH_FULL    640
#define W_MANUAL_FB_WIDTH_SQUASH  640
#define W_MANUAL_VI_WIDTH_FULL    640
#define W_MANUAL_VI_WIDTH_SQUASH  640

// Normal TV with 4:3 aspect ratio
#define BROWSER_FB_WIDTH        608
#define MANUAL_FB_WIDTH_FULL    608
#define MANUAL_VI_WIDTH_FULL    672   // Multiple of 16, may be better than 670 for VI resampling
#define MANUAL_FB_WIDTH_SQUASH  512
#define MANUAL_VI_WIDTH_SQUASH  512

/*---------------------------------------------------------------------------*
  Simulate Game memory definitions and variables
*---------------------------------------------------------------------------*/

#if SIMULATE_GAME_MEMORY_USAGE
// For simulating game memory usage
#define GAME_MEM1_SIZE (16 * 1024 * 1024)
#define GAME_MEM2_SIZE (40 * 1024 * 1024)

u8 *pGameMem1 = 0;
u8 *pGameMem2 = 0;
s32 nGameMem1Idx = 0;
s32 nGameMem2Idx = 0;
#endif

/*---------------------------------------------------------------------------*
  Render Mode definitions and data
*---------------------------------------------------------------------------*/
//-------------------
// For Game
//-------------------
static const GXRenderModeObj C_aRmGame[6] = {
    // Game Interlaced, 4:3 or 16:9 Stretched
    {
        // Settings for progressive mode should be similar to interlaced settings
        INT_MODE,                                 // viTVmode
            GAME_XFB_WIDTH_FULL,                      // fbWidth
            GAME_HARDWARE_HEIGHT,                     // efbHeight
            GAME_VI_HEIGHT,                           // xfbHeight
            (VI_MAX_WIDTH - GAME_VI_WIDTH_FULL)/2,    // viXOrigin
            (VI_MAX_HEIGHT - GAME_VI_HEIGHT)/2,       // viYOrigin
            GAME_VI_WIDTH_FULL,                       // viWidth
            GAME_VI_HEIGHT,                           // viHeight
            VI_XFBMODE_DF,                            // xFBmode
            GX_FALSE,                                 // field_rendering
            GX_FALSE,                                 // aa
            6, 6, 6, 6, 6, 6,                         // sample_pattern
            6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 6, 6,
            8, 8,                                     // vfilter
            10, 12, 10,
            8, 8,
    },

    // Game Interlaced, 16:9 Squashed
    {
        // Settings for progressive mode should be similar to interlaced settings
        INT_MODE,                                 // viTVmode
            GAME_XFB_WIDTH_SQUASH,                    // fbWidth
            GAME_HARDWARE_HEIGHT,                     // efbHeight
            GAME_VI_HEIGHT,                           // xfbHeight
            (VI_MAX_WIDTH - GAME_VI_WIDTH_SQUASH)/2,  // viXOrigin
            (VI_MAX_HEIGHT - GAME_VI_HEIGHT)/2,       // viYOrigin
            GAME_VI_WIDTH_SQUASH,                     // viWidth
            GAME_VI_HEIGHT,                           // viHeight
            VI_XFBMODE_DF,                            // xFBmode
            GX_FALSE,                                 // field_rendering
            GX_FALSE,                                 // aa
            6, 6, 6, 6, 6, 6,                         // sample_pattern
            6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 6, 6,
            8, 8,                                     // vfilter
            10, 12, 10,
            8, 8,
        },

        // Game Progressive, 4:3 or 16:9 Stretched
        {
            PROG_MODE,                                // viTVmode
                GAME_XFB_WIDTH_FULL,                      // fbWidth
                GAME_HARDWARE_HEIGHT,                     // efbHeight
                GAME_VI_HEIGHT,                           // xfbHeight
                (VI_MAX_WIDTH - GAME_VI_WIDTH_FULL)/2,    // viXOrigin
                (VI_MAX_HEIGHT - GAME_VI_HEIGHT)/2,       // viYOrigin
                GAME_VI_WIDTH_FULL,                       // viWidth
                GAME_VI_HEIGHT,                           // viHeight
                VI_XFBMODE_SF,                            // xFBmode
                GX_FALSE,                                 // field_rendering
                GX_FALSE,                                 // aa
                6, 6, 6, 6, 6, 6,                         // sample_pattern
                6, 6, 6, 6, 6, 6,
                6, 6, 6, 6, 6, 6,
                6, 6, 6, 6, 6, 6,
                0, 0,                                     // vfilter
                21, 22, 21,
                0, 0,
        },

        // Game Progressive, 16:9 Squashed
        {
            PROG_MODE,                                // viTVmode
                GAME_XFB_WIDTH_SQUASH,                    // fbWidth
                GAME_HARDWARE_HEIGHT,                     // efbHeight
                GAME_VI_HEIGHT,                           // xfbHeight
                (VI_MAX_WIDTH - GAME_VI_WIDTH_SQUASH)/2,  // viXOrigin
                (VI_MAX_HEIGHT - GAME_VI_HEIGHT)/2,       // viYOrigin
                GAME_VI_WIDTH_SQUASH,                     // viWidth
                GAME_VI_HEIGHT,                           // viHeight
                VI_XFBMODE_SF,                            // xFBmode
                GX_FALSE,                                 // field_rendering
                GX_FALSE,                                 // aa
                6, 6, 6, 6, 6, 6,                         // sample_pattern
                6, 6, 6, 6, 6, 6,
                6, 6, 6, 6, 6, 6,
                6, 6, 6, 6, 6, 6,
                0, 0,                                     // vfilter
                21, 22, 21,
                0, 0,
            },

            // Game Non-interlaced, 4:3 or 16:9 Stretched
            {
                DS_MODE,                                  // viDisplayMode
                    GAME_XFB_WIDTH_FULL,                      // fbWidth
                    GAME_HARDWARE_HEIGHT,                     // efbHeight
                    (GAME_VI_HEIGHT/2),                       // xfbHeight
                    (VI_MAX_WIDTH - GAME_VI_WIDTH_FULL)/2,    // viXOrigin
                    (VI_MAX_HEIGHT - GAME_VI_HEIGHT)/4,       // viYOrigin
                    GAME_VI_WIDTH_FULL,                       // viWidth
                    GAME_VI_HEIGHT,                           // viHeight
                    VI_XFBMODE_SF,                            // xFBmode
                    GX_FALSE,                                 // field_rendering
                    GX_FALSE,                                 // aa
                    6,  6,  6,  6,  6,  6,                    // sample_pattern
                    6,  6,  6,  6,  6,  6,
                    6,  6,  6,  6,  6,  6,
                    6,  6,  6,  6,  6,  6,
                    0, 0,                                     // vfilter
                    21, 22, 21,
                    0, 0,
            },

            // Game Non-interlaced, 16:9 Squashed
            {
                DS_MODE,                                  // viDisplayMode
                    GAME_XFB_WIDTH_SQUASH,                    // fbWidth
                    GAME_HARDWARE_HEIGHT,                     // efbHeight
                    (GAME_VI_HEIGHT/2),                       // xfbHeight
                    (VI_MAX_WIDTH - GAME_VI_WIDTH_SQUASH)/2,  // viXOrigin
                    (VI_MAX_HEIGHT - GAME_VI_HEIGHT)/4,       // viYOrigin
                    GAME_VI_WIDTH_SQUASH,                     // viWidth
                    GAME_VI_HEIGHT,                           // viHeight
                    VI_XFBMODE_SF,                            // xFBmode
                    GX_FALSE,                                 // field_rendering
                    GX_FALSE,                                 // aa
                    6,  6,  6,  6,  6,  6,                    // sample_pattern
                    6,  6,  6,  6,  6,  6,
                    6,  6,  6,  6,  6,  6,
                    6,  6,  6,  6,  6,  6,
                    0, 0,                                     // vfilter
                    21, 22, 21,
                    0, 0,
                }
};

//-------------------
// For HBM
//-------------------
static const GXRenderModeObj C_aRmHBM[4] = {
    // HBM Interlaced, 4:3
    {
        INT_MODE,                                 // viTVmode
            HBM_EFB_WIDTH_NORMAL,                     // fbWidth
            HBM_EFB_HEIGHT,                           // efbHeight
            HBM_VI_HEIGHT,                            // xfbHeight
            (VI_MAX_WIDTH - HBM_VI_WIDTH_NORMAL)/2,   // viXOrigin
            (VI_MAX_HEIGHT - HBM_VI_HEIGHT)/2,        // viYOrigin
            HBM_VI_WIDTH_NORMAL,                      // viWidth
            HBM_VI_HEIGHT,                            // viHeight
            VI_XFBMODE_DF,                            // xFBmode
            GX_FALSE,                                 // field_rendering
            GX_FALSE,                                 // aa
            6, 6, 6, 6, 6, 6,                         // sample_pattern
            6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 6, 6,
            8, 8,                                     // vfilter
            10, 12, 10,
            8, 8,
    },

    // HBM Interlaced, 16:9
    {
        INT_MODE,                                 // viTVmode
            HBM_EFB_WIDTH_WIDE,                       // fbWidth
            HBM_EFB_HEIGHT,                           // efbHeight
            HBM_VI_HEIGHT,                            // xfbHeight
            (VI_MAX_WIDTH - HBM_VI_WIDTH_WIDE)/2,     // viXOrigin
            (VI_MAX_HEIGHT - HBM_VI_HEIGHT)/2,        // viYOrigin
            HBM_VI_WIDTH_WIDE,                        // viWidth
            HBM_VI_HEIGHT,                            // viHeight
            VI_XFBMODE_DF,                            // xFBmode
            GX_FALSE,                                 // field_rendering
            GX_FALSE,                                 // aa
            6, 6, 6, 6, 6, 6,                         // sample_pattern
            6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 6, 6,
            8, 8,                                     // vfilter
            10, 12, 10,
            8, 8,
        },

        // HBM Progressive, 4:3
        {
            PROG_MODE,                                // viTVmode
                HBM_EFB_WIDTH_NORMAL,                     // fbWidth
                HBM_EFB_HEIGHT,                           // efbHeight
                HBM_VI_HEIGHT,                            // xfbHeight
                (VI_MAX_WIDTH - HBM_VI_WIDTH_NORMAL)/2,   // viXOrigin
                (VI_MAX_HEIGHT - HBM_VI_HEIGHT)/2,        // viYOrigin
                HBM_VI_WIDTH_NORMAL,                      // viWidth
                HBM_VI_HEIGHT,                            // viHeight
                VI_XFBMODE_SF,                            // xFBmode
                GX_FALSE,                                 // field_rendering
                GX_FALSE,                                 // aa
                6, 6, 6, 6, 6, 6,                         // sample_pattern
                6, 6, 6, 6, 6, 6,
                6, 6, 6, 6, 6, 6,
                6, 6, 6, 6, 6, 6,
                8, 8,                                     // vfilter
                10, 12, 10,
                8, 8,
        },

        // HBM Progressive, 16:9
        {
            PROG_MODE,                                // viTVmode
                HBM_EFB_WIDTH_WIDE,                       // fbWidth
                HBM_EFB_HEIGHT,                           // efbHeight
                HBM_VI_HEIGHT,                            // xfbHeight
                (VI_MAX_WIDTH - HBM_VI_WIDTH_WIDE)/2,     // viXOrigin
                (VI_MAX_HEIGHT - HBM_VI_HEIGHT)/2,        // viYOrigin
                HBM_VI_WIDTH_WIDE,                        // viWidth
                HBM_VI_HEIGHT,                            // viHeight
                VI_XFBMODE_SF,                            // xFBmode
                GX_FALSE,                                 // field_rendering
                GX_FALSE,                                 // aa
                6, 6, 6, 6, 6, 6,                         // sample_pattern
                6, 6, 6, 6, 6, 6,
                6, 6, 6, 6, 6, 6,
                6, 6, 6, 6, 6, 6,
                8, 8,                                     // vfilter
                10, 12, 10,
                8, 8,
            },
};


//-------------------
// For Manual
//-------------------
static const GXRenderModeObj C_aRmManual[4] = {
    // Manual Interlaced, 4:3 or 16:9 Stretched
    {
        INT_MODE,                                 // viTVmode
            MANUAL_FB_WIDTH_FULL,                     // fbWidth
            MANUAL_FB_HEIGHT,                         // efbHeight
            MANUAL_VI_HEIGHT,                         // xfbHeight
            (VI_MAX_WIDTH - MANUAL_VI_WIDTH_FULL)/2,  // viXOrigin
            (VI_MAX_HEIGHT - MANUAL_VI_HEIGHT)/2,     // viYOrigin
            MANUAL_VI_WIDTH_FULL,                     // viWidth
            MANUAL_VI_HEIGHT,                         // viHeight
            VI_XFBMODE_DF,                            // xFBmode
            GX_FALSE,                                 // field_rendering
            GX_FALSE,                                 // aa
            6, 6, 6, 6, 6, 6,                         // sample_pattern
            6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 6, 6,
            8, 8,                                     // vfilter
            10, 12, 10,
            8, 8,
    },

    // Manual Interlaced, 16:9 Squashed
    {
        INT_MODE,                                 // viTVmode
            W_MANUAL_FB_WIDTH_SQUASH,                   // fbWidth
            MANUAL_FB_HEIGHT,                         // efbHeight
            MANUAL_VI_HEIGHT,                         // xfbHeight
            (VI_MAX_WIDTH - W_MANUAL_VI_WIDTH_SQUASH)/2,// viXOrigin
            (VI_MAX_HEIGHT - MANUAL_VI_HEIGHT)/2,     // viYOrigin
            W_MANUAL_VI_WIDTH_SQUASH,                   // viWidth
            MANUAL_VI_HEIGHT,                         // viHeight
            VI_XFBMODE_DF,                            // xFBmode
            GX_FALSE,                                 // field_rendering
            GX_FALSE,                                 // aa
            6, 6, 6, 6, 6, 6,                         // sample_pattern
            6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 6, 6,
            6, 6, 6, 6, 6, 6,
            8, 8,                                     // vfilter
            10, 12, 10,
            8, 8,
        },

        // Manual Progressive, 4:3 or 16:9 Stretched
        {
            PROG_MODE,                                // viTVmode
                MANUAL_FB_WIDTH_FULL,                     // fbWidth
                MANUAL_FB_HEIGHT,                         // efbHeight
                MANUAL_VI_HEIGHT,                         // xfbHeight
                (VI_MAX_WIDTH - MANUAL_VI_WIDTH_FULL)/2,  // viXOrigin
                (VI_MAX_HEIGHT - MANUAL_VI_HEIGHT)/2,     // viYOrigin
                MANUAL_VI_WIDTH_FULL,                     // viWidth
                MANUAL_VI_HEIGHT,                         // viHeight
                VI_XFBMODE_SF,                            // xFBmode
                GX_FALSE,                                 // field_rendering
                GX_FALSE,                                 // aa
                6, 6, 6, 6, 6, 6,                         // sample_pattern
                6, 6, 6, 6, 6, 6,
                6, 6, 6, 6, 6, 6,
                6, 6, 6, 6, 6, 6,
                8, 8,                                     // vfilter
                10, 12, 10,
                8, 8,
        },

        // Manual Progressive, 16:9 Squashed
        {
            PROG_MODE,                                // viTVmode
                W_MANUAL_FB_WIDTH_SQUASH,                   // fbWidth
                MANUAL_FB_HEIGHT,                         // efbHeight
                MANUAL_VI_HEIGHT,                         // xfbHeight
                (VI_MAX_WIDTH - W_MANUAL_VI_WIDTH_SQUASH)/2,// viXOrigin
                (VI_MAX_HEIGHT - MANUAL_VI_HEIGHT)/2,     // viYOrigin
                W_MANUAL_VI_WIDTH_SQUASH,                   // viWidth
                MANUAL_VI_HEIGHT,                         // viHeight
                VI_XFBMODE_SF,                            // xFBmode
                GX_FALSE,                                 // field_rendering
                GX_FALSE,                                 // aa
                6, 6, 6, 6, 6, 6,                         // sample_pattern
                6, 6, 6, 6, 6, 6,
                6, 6, 6, 6, 6, 6,
                6, 6, 6, 6, 6, 6,
                8, 8,                                     // vfilter
                10, 12, 10,
                8, 8,
            },
};

enum {
    E_InGame = 0,
    E_InGamePlusBanIcon,
    E_GameToHbmTransition1,
    E_GameToHbmTransition2,
    E_InHbm,
    E_HbmToGameTransition,
    E_HbmToVcmvTransition,
    E_InVcmv,
    E_FadeInGameTransition,

    E_BlackOutTransition,
    E_ResartGameAfterResetTransition
};

/*---------------------------------------------------------------------------*
  Global variables
*---------------------------------------------------------------------------*/
typedef struct { f32 left, top, right, bottom; } RectF32;

//-----------------------
// For NW4R
//-----------------------
#if GAME_USES_NW4R
#include <nw4r/snd.h>
static const OSPriority SOUND_THREAD_PRIORITY = 4;
static const OSPriority DVD_THREAD_PRIORITY = 3;
#endif

//-----------------------
// For Memory
//-----------------------
MEMAllocator Allocator1;
MEMAllocator Allocator2;

//-----------------------
// For File read
//-----------------------
CNTHandle hCnt4, hCnt5;
#if HOME_BUTTON_MENU_3
CNTHandle hCnt6;
#endif

//-----------------------
// For Rendering
//-----------------------
const u32 C_nNumTweakEntries = sizeof(aTweakTbl)/sizeof(TweakEntry);

const GXRenderModeObj *pRmGame;
const GXRenderModeObj *pRmHBM;
const GXRenderModeObj *pRmManual;
const GXRenderModeObj *pRmManualNormal;
const GXRenderModeObj *pRmManualWide;
const GXRenderModeObj *pCurrentRenderMode;
const GXRenderModeObj *pPreviousRenderMode;

BOOL bProgressiveFlag;
BOOL bNonInterlaceFlag;
BOOL bSquashFlag;

Mtx44 mGameProjectionMtx;

s32 nGameEfbWidth;
s32 nGameXfbWidth;
s32 nGameXfbStride;
s32 nGameViWidth;
s32 nHbmEfbWidth;
s32 nHbmXfbStride;
s32 nHbmViWidth;
s32 nCurrentEfbRenderWidth;
f32 rHbmGxHalfWidth;
u32 nMaxXfbSize;
u8  nTVAspectRatio;
u8  nHbmAspectRatio;

f32 rGlobalAdjustRightCoord = 0.0f;

static void      *pGXFifoBuffer;
static GXFifoObj *pGXFifoObj;

static void      *apXFB[2];
static s32       nDisplayXFB;

GXTexObj toSample;
void     *pSampleTextureData = NULL;

RectF32 rectGameEfb;
RectF32 rectScreen;

//-----------------------
// For Man viewer
//-----------------------
void *pManualData;

BOOL bAnyHomeButtonPressed;
BOOL bHomeButtonMenu;

const char *pCurrentURL;
char pTopPageURL[100];
char *pTopPage;

volatile s32 nSum;
u8 nInitialFocusController;

//-----------------------
// For Home Button Menu
//-----------------------
HBMDataInfo hbmInfo;

int nGameToHbmTransition1MaxFrame;
int nGameToHbmTransition2MaxFrame;
int nHbmToGameTransitionMaxFrame;
int nFadeInGameTransitionMaxFrame;
int nHbmVcmvState;
int nTransitionFrame;

u8 nGameFadeBrightnessLevel;

// The VCMV initialization routines do not require a large stack size
const int C_nVcmvInitThreadStackSize = 64*1024;

BOOL bTmpFilesCreated = FALSE;
void *pMyVcmvInitThreadStack = 0;
void *pHbmSoundInstanceBuf   = 0;

#if HOME_BUTTON_MENU_3
u8* sound_data_ptr = NULL;
#endif

enum {
    eAlphaInIcon = 0,
    ePauseIcon,
    eAlphaOutIcon
};

typedef struct {
    TPLPalette *pTpl;
    BOOL   bOnFlag;
    OSTick nTime;
    s8     nState;  // 0:AlphaIn, 1:Pause, 2:AlphaOut
    u8     nAlpha;
} OverlayIconStruct;

OverlayIconStruct sBanHbmIcon;  // Icon to indicate when HBM temporarily unavailable.

//-----------------------
// For Reset Function
//-----------------------
volatile BOOL bCalledHBMBlackOut;
volatile BOOL bResetButtonPressed = FALSE;
volatile BOOL bPowerButtonPressed = FALSE;

/*---------------------------------------------------------------------------*
  Function Declaration
*---------------------------------------------------------------------------*/
//-----------------------
//  MEMORY
//-----------------------
void MyInitAllocators(void);
void *MyAllocMem1(u32 size);
void *MyAllocMem2(u32 size);
u8 MyFreeMem1(void *addr);
u8 MyFreeMem2(void *addr);

//-----------------------
//  FILE READ
//-----------------------
u32 MyContentReadFile(CNTHandle *phCnt, const char *pFileName, void **ppBuffer, MEMAllocator *pAlloc1, MEMAllocator *pAlloc2);

//-----------------------
//  AUDIO
//-----------------------
void MyInitAudio(void);

//-----------------------
//  RENDERING
//-----------------------
void ClearYUV(void *pPtr, u32 nSizeInBytes);
void ClearBorderYUV(void *pPtr);
void MyInitGX(void);
void MyUpdateRenderModes();
void MyInitDisplayMode(void);
void LoadTexture();
void MyDrawInit();
void SetupTexture(const GXTexObj *pTexObj, GXColor clr);
void DrawAxisAlignedRect(const RectF32 *pRect);
void SetupColorOnly(GXColor clr);
void DrawColorRect(const RectF32 *pRect);
void DrawTexture(const RectF32 *pRect, const GXTexObj *pTexObj, GXColor color);
void CompensateForModeChange(void);
void GameDrawTick(void);
void MyDrawDone(void);

//-------------------------
//  MANUAL VIEWER
//-------------------------
void MyLoadManualData(void);
void MyVcmvDoneRenderCallback(u8 nFadeIn, const GXRenderModeObj *pRm);
void UpdateInitialFocusController(void);
void MyInitializeManualViewer(void *);
void MyCloseManualViewer(void);
void RunManualViewer(void);

//-------------------------------
//  HOME BUTTON BAN ICON
//--------------------------------
void ActivateBanIcon(void);
void DrawBanIcon(void);

//------------------------------------
//  HOME BUTTON MENU RELATED
//------------------------------------
static int MyHBMSoundCallback(int evt, int arg);
void MyInitHomeButtonMenu(void);
void SetupHbmGX(void);
void DrawBoxCursors(void);

//-----------------------
//  RESET
//-----------------------
void ResetGame();
void MyPowerButtonCallback(void);
void MyResetButtonCallback(void);

//-----------------------
//  CONTROLLER FUNCTIONS
//-----------------------
void MyReadControllers(void);

//-----------------------
//  MAIN PROGRAM
//-----------------------
void Test(void);


/*---------------------------------------------------------------------------*
  Functions
*---------------------------------------------------------------------------*/
//=============================================================================
// MEMORY FUNCTIONS
//=============================================================================
/*---------------------------------------------------------------------------*
    Name:         MyInitAllocators
*---------------------------------------------------------------------------*/
void MyInitAllocators(void)
{
    void *arenaLo, *arenaHi;
    MEMHeapHandle heapHandle;

    // Memory allocation managed by MEM library
    arenaLo = OSGetMEM1ArenaLo();
    arenaHi = OSGetMEM1ArenaHi();
    heapHandle = MEMCreateExpHeap(arenaLo, (u32)arenaHi - (u32)arenaLo);
    verbose(OSReport("MEMCreateExpHeap(%p, %p)\n", arenaLo, (u32)arenaHi - (u32)arenaLo););

    if (heapHandle == MEM_HEAP_INVALID_HANDLE) {
        OSHalt("MEM1 heap allocation error.\n");
    }

    OSSetMEM1ArenaLo(arenaHi);
    MEMInitAllocatorForExpHeap(&Allocator1, heapHandle, 32);

    // Heap on MEM2
    arenaLo = OSGetMEM2ArenaLo();
    arenaHi = OSGetMEM2ArenaHi();
    heapHandle = MEMCreateExpHeap(arenaLo, (u32)arenaHi - (u32)arenaLo);
    verbose(OSReport("MEMCreateExpHeap(%p, %p)\n", arenaLo, (u32)arenaHi - (u32)arenaLo););

    if (heapHandle == MEM_HEAP_INVALID_HANDLE) {
        OSHalt("MEM2 heap allocation error.\n");
    }

    OSSetMEM2ArenaLo(arenaHi);
    MEMInitAllocatorForExpHeap(&Allocator2, heapHandle, 32);
}

/*---------------------------------------------------------------------------*
    Name:         MyAllocMem1
*---------------------------------------------------------------------------*/
void *MyAllocMem1(u32 size)
{
    void *addr = MEMAllocFromAllocator(&Allocator1, size);
    verbose(OSReport("MyAllocMem1 %d bytes @ 0x%08x\n", size, addr););

    return addr;
}

/*---------------------------------------------------------------------------*
    Name:         MyFreeMem1
*---------------------------------------------------------------------------*/
u8 MyFreeMem1(void *addr)
{

    MEMFreeToAllocator(&Allocator1, addr);
    verbose(OSReport("MyFreeMem1 @ 0x%08x\n", addr););

    return TRUE;
}

/*---------------------------------------------------------------------------*
    Name:         MyAllocMem2
*---------------------------------------------------------------------------*/

void *MyAllocMem2(u32 size)
{
    void *addr = MEMAllocFromAllocator(&Allocator2, size);
    verbose(OSReport("MyAllocMem2 %d bytes @ 0x%08x\n", size, addr););

    return addr;
}

/*---------------------------------------------------------------------------*
    Name:         MyFreeMem2
--------------------------------------------------*/
u8 MyFreeMem2(void *addr)
{
    MEMFreeToAllocator(&Allocator2, addr);
    verbose(OSReport("MyFreeMem2 @ 0x%08x\n", addr););

    return TRUE;
}

//============================================================================
// FILE READ FUNCTIONS
//============================================================================
/*---------------------------------------------------------------------------*
    Name:         MyContentReadFile
*---------------------------------------------------------------------------*/
u32 MyContentReadFile(CNTHandle *phCnt, const char *pFileName, void **ppBuffer, MEMAllocator *pAlloc1, MEMAllocator *pAlloc2)
{
    CNTFileInfo cfi;
    u32 nSize, nRoundedUpSize;
    u8 nCompression = 0;
    s32 nResult;

    nResult = CNTOpen(phCnt, pFileName, &cfi);
    verbose(OSReport("CNTOpen(%p, \"%s\", %p) returned %d\n", phCnt, pFileName, (u32)&cfi, nResult););

    if (nResult != CNT_RESULT_OK) {
        return 0;
    }

    nSize = CNTGetLength(&cfi);
    nRoundedUpSize = OSRoundUp32B(nSize);

    if (strstr(pFileName, "/LZ77")) {
        nCompression = CX_COMPRESSION_LZ;
    } else if (strstr(pFileName, "/Huf8")) {
        nCompression = CX_COMPRESSION_HUFFMAN;
    }

    verbose(OSReport("Compression=%d\n", nCompression););

    if (nCompression) {
        void *pTempBuf=0;
        VCMVAllocIfNecessary(&pTempBuf, nRoundedUpSize, pAlloc1, pAlloc2);

        if (pTempBuf) {
            verbose(OSReport("Reading %p Bytes from %s to %p\n", nRoundedUpSize, pFileName, pTempBuf););

            CNTRead(&cfi, pTempBuf, nRoundedUpSize);
            nSize = CXGetUncompressedSize(pTempBuf);
            nRoundedUpSize = OSRoundUp32B(nSize);
            VCMVAllocIfNecessary(ppBuffer, nRoundedUpSize, pAlloc1, pAlloc2);
            verbose(OSReport("Decompressing %p Bytes to %p\n", nRoundedUpSize, *ppBuffer););

            if (*ppBuffer) {
                if (nCompression==CX_COMPRESSION_LZ) {
                    CXUncompressLZ(pTempBuf, *ppBuffer);
                } else {
                    CXUncompressHuffman(pTempBuf, *ppBuffer);
                }
            } else {
                nSize = 0;
            }

            VCMVFreeAndClearPointer(&pTempBuf);
        } else {
            nSize = 0;
        }
    } else {
        verbose(OSReport("VCMVAllocIfNecessary(%p, %d, %p %p)\n", *ppBuffer, nRoundedUpSize, pAlloc1, pAlloc2););
        VCMVAllocIfNecessary(ppBuffer, nRoundedUpSize, pAlloc1, pAlloc2);
        verbose(OSReport("ppBuffer=%p\n", *ppBuffer););

        if (*ppBuffer) {

            verbose(OSReport("Reading %p Bytes from %s to %p\n", nRoundedUpSize, pFileName, *ppBuffer););
            CNTRead(&cfi, *ppBuffer, nRoundedUpSize);
        } else {
            nSize = 0;
        }
    }

    CNTClose(&cfi);

    return nSize;
}

//============================================================================
// AUDIO FUNCTION
//============================================================================
/*---------------------------------------------------------------------------*
    Name:         MyInitAudio
*---------------------------------------------------------------------------*/
void MyInitAudio(void)
{
    static u8 bInitAX = TRUE;

    if (bInitAX) {
        AIInit(NULL);
        AXInit();
        AXSetMode(AX_MODE_STEREO);
#if GAME_USES_NW4R
        nw4r::snd::SoundSystem::InitSoundSystem(SOUND_THREAD_PRIORITY, DVD_THREAD_PRIORITY);
#else
        MIXInit();
        MIXSetSoundMode(MIX_SOUND_MODE_STEREO);
#endif
        bInitAX=FALSE;
    }
}


//============================================================================
// RENDERING FUNCTIONS
//============================================================================
/*---------------------------------------------------------------------------*
    Name:         ClearYUV
*---------------------------------------------------------------------------*/
void ClearYUV(void *pPtr, u32 nSizeInBytes)
{
    u32 *pPtrYUV = (u32*)pPtr;
    u32 *pPtrEnd = (u32*)((u32)pPtr + nSizeInBytes);

    verbose(OSReport("ClearYUV(%p, %d)\n", pPtr, nSizeInBytes););

    while (pPtrYUV<pPtrEnd) {
        *pPtrYUV++ = 0x800080;
    }

    DCFlushRange(pPtr, nSizeInBytes);
}

/*---------------------------------------------------------------------------*
    Name:         ClearBorderYUV
*---------------------------------------------------------------------------*/
void ClearBorderYUV(void *pPtr)
{
    u32 nBlackYUV = 0x800080;
    u32 *pPtrYUV = (u32*)pPtr;
    s32 nBorderSize = (pCurrentRenderMode->fbWidth - nCurrentEfbRenderWidth)>>1;
    s32 nEfbWidthInU32 = nCurrentEfbRenderWidth>>1;
    s32 nX, nY;

    if (nBorderSize < 0) {
        OSHalt(".");
    }

    for(nX=0; nX<(nBorderSize>>1); nX++) {
        *pPtrYUV++ = nBlackYUV;
    }

    pPtrYUV += nEfbWidthInU32;

    for(nY=1; nY<pCurrentRenderMode->viHeight; nY++) {

        for(nX=0; nX<nBorderSize; nX++) {
            *pPtrYUV++ = nBlackYUV;
        }

        pPtrYUV += nEfbWidthInU32;
    }

    for(nX=0; nX<nBorderSize>>1; nX++) {
        *pPtrYUV++ = nBlackYUV;
    }

    {
        u32 nSize = (u32)pPtrYUV - (u32)pPtr;
        DCFlushRange(pPtr, nSize);
    }
}

/*---------------------------------------------------------------------------*
    Name:         MyInitGX
*---------------------------------------------------------------------------*/
void MyInitGX(void)
{
    GXColor clear_clr = { 0,0,0,0 };

    if (pGXFifoBuffer==0) {
        pGXFifoBuffer = MyAllocMem1(GX_FIFO_SIZE);
        pGXFifoObj = GXInit(pGXFifoBuffer, GX_FIFO_SIZE);
    }

    // Set Pixel Format
    GXSetPixelFmt(GX_PF_RGB8_Z24, GX_ZC_LINEAR);
    GXSetDither(GX_DISABLE);

    // Initialize parameters of EFB->XFB Copy-out
    GXSetDispCopySrc(0, 0, pCurrentRenderMode->fbWidth, pCurrentRenderMode->efbHeight);
    GXSetDispCopyDst(pCurrentRenderMode->fbWidth, pCurrentRenderMode->xfbHeight);
    GXSetCopyFilter(pCurrentRenderMode->aa, pCurrentRenderMode->sample_pattern, GX_TRUE, pCurrentRenderMode->vfilter);
    GXSetDispCopyYScale(GXGetYScaleFactor(pCurrentRenderMode->efbHeight, pCurrentRenderMode->xfbHeight));
    GXSetDispCopyGamma(GX_GM_1_0);

    GXSetCopyClear(clear_clr, 0x00FFFFFF);

    // Initialize EFB Rendering Area
    GXSetViewport(0.0f, 0.0f, (f32)pCurrentRenderMode->fbWidth, (f32)pCurrentRenderMode->efbHeight, 0.0f, 1.0f);
    GXSetScissor(0, 0, (u32)pCurrentRenderMode->fbWidth, (u32)pCurrentRenderMode->efbHeight);

    // Clear EFB and XFB
    GXCopyDisp(apXFB[0], GX_ENABLE);
    GXDrawDone();
}

/*---------------------------------------------------------------------------*
    Name:         MyUpdateRenderModes
*---------------------------------------------------------------------------*/
void MyUpdateRenderModes()
{
    // This function should be called after VCMVRun finishes
#if ((PAL_MODE==0) || (PAL_MODE_SUPPORTS_PROGRESSIVE))
    bProgressiveFlag  = (VIGetDTVStatus() && (SCGetProgressiveMode()==SC_PROGRESSIVE_MODE_ON));
#else
    bProgressiveFlag  = 0;
#endif
    bNonInterlaceFlag = (~bProgressiveFlag) & VCMVGetNonInterlaceFlag() & GAME_SUPPORTS_NON_INTERLACE;

#if 0
    bSquashFlag       = nTVAspectRatio & VCMVGetSquashFlag();
#else
    bSquashFlag       = nTVAspectRatio;
#endif

    verbose(
    OSReport("bProgressiveFlag  = %d\n", bProgressiveFlag);
    OSReport("bNonInterlaceFlag = %d\n", bNonInterlaceFlag);
    OSReport("bSquashFlag       = %d\n", bSquashFlag);
    );

    pRmGame   = &C_aRmGame[(4*bNonInterlaceFlag)+(2*bProgressiveFlag)+bSquashFlag];
    pRmHBM    = &C_aRmHBM[(2*bProgressiveFlag)+nHbmAspectRatio];
    pRmManual = &C_aRmManual[(2*bProgressiveFlag)+bSquashFlag];
    pRmManualNormal = &C_aRmManual[2*bProgressiveFlag];
    pRmManualWide   = &C_aRmManual[(2*bProgressiveFlag)+1];

    if (bNonInterlaceFlag) {
        nGameToHbmTransition1MaxFrame = 10;
        nGameToHbmTransition2MaxFrame = 10;
        nHbmToGameTransitionMaxFrame  = 45;
        nFadeInGameTransitionMaxFrame = 12;
    } else {
        nGameToHbmTransition1MaxFrame = 1;
        nGameToHbmTransition2MaxFrame = -BLACKOUT_TIME;
        nHbmToGameTransitionMaxFrame  = 1;
        nFadeInGameTransitionMaxFrame = -BLACKOUT_TIME;
    }

    if (bSquashFlag) {
        nGameEfbWidth = GAME_EFB_WIDTH_SQUASH;
        nGameXfbWidth = GAME_XFB_WIDTH_SQUASH;
        nGameViWidth  = GAME_VI_WIDTH_SQUASH;
    } else {
        nGameEfbWidth = GAME_EFB_WIDTH_FULL;
        nGameXfbWidth = GAME_XFB_WIDTH_FULL;
        nGameViWidth  = GAME_VI_WIDTH_FULL;
    }

    if (nHbmAspectRatio) {
        nHbmEfbWidth  = HBM_EFB_WIDTH_WIDE;
    } else {
        nHbmEfbWidth  = HBM_EFB_WIDTH_NORMAL;
    }

    verbose(OSReport("pRmHBM->viWidth=%d\n", pRmHBM->viWidth););

    nGameXfbStride = VIPadFrameBufferWidth(nGameXfbWidth);
    nHbmXfbStride  = VIPadFrameBufferWidth(nHbmEfbWidth);
}

/*---------------------------------------------------------------------------*
    Name:         MyInitDisplayMode
*---------------------------------------------------------------------------*/
void MyInitDisplayMode(void)
{
    s32 nI;
    nTVAspectRatio  = SCGetAspectRatio();
#if IGNORE_TV_ASPECT_RATIO
    nTVAspectRatio  = 0;
#endif
    nHbmAspectRatio = nTVAspectRatio;
    //nHbmAspectRatio = 0;
    MyUpdateRenderModes();
    nCurrentEfbRenderWidth = nGameEfbWidth;

    // Allocate a double buffered XFB
    // First determine the maximum size required by the Game, HBM or Manual Viewer.
    // Allocate the maximum size so that the buffer does not need to be resized each
    // time the mode is changed.
    nMaxXfbSize = 0;

    for(nI=0; nI<6; nI++) {
        u32 nSize = (u32)(VIPadFrameBufferWidth(C_aRmGame[nI].fbWidth) * C_aRmGame[nI].viHeight * VI_DISPLAY_PIX_SZ);

        if (nMaxXfbSize < nSize) {
            nMaxXfbSize = nSize;
        }
    }
    for(nI=0; nI<4; nI++) {
        u32 nSize = (u32)(VIPadFrameBufferWidth(C_aRmHBM[nI].fbWidth) * C_aRmHBM[nI].viHeight * VI_DISPLAY_PIX_SZ);

        if (nMaxXfbSize < nSize) {
            nMaxXfbSize = nSize;
        }

        nSize = (u32)(VIPadFrameBufferWidth(C_aRmManual[nI].fbWidth) * C_aRmManual[nI].viHeight * VI_DISPLAY_PIX_SZ);

        if (nMaxXfbSize < nSize) {
            nMaxXfbSize = nSize;
        }

    }
    apXFB[0] = MyAllocMem2(nMaxXfbSize);
    apXFB[1] = MyAllocMem2(nMaxXfbSize);
    nDisplayXFB = 0;

    verbose(OSReport("VIGetDTVStatus()=%d, SCGetProgressiveMode()=%d bSquashFlag=%d\n", VIGetDTVStatus(), SCGetProgressiveMode(), bSquashFlag););
    verbose(OSReport("nGameViWidth=%d, nGameXfbWidth=%d, nGameXfbStride=%d\n", nGameViWidth, nGameXfbWidth, nGameXfbStride););

    // Clear EFB area in advance for HBM
    pCurrentRenderMode = pRmHBM;
    MyInitGX();

    pCurrentRenderMode = pRmGame;
    MyInitGX();

    // Clear XFB
    ClearYUV(apXFB[0], nMaxXfbSize);
    ClearYUV(apXFB[1], nMaxXfbSize);

    // Initialize VI
    VIConfigure(pCurrentRenderMode);
    VISetNextFrameBuffer(apXFB[nDisplayXFB]);
    VIFlush();

    // Wait 2 frames for new VI settings to take effect
    VIWaitForRetrace();
    VIWaitForRetrace();
}

/*---------------------------------------------------------------------------*
    Name:         LoadTexture
*---------------------------------------------------------------------------*/
void LoadTexture()
{
    char sFileName[64];

    sprintf(sFileName, "sample%dx%d.rgb565", GAME_TEXTURE_WIDTH, GAME_TEXTURE_HEIGHT);
    verbose(OSReport("Loading %s\n", sFileName););

    MyContentReadFile(&hCnt5, sFileName, &pSampleTextureData, &Allocator2, &Allocator1);
    GXInitTexObj   (&toSample, pSampleTextureData, GAME_TEXTURE_WIDTH, GAME_TEXTURE_HEIGHT, GX_TF_RGB565, GX_CLAMP, GX_CLAMP, GX_FALSE);
    GXInitTexObjLOD(&toSample, GX_NEAR, GX_NEAR, 0, 0, 0, GX_FALSE, GX_FALSE, GX_ANISO_1);
}

/*---------------------------------------------------------------------------*
    Name:         MyDrawInit
*---------------------------------------------------------------------------*/
void MyDrawInit()
{
    Mtx44  proj;
    GXColor clrBlack = {   0,   0,   0, 255 };

    verbose(OSReport("MyDrawInit\n"););
    GXSetProjection(proj, GX_ORTHOGRAPHIC);

    // Vertex Attribute
    GXSetVtxAttrFmt(GX_VTXFMT1, GX_VA_POS, GX_POS_XYZ, GX_S16, 0);
    GXSetVtxAttrFmt(GX_VTXFMT1, GX_VA_TEX0, GX_TEX_ST, GX_S16, 8);
    GXSetVtxAttrFmt(GX_VTXFMT1, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0);
    // Z compare, pixel format and background color
    GXSetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);

    GXSetAlphaUpdate(GX_ENABLE);
    // Set number of tev stages, tex coord generators and color channels
    GXSetNumTevStages(1);
    GXSetNumTexGens(1);
    GXSetNumChans(0); // 1, Done
    GXSetCopyClear(clrBlack, 0x00FFFFFF);
}

/*---------------------------------------------------------------------------*
    Name:         SetupTexture
*---------------------------------------------------------------------------*/
void SetupTexture(const GXTexObj *pTexObj, GXColor clr)
{
    GXClearVtxDesc();
    GXInvalidateVtxCache();
    GXInvalidateTexAll();
    GXSetVtxDesc(GX_VA_POS , GX_DIRECT);
    GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT);
    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS , GX_POS_XYZ, GX_F32, 0);
    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST , GX_U8 , 0);
    GXSetNumChans(0);
    GXSetNumTexGens(1);
    GXSetNumIndStages(0);
    GXSetNumTevStages(1);
    GXSetTevDirect( GX_TEVSTAGE0);
    GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO  , GX_CC_C0 , GX_CC_TEXC , GX_CC_ZERO);
    GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO  , GX_CA_A0 , GX_CA_TEXA , GX_CA_ZERO);
    GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD  , GX_TB_ZERO , GX_CS_SCALE_1 , GX_TRUE , GX_TEVPREV);
    GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD  , GX_TB_ZERO , GX_CS_SCALE_1 , GX_TRUE , GX_TEVPREV);
    GXSetTevOrder(  GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0 , GX_COLOR_NULL);
    GXSetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0 , GX_IDENTITY);
    GXSetColorUpdate(GX_ENABLE);
    GXSetAlphaUpdate(GX_ENABLE);
    GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
    GXSetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
    GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);
    GXSetCullMode(GX_CULL_NONE);
    GXSetClipMode(GX_CLIP_ENABLE);
    GXLoadTexObj(pTexObj, GX_TEXMAP0);
    GXSetTevColor(GX_TEVREG0, clr);
}

/*---------------------------------------------------------------------------*
    Name:         DrawAxisAlignedRect
*---------------------------------------------------------------------------*/
void DrawAxisAlignedRect(const RectF32 *pRect)
{
    GXBegin(GX_QUADS, GX_VTXFMT0 , 4);
    GXPosition3f32(pRect->left , pRect->top   , 0); GXTexCoord2u8(0, 0);
    GXPosition3f32(pRect->left , pRect->bottom, 0); GXTexCoord2u8(0, 1);
    GXPosition3f32(pRect->right, pRect->bottom, 0); GXTexCoord2u8(1, 1);
    GXPosition3f32(pRect->right, pRect->top   , 0); GXTexCoord2u8(1, 0);
    GXEnd();
}

/*---------------------------------------------------------------------------*
    Name:         SetupColorOnly
*---------------------------------------------------------------------------*/
void SetupColorOnly(GXColor clr)
{
    GXClearVtxDesc();
    GXInvalidateVtxCache();
    GXInvalidateTexAll();
    GXSetVtxDesc(GX_VA_POS , GX_DIRECT);
    GXSetVtxDesc(GX_VA_CLR0, GX_DIRECT);
    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS , GX_POS_XYZ , GX_F32  , 0);
    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGBA8, 0);

    GXSetNumChans(1);
    GXSetNumTexGens(0);
    GXSetNumIndStages(0);
    GXSetNumTevStages(1);

    GXSetTevDirect( GX_TEVSTAGE0);
    GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_C0, GX_CC_RASC, GX_CC_ZERO);
    GXSetTevAlphaIn(GX_TEVSTAGE0, GX_CA_ZERO, GX_CA_A0, GX_CA_RASA, GX_CA_ZERO);
    GXSetTevColorOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
    GXSetTevAlphaOp(GX_TEVSTAGE0, GX_TEV_ADD, GX_TB_ZERO, GX_CS_SCALE_1, GX_TRUE, GX_TEVPREV);
    GXSetTevOrder(  GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);

    GXSetChanCtrl(GX_COLOR0A0, GX_DISABLE, GX_SRC_VTX, GX_SRC_VTX, GX_LIGHT_NULL, GX_DF_CLAMP, GX_AF_NONE);

    GXSetColorUpdate(GX_ENABLE);
    GXSetAlphaUpdate(GX_ENABLE);
    GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_SET);
    GXSetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);
    GXSetAlphaCompare(GX_ALWAYS, 0, GX_AOP_OR, GX_ALWAYS, 0);

    GXSetCullMode(GX_CULL_NONE);
    GXSetClipMode(GX_CLIP_ENABLE);

    GXSetTevColor(GX_TEVREG0, clr);
}

/*---------------------------------------------------------------------------*
    Name:         DrawColorRect
*---------------------------------------------------------------------------*/
void DrawColorRect(const RectF32 *pRect)
{
    GXBegin(GX_QUADS, GX_VTXFMT0, 4);
    GXPosition3f32(pRect->left , pRect->top   , 0); GXColor1u32(0xffffffff);
    GXPosition3f32(pRect->left , pRect->bottom, 0); GXColor1u32(0xffffffff);
    GXPosition3f32(pRect->right, pRect->bottom, 0); GXColor1u32(0xffffffff);
    GXPosition3f32(pRect->right, pRect->top   , 0); GXColor1u32(0xffffffff);
    GXEnd();
}

/*---------------------------------------------------------------------------*
    Name:         DrawTexture
*---------------------------------------------------------------------------*/
void DrawTexture(const RectF32 *pRect, const GXTexObj *pTexObj, GXColor color)
{
    SetupTexture(pTexObj, color);
    DrawAxisAlignedRect(pRect);
}

/*---------------------------------------------------------------------------*
    Name:         CompensateForModeChange
*---------------------------------------------------------------------------*/
void CompensateForModeChange(void)
{
    // This function is used to ensure the game always covers the same part of the screen even when
    // the render mode is changed, as happens during HBM display and the fade out of VCMV.
    f32 rExpandX = 0.5f * (((f32)(pCurrentRenderMode->viWidth * nCurrentEfbRenderWidth * GAME_HARDWARE_WIDTH) / (f32)(nGameViWidth * pCurrentRenderMode->fbWidth)) - (f32)GAME_HARDWARE_WIDTH);
    f32 rExpandY = (f32)((pCurrentRenderMode->viHeight - GAME_VI_HEIGHT) * GAME_HARDWARE_HEIGHT) / (f32)(2 * GAME_VI_HEIGHT);

    GXSetViewport(0.0f, 0.0f, (f32)nCurrentEfbRenderWidth, (f32)pCurrentRenderMode->efbHeight, 0.0f, 1.0f);
    GXSetScissor(0, 0, (u32)nCurrentEfbRenderWidth, (u32)pCurrentRenderMode->efbHeight);

    verbose(
        if (pPreviousRenderMode != pCurrentRenderMode) {
            OSReport("\n");
            OSReport("pCurrentRenderMode->viWidth=%d\n", pCurrentRenderMode->viWidth);
            OSReport("nCurrentEfbRenderWidth=%d\n", nCurrentEfbRenderWidth);
            OSReport("pCurrentRenderMode->fbWidth=%d\n", pCurrentRenderMode->fbWidth);
            OSReport("pCurrentRenderMode->viHeight=%d\n", pCurrentRenderMode->viHeight);
            OSReport("GAME_VI_HEIGHT=%d\n", GAME_VI_HEIGHT);
            OSReport("GAME_HARDWARE_HEIGHT=%d\n", GAME_HARDWARE_HEIGHT);
            OSReport("\n");
            OSReport("             %3d   %3d\n", pCurrentRenderMode->viWidth, nCurrentEfbRenderWidth);
            OSReport("rExpandX = ( --- x --- - 1.0 ) * %3d * 0.5 == %.1f\n", GAME_HARDWARE_WIDTH, rExpandX);
            OSReport("             %3d   %3d\n", nGameViWidth, pCurrentRenderMode->fbWidth);
            OSReport("\n");
            OSReport("            %3d\n", GAME_HARDWARE_HEIGHT);
            OSReport("rExpandY =  --- x ( %3d - %3d ) * 0.5 == %.1f\n", pCurrentRenderMode->viHeight, GAME_VI_HEIGHT, rExpandY);
            OSReport("            %3d\n", GAME_VI_HEIGHT);
            OSReport("\n");
            OSReport("GXSetViewport(0, 0, %d, %d, 0, 1)\n", nCurrentEfbRenderWidth, pCurrentRenderMode->efbHeight);
            OSReport("GXSetScissor(0, 0, %d, %d)\n", (u32)nCurrentEfbRenderWidth, (u32)pCurrentRenderMode->efbHeight);
        }
    );

    rectGameEfb.top    = -rExpandY;
    rectGameEfb.bottom =  rExpandY + GAME_HARDWARE_HEIGHT;

    rectGameEfb.left  = -rExpandX;
    rectGameEfb.right =  rExpandX + GAME_HARDWARE_WIDTH;

    if (pCurrentRenderMode != pRmGame) {
        s32 nTweakIdx=0;

        for(; nTweakIdx<C_nNumTweakEntries; nTweakIdx++) {
            TweakEntry *te = &aTweakTbl[nTweakIdx];
            if ((te->nGameXFB == pRmGame->fbWidth) &&
                (te->nGameVI  == pRmGame->viWidth) &&
                (te->nCurrentXFB  == pCurrentRenderMode->fbWidth) &&
                (te->nCurrentVI   == pCurrentRenderMode->viWidth))
            {
                verbose(OSReport("Using Tweak: %.1f + GlobalAdjust:%.1f\n", te->rTweakR, rGlobalAdjustRightCoord););
                rectGameEfb.right -= te->rTweakR + rGlobalAdjustRightCoord;

                goto Done;
            }
        }

        verbose(OSReport("Using GlobalAdjust: %.1f\n", rGlobalAdjustRightCoord););
        rectGameEfb.right -= rGlobalAdjustRightCoord;
    }

Done:
    MTXOrtho(mGameProjectionMtx, rectGameEfb.top, rectGameEfb.bottom, rectGameEfb.left, rectGameEfb.right, 0.0f, -1.0f);
}

/*---------------------------------------------------------------------------*
    Name:         GameDrawTick
*---------------------------------------------------------------------------*/
void GameDrawTick(void)
{
    GXColor clrGrey;
    GXColor clrBlack = {   0,   0,   0, 255 };

    RectF32 rectGame = { 0, 0, GAME_HARDWARE_WIDTH, GAME_HARDWARE_HEIGHT };
    // Adjust the left and right coordinates of the game display area to compensate
    // for the display width changing while displaying the HBM / Manual Viewer
    GXInvalidateVtxCache();
    GXInvalidateTexAll();

    if (pPreviousRenderMode != pCurrentRenderMode) {
        CompensateForModeChange();
        verbose(OSReport("MTXOrtho(proj, %.1f, %.1f, %.1f, %.1f, 0.0f, -1.0f)\n",
            rectGameEfb.top, rectGameEfb.bottom, rectGameEfb.left, rectGameEfb.right);
        );
        GXSetDispCopySrc(0, 0, (u16)nCurrentEfbRenderWidth, pCurrentRenderMode->efbHeight);
        GXSetDispCopyDst(pCurrentRenderMode->fbWidth, pCurrentRenderMode->xfbHeight);
        GXSetDispCopyYScale(GXGetYScaleFactor(pCurrentRenderMode->efbHeight, pCurrentRenderMode->xfbHeight));
        GXSetCopyFilter(pCurrentRenderMode->aa, pCurrentRenderMode->sample_pattern, GX_TRUE, pCurrentRenderMode->vfilter);
        GXSetCopyClear(clrBlack, 0x00FFFFFF);   // Ensure the borders around the game image are black
        GXCopyDisp(apXFB[nDisplayXFB^1], GX_ENABLE);  // Clear the EFB when the resolution changes
        pPreviousRenderMode = pCurrentRenderMode;
        *((u32*)apXFB[0]) = 0x12345678; // Magic number used to indicate XFB needs to be cleared before copyout
        *((u32*)apXFB[1]) = 0x12345678;
        verbose(
            OSReport("GXSetDispCopySrc(0, 0, %d, %d)\n", nCurrentEfbRenderWidth, pCurrentRenderMode->efbHeight);
        OSReport("GXSetDispCopyDst(%d, %d)\n", pCurrentRenderMode->fbWidth, pCurrentRenderMode->xfbHeight);
        OSReport("pCurrentRenderMode->Width = %d\n", pCurrentRenderMode->fbWidth);
        );
    }

    GXSetProjection(mGameProjectionMtx, GX_ORTHOGRAPHIC);

    // Perform the normal game rendering here
    GXSetNumTexGens(1);   // Generate 1 texture coordinate for TEV: GX_TEXCOORD0
    GXSetNumChans(0);     // Generate 0 color channels
    GXSetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX3x4, GX_TG_TEX0, GX_IDENTITY);

    GXSetNumTevStages(1);
    GXSetTevOp(GX_TEVSTAGE0, GX_REPLACE);
    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL);

    GXClearVtxDesc();
    GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
    GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT);

    clrGrey.r = clrGrey.g = clrGrey.b = nGameFadeBrightnessLevel;
    clrGrey.a = 255;
    DrawTexture(&rectGame, &toSample, clrGrey);
}

/*---------------------------------------------------------------------------*
    Name:         MyDrawDone
*---------------------------------------------------------------------------*/
void MyDrawDone(void)
{
    s32 nXFBLeftOffset = (s32)(pCurrentRenderMode->fbWidth - nCurrentEfbRenderWidth);

    if (nXFBLeftOffset&15) {
        OSHalt(".");
    }

    nDisplayXFB ^= 1;

    if (*((u32*)apXFB[nDisplayXFB]) == 0x12345678) {
        ClearYUV(apXFB[nDisplayXFB],nMaxXfbSize);
        //ClearBorderYUV(apXFB[nDisplayXFB]); // Clear the XFB after a mode change
    }

    GXCopyDisp((void*)((u32)apXFB[nDisplayXFB] + nXFBLeftOffset), GX_ENABLE);
    GXDrawDone();
    // VI Configure is done here to ensure there is no garbled frame when switching between
    // the HBM / Manual Viewer resolution and the Game resolution.
    VIConfigure(pCurrentRenderMode);
    VISetNextFrameBuffer(apXFB[nDisplayXFB]);
    VIFlush();
    //verbose(OSReport("VBL(%d) ", nGameFadeBrightnessLevel););
    VIWaitForRetrace();
}

//============================================================================
// MANUAL VIEWER FUNCTIONS
//============================================================================
/*---------------------------------------------------------------------------*
    Name:         MyLoadManualData
*---------------------------------------------------------------------------*/
void MyLoadManualData(void)
{
    const char * const ARC_PATH =
#if   defined REGION_JPN
        "html/JPN.arc";
#elif defined REGION_EUR
        "html/EUR.arc";
#elif defined REGION_KOR
        "html/KOR.arc";
#elif defined REGION_CHN
        "html/CHN.arc";
#else
        "html/USA.arc";
#endif

    u32 nSize = MyContentReadFile(&hCnt5, ARC_PATH, &pManualData, &Allocator2, &Allocator1);

#if USE_MEMORY_PROTOCOL
    VCMVSetMemoryContentsArcAddress(pManualData);
#else
    // Write out html.arc to nand flash /tmp/html.arc
    NANDFileInfo nfi;
    NANDCreate("/tmp/html.arc", NAND_PERM_OWNER_READ|NAND_PERM_OWNER_WRITE, 0);
    NANDOpen("/tmp/html.arc", &nfi, NAND_ACCESS_WRITE);
    NANDWrite(&nfi, pManualData, nSize);
    NANDClose(&nfi);
    MyFreeMem2(pManualData);
#endif
}

/*---------------------------------------------------------------------------*
    Name:         MyVcmvDoneRenderCallback
*---------------------------------------------------------------------------*/
void MyVcmvDoneRenderCallback(u8 nFadeIn, const GXRenderModeObj *pRm)
{
#if GAME_SUPPORTS_NON_INTERLACE
    if (bNonInterlaceFlag != (BOOL)((~bProgressiveFlag) & VCMVGetNonInterlaceFlag())) {
        // User toggled Non-Interlace flag during VCMV
        verbose(OSReport("bNonInterlaceFlag changed: %d->%d\n", (s32)bNonInterlaceFlag, (s32)((~bProgressiveFlag)&VCMVGetNonInterlaceFlag())););
        MyUpdateRenderModes();
    }
#endif

    pCurrentRenderMode = pRm;

    if (pPreviousRenderMode != pCurrentRenderMode) {
        // The user has changed the 16:9 stretch/squash mode during VCMV (Nunchuck 'Z' + Wii Remote 'A' + 'B')
        verbose(OSReport("pPreviousRenderMode: %p!=%p\n", pPreviousRenderMode, pCurrentRenderMode););
        MyUpdateRenderModes();
        nCurrentEfbRenderWidth = pCurrentRenderMode->fbWidth;
        CompensateForModeChange();
        GXSetDispCopySrc(0, 0, pCurrentRenderMode->fbWidth, pCurrentRenderMode->efbHeight);
        GXSetDispCopyDst(pCurrentRenderMode->fbWidth, pCurrentRenderMode->xfbHeight);
        GXSetDispCopyYScale(GXGetYScaleFactor(pCurrentRenderMode->efbHeight, pCurrentRenderMode->xfbHeight));
        GXSetCopyFilter(pCurrentRenderMode->aa, pCurrentRenderMode->sample_pattern, GX_TRUE, pCurrentRenderMode->vfilter);
        pPreviousRenderMode = pCurrentRenderMode;
        *((u32*)apXFB[0]) = 0x12345678; // Magic Number
        *((u32*)apXFB[1]) = 0x12345678;
        verbose(
            OSReport("GXSetDispCopySrc(0, 0, %d, %d)\n", nCurrentEfbRenderWidth, pCurrentRenderMode->efbHeight);
        OSReport("GXSetDispCopyDst(%d, %d)\n", pCurrentRenderMode->fbWidth, pCurrentRenderMode->xfbHeight);
        OSReport("pCurrentRenderMode->Width = %d\n", pCurrentRenderMode->fbWidth);
        );
    }

    if (nFadeIn) {
        // FadeIn ramps from 0->255 as the Manual Viewer closes
        GXColor clrBlackAlpha;
        clrBlackAlpha.r = clrBlackAlpha.g = clrBlackAlpha.b = 0;    clrBlackAlpha.a = nFadeIn;
        verbose(OSReport("nFadeIn=%d\n", (s32)nFadeIn););
        GXSetProjection(mGameProjectionMtx, GX_ORTHOGRAPHIC);

        if (bNonInterlaceFlag) {
            // Fade out the VCMV by blending the EFB with a Black rectangle using the Alpha value
            RectF32 rect;
            rect.left   = -150;
            rect.top    = -150;
            rect.right  = GAME_HARDWARE_WIDTH+150;
            rect.bottom = GAME_HARDWARE_HEIGHT+150;
            SetupColorOnly(clrBlackAlpha);
            DrawColorRect(&rect);
        } else {
            // Fade in the game by blending the game texture with the EFB using the Alpha value
            RectF32 rect;
            GXColor clrGreyAlpha;
            clrGreyAlpha.r = clrGreyAlpha.g = clrGreyAlpha.b = nGameFadeBrightnessLevel;  clrGreyAlpha.a = nFadeIn;
            rect.left=0; rect.right=GAME_HARDWARE_WIDTH; rect.top=0; rect.bottom=GAME_HARDWARE_HEIGHT;
            DrawTexture(&rect, &toSample, clrGreyAlpha);
            // Fade out the borders around the game by blending with Black rectangles using the Alpha value
            SetupColorOnly(clrBlackAlpha);
            rect.left=-150; rect.right=GAME_HARDWARE_WIDTH+150; rect.top=-150; rect.bottom=0;
            DrawColorRect(&rect);
            rect.left=-150; rect.right=0; rect.top=0; rect.bottom=GAME_HARDWARE_HEIGHT;
            DrawColorRect(&rect);
            rect.left=GAME_HARDWARE_WIDTH; rect.right=GAME_HARDWARE_WIDTH+150; rect.top=-150; rect.bottom=GAME_HARDWARE_HEIGHT;
            DrawColorRect(&rect);
            rect.left=-150; rect.right=GAME_HARDWARE_WIDTH+150; rect.top=GAME_HARDWARE_HEIGHT; rect.bottom=GAME_HARDWARE_HEIGHT+150;
            DrawColorRect(&rect);
        }
    }

    // Copy out, and switch VI to display the new XFB
    GXSetDispCopySrc(0, 0, pCurrentRenderMode->fbWidth, pCurrentRenderMode->efbHeight);
    GXSetDispCopyDst(pCurrentRenderMode->fbWidth, pCurrentRenderMode->xfbHeight);
    GXSetDispCopyYScale(GXGetYScaleFactor(pCurrentRenderMode->efbHeight, pCurrentRenderMode->xfbHeight));
    nDisplayXFB ^= 1;
    GXCopyDisp((void*)((u32)apXFB[nDisplayXFB]), GX_ENABLE);
    GXDrawDone();
    VIConfigure(pCurrentRenderMode);
    VISetNextFrameBuffer(apXFB[nDisplayXFB]);
    VIFlush();
    VIWaitForRetrace();  // Render thread will yield during this call
}

/*---------------------------------------------------------------------------*
    Name:         UpdateInitialFocusController
*---------------------------------------------------------------------------*/
void UpdateInitialFocusController(void)
{
    u8 nI;

    for(nI=0; nI<WPAD_MAX_CONTROLLERS; nI++) {

        if (VCMV_HBMControllerData.wiiCon[nI].kpad) {

            if (VCMV_HBMControllerData.wiiCon[nI].use_devtype == WPAD_DEV_CORE) {
                if (VCMV_HBMControllerData.wiiCon[nI].kpad->trig & KPAD_BUTTON_A) {
                    nInitialFocusController = nI;
                }
            } else {
                if (VCMV_HBMControllerData.wiiCon[nI].kpad->ex_status.cl.trig & KPAD_CL_BUTTON_A) {
                    nInitialFocusController = nI;
                }
            }
        }
    }
}

/*---------------------------------------------------------------------------*
    Name:         RunManualViewer
*---------------------------------------------------------------------------*/
void RunManualViewer(void)
{
    s32 nHeapSize = 20 * 1024 * 1024;

    if (pCurrentURL==0) {
        pCurrentURL = pTopPageURL;
    }

    pCurrentRenderMode = pRmManual;
    nCurrentEfbRenderWidth = pCurrentRenderMode->fbWidth;
    VIConfigure(pCurrentRenderMode);
    VIFlush();

#if IGNORE_TV_ASPECT_RATIO
    VCMVSetRenderModes(pRmManualNormal, pRmManualNormal, GAME_SUPPORTS_NON_INTERLACE & ~bProgressiveFlag);
    VCMVAllocateRenderingBuffers(BROWSER_FB_WIDTH, BROWSER_FB_HEIGHT);
#else
    if (nTVAspectRatio == SC_ASPECT_RATIO_4x3) {
        VCMVSetRenderModes(pRmManualNormal, pRmManualNormal, GAME_SUPPORTS_NON_INTERLACE & ~bProgressiveFlag);
        VCMVAllocateRenderingBuffers(BROWSER_FB_WIDTH, BROWSER_FB_HEIGHT);
    } else {
        VCMVSetRenderModes(pRmManualWide, pRmManualWide, GAME_SUPPORTS_NON_INTERLACE & ~bProgressiveFlag);
        VCMVAllocateRenderingBuffers(W_BROWSER_FB_WIDTH, BROWSER_FB_HEIGHT);
    }
#endif

    VCMVSetScrollBarWidth(12);

    for(;nHeapSize>0; nHeapSize-=1024*1024) {
        if (VCMVAllocateHeap((u32)nHeapSize)) {
            break;
        }
    }

    verbose(OSReport("HeapSize = %p\n", nHeapSize););

    if (nHeapSize <= 0) {
        OSHalt(".");
    }

    VCMVSetTopPageURL(pTopPageURL);

    verbose(
       OSReport("FreeMem  Mem1=%p Mem2=%p\n",
        MEMGetAllocatableSizeForExpHeapEx((MEMHeapHandle)Allocator1.pHeap, 32),
        MEMGetAllocatableSizeForExpHeapEx((MEMHeapHandle)Allocator2.pHeap, 32));
    );

    verbose(OSReport("VCMVRun(\"%s\", %d)\n", pCurrentURL, nInitialFocusController););

    pCurrentURL = VCMVRun(MyVcmvDoneRenderCallback, pCurrentURL, nInitialFocusController);
    MyUpdateRenderModes();
    nCurrentEfbRenderWidth = nGameEfbWidth;
    verbose(OSReport("Final URL: \"%s\"\n", pCurrentURL););

    verbose(
       OSReport("FreeMem  Mem1=%p Mem2=%p\n",
        MEMGetAllocatableSizeForExpHeapEx((MEMHeapHandle)Allocator1.pHeap, 32),
        MEMGetAllocatableSizeForExpHeapEx((MEMHeapHandle)Allocator2.pHeap, 32));
    );
}

/*---------------------------------------------------------------------------*
    Name:         MyInitializeManualViewer
*---------------------------------------------------------------------------*/
void MyInitializeManualViewer(void *)
{
    // This function can be registered as the idle function in order to
    // load initialize the Manual Viewer in the background.
    verbose(OSReport("MyInitializeManualViewer\n"););
    VCMVAllocateAndLoadBrowserComponent(BROWSER_RSO_CIDX, FONT_CIDX);
    MyLoadManualData();
}

/*---------------------------------------------------------------------------*
    Name:         MyCloseManualViewer
*---------------------------------------------------------------------------*/
void MyCloseManualViewer(void)
{
    verbose(OSReport("MyCloseManualViewer\n"););
    VCMVFreeRenderingBuffers();
    VCMVFreeHeap();
#if USE_MEMORY_PROTOCOL
    VCMVFreeAndClearPointer(&pManualData);
#endif
    VCMVCloseAndFreeBrowserComponent();
    verbose(OSReport("MyCloseManualViewer finished\n"););
}


//============================================================================
// HOME BUTTON BAN ICON FUNCTIONS
//============================================================================
/*---------------------------------------------------------------------------*
    Name:         ActivateBanIcon
*---------------------------------------------------------------------------*/
void ActivateBanIcon(void)
{
    sBanHbmIcon.nState  = eAlphaInIcon;
    sBanHbmIcon.bOnFlag = TRUE;
    sBanHbmIcon.nTime   = OSGetTick();
    sBanHbmIcon.nAlpha  = 0;
}

/*---------------------------------------------------------------------------*
    Name:         DrawBanIcon
*---------------------------------------------------------------------------*/
void DrawBanIcon(void)
{
    // �֎~�A�C�R���̕`��
    // Update & Draw HOME Button Menu "Ban Icon" (== temporarily unavailable icon)
    GXTexObj texObj;
    f32 elapse = OSTicksToMilliseconds(OSDiffTick(OSGetTick(), sBanHbmIcon.nTime));

    switch (sBanHbmIcon.nState) {
            case eAlphaInIcon: // AlphaIn(250ms)
                sBanHbmIcon.nAlpha = (u8)(255.9f * (elapse / 250.f));

                if (elapse >= 250.f) {
                    sBanHbmIcon.nTime  = OSGetTick();
                    sBanHbmIcon.nState = ePauseIcon;
                    sBanHbmIcon.nAlpha = 255;
                }

                break;
            case ePauseIcon: // Pause(1000ms)

                if (elapse >= 1000.f) {
                    sBanHbmIcon.nTime = OSGetTick();
                    sBanHbmIcon.nState = eAlphaOutIcon;
                }

                break;
            case eAlphaOutIcon: // AlphaOut(250ms)
                sBanHbmIcon.nAlpha = (u8)(255.9f * ((250.f - elapse) / 250.f));

                if (elapse >= 250.f) {
                    sBanHbmIcon.nAlpha  = 0;
                    sBanHbmIcon.bOnFlag = FALSE;
                }

                break;
    }

    GXClearVtxDesc();
    GXSetVtxAttrFmt(GX_VTXFMT5, GX_VA_POS,  GX_POS_XY, GX_S16, 0);
    GXSetVtxAttrFmt(GX_VTXFMT5, GX_VA_TEX0, GX_TEX_ST, GX_S16, 0);
    GXSetVtxDesc(GX_VA_POS,  GX_DIRECT);
    GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT);
    GXSetNumChans(1);
    GXSetChanCtrl(GX_COLOR0A0, GX_FALSE, GX_SRC_VTX, GX_SRC_VTX, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE);
    GXSetNumTexGens(1);
    GXSetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY);
    GXSetNumTevStages(1);
    GXSetTevColor(GX_TEVREG0, (GXColor){255, 255, 255, sBanHbmIcon.nAlpha});
    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR_NULL);
    GXSetTevColorIn(GX_TEVSTAGE0, GX_CC_ZERO, GX_CC_ZERO, GX_CC_ZERO, GX_CC_TEXC);
    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_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
    GXSetZMode(GX_FALSE, GX_LEQUAL, GX_FALSE);
    GXSetCurrentMtx(GX_PNMTX1);
    TPLGetGXTexObjFromPalette(sBanHbmIcon.pTpl, &texObj, 0);
    GXLoadTexObj(&texObj, GX_TEXMAP0);

    // The display position can be anywhere inside the guaranteed visible screen area (safety frame).
    // �`��ʒu�͈��S�t���[�����Ȃ�ǂ��ł��ǂ�
    {
        s16 nL = (s16)(( 48 * GAME_HARDWARE_WIDTH) / 608);
        s16 nR = (s16)((104 * GAME_HARDWARE_WIDTH) / 608);
        s16 nT = (s16)(( 40 * GAME_HARDWARE_HEIGHT) / 456);
        s16 nB = (s16)(( 96 * GAME_HARDWARE_HEIGHT) / 456);
        GXBegin(GX_QUADS, GX_VTXFMT5, 4);
        GXPosition2s16(nL, nB); GXTexCoord2s16(0, 1);
        GXPosition2s16(nL, nT); GXTexCoord2s16(0, 0);
        GXPosition2s16(nR, nT); GXTexCoord2s16(1, 0);
        GXPosition2s16(nR, nB); GXTexCoord2s16(1, 1);
        GXEnd();
    }
}

//============================================================================
// RESET FUNCTIONS
//============================================================================
/*---------------------------------------------------------------------------*
    Name:         ResetGame
*---------------------------------------------------------------------------*/
void ResetGame()
{
    // Note: The screen should already be BLACK when this function is called
    // ** TODO: Perform game soft reset here. **
    verbose(OSReport("GAME RESET.\n"););
    pCurrentRenderMode = pRmGame;
    nCurrentEfbRenderWidth = nGameEfbWidth;
    bResetButtonPressed = FALSE;
}

/*---------------------------------------------------------------------------*
    Name:         MyPowerButtonCallback
*---------------------------------------------------------------------------*/
void MyPowerButtonCallback(void)
{
    bCalledHBMBlackOut = FALSE;
    bPowerButtonPressed = TRUE;

    if (nHbmVcmvState == E_InVcmv) {
        VCMVBlackOutAndQuit(30);
        nGameFadeBrightnessLevel=0;  // To ensure VCMV fades out to Black in progressive mode
    }
}

/*---------------------------------------------------------------------------*
    Name:         MyResetButtonCallback
*---------------------------------------------------------------------------*/
void MyResetButtonCallback(void)
{
    bCalledHBMBlackOut = FALSE;
    bResetButtonPressed = TRUE;

    if (nHbmVcmvState == E_InVcmv) {
        VCMVBlackOutAndQuit(30);
        nGameFadeBrightnessLevel=0;  // To ensure VCMV fades out to Black in progressive mode
    }
}

//============================================================================
// CONTROLLER FUNCTIONS
//============================================================================
/*---------------------------------------------------------------------------*
    Name:         MyReadControllers
*---------------------------------------------------------------------------*/
void MyReadControllers(void)
{
    u8 nI;
#if FILTER_KPAD
    static u32 aOldHoldClassic[4][2];
    for(nI=0; nI<WPAD_MAX_CONTROLLERS; nI++) {
        KPADStatus *kps = VCMV_HBMControllerData.wiiCon[nI].kpad;

        if (kps) {
            // Replace the original KPAD so kpad.a can't tell we changed it
            kps->ex_status.cl.hold = aOldHoldClassic[nI][1];
        }
    }
#endif
    VCMVReadControllersForHBM();
    bAnyHomeButtonPressed = FALSE;

    for(nI=0; nI<WPAD_MAX_CONTROLLERS; nI++) {
        KPADStatus *kps = VCMV_HBMControllerData.wiiCon[nI].kpad;

        if (kps) {
#if IGNORE_TV_ASPECT_RATIO
            // Important Bug Fix! This is necessary otherwise the cursor X position will be
            // scaled incorrectly within the HBM in the case where IGNORE_TV_ASPECT_RATIO and
            // VCMVGetSquashFlag are both set. HBM Version 3.0.1 makes this problem more
            // noticable because the cursor cannot reach the edge of the screen.
            // The behaviour can be tested by using the vcmvmenu_*.wad tool to set the squash flag.
            if (VCMVGetSquashFlag()) {
                VCMV_HBMControllerData.wiiCon[nI].pos.x *= 1.3333;
                kps->pos.x *= 1.3333;
            }
#endif
#if FILTER_KPAD
            // Filter KPAD release signal to delay Home Button Release by one frame
            aOldHoldClassic[nI][1]    = kps->ex_status.cl.hold;
            kps->ex_status.cl.hold   |= kps->ex_status.cl.release & KPAD_CL_BUTTON_HOME;
            kps->ex_status.cl.trig    = kps->ex_status.cl.hold & ~aOldHoldClassic[nI][0];
            kps->ex_status.cl.release = ~kps->ex_status.cl.hold & aOldHoldClassic[nI][0];
            aOldHoldClassic[nI][0]    = kps->ex_status.cl.hold;
#endif
#if MANUALLY_ADJUSTED_TWEAK

            if (kps->trig & KPAD_BUTTON_RIGHT) {
                rGlobalAdjustRightCoord += 0.1f;
                OSReport("rGlobalAdjustRightCoord = %0.1f\n", rGlobalAdjustRightCoord);
            } else if (kps->trig & KPAD_BUTTON_LEFT) {
                rGlobalAdjustRightCoord -= 0.1f;
                OSReport("rGlobalAdjustRightCoord = %0.1f\n", rGlobalAdjustRightCoord);
            }
#endif
            // Wait for KPAD_BUTTON_1 after reset button is pressed. Then fade-in start screen again.
            if ((kps->trig==KPAD_BUTTON_1)&&(nHbmVcmvState==E_BlackOutTransition)&&(bResetButtonPressed==FALSE)) {
                VISetBlack(FALSE);
                VIFlush();
                nHbmVcmvState = E_ResartGameAfterResetTransition;
                OSSetResetCallback(MyResetButtonCallback);
            }

#if TEST_BAN_ICON
            if ((nHbmVcmvState==E_InGame) && !sBanHbmIcon.bOnFlag && (kps->trig==KPAD_BUTTON_PLUS)) {
                nHbmVcmvState = E_InGamePlusBanIcon;
                ActivateBanIcon();
            }
#endif
            if ((kps->trig&KPAD_BUTTON_HOME) ||
                ((kps->dev_type==WPAD_DEV_CLASSIC) && (kps->ex_status.cl.trig&KPAD_CL_BUTTON_HOME))) {
                    bAnyHomeButtonPressed = TRUE;
                    nInitialFocusController = nI;
            }
        }
    }
}


//============================================================================
// HOME BUTTON MENU RELATED
//============================================================================
/*---------------------------------------------------------------------------*
    Name:         MyHBMSoundCallback
*---------------------------------------------------------------------------*/
static int MyHBMSoundCallback(int evt, int arg)
{
#if GAME_INTERACED
#pragma unused(arg)
#else
    if ((evt == HBMSEV_PLAY_SOUND) && (arg == HBMSE_RETURN_APP)) {
        // If the game is using non-interlace mode, we need to fade to black before switching
        // back to non-interlace mode. In order to minimise the number of screen transitions,
        // we start fading to black at the same time as the user exits the home button menu.
        nTransitionFrame = 0;
        nHbmVcmvState = E_HbmToGameTransition;
    }
#endif
    //verbose(OSReport("SoundCallback: %d, %d\n", evt, arg););
#if INITIALIZE_IN_THREAD
    if (evt == HBMSEV_BEGIN_BLACKOUT_TO_MANUAL) {
        // Start initializing the manual viewer in the background
        verbose(OSReport("Starting Manual Viewer Initialization Thread\n"););
        VCMVAllocIfNecessary(&pMyVcmvInitThreadStack, C_nVcmvInitThreadStackSize, &Allocator1, &Allocator2);
        OSSetIdleFunction(MyInitializeManualViewer, 0, (void*)((u32)pMyVcmvInitThreadStack+C_nVcmvInitThreadStackSize),
            C_nVcmvInitThreadStackSize);
    }
#endif
    return HBMSEV_RET_NONE;
}

/*---------------------------------------------------------------------------*
    Name:         MyInitHomeButtonMenu
*---------------------------------------------------------------------------*/
void MyInitHomeButtonMenu(void)
{
#if HOME_BUTTON_MENU_3
    const char *pNandSoundFullPath = "/tmp/HBMSE.arc";
    char aSeFullPath[32] = "HomeButtonSe/";
    char *pSeFileName = &aSeFullPath[strlen(aSeFullPath)];
#else
    const char *pNandSoundFullPath = "/tmp/HBMSE.brsar";
#endif
    const char *pOperaIniFilesFullPath = "/tmp/opera.arc";
    char aFullPath[32] = "HomeButton3/";
    char *pFileName = &aFullPath[strlen(aFullPath)];

    CNTInitHandle(4, &hCnt4, &Allocator2);

#if HOME_BUTTON_MENU_3
    CNTInitHandle(6, &hCnt6, &Allocator2);
#endif
    if (!bTmpFilesCreated) {
        // The first time this function is run, copy the sound effects file to the NAND /tmp directory
        // where it can be accessed by the Home Button Menu library
        NANDFileInfo nfi;
        void *pTempBuf=0;   // VCMVAllocFrame
        u32 nSize;
        s32 nResult;
        bTmpFilesCreated = TRUE;
#if HOME_BUTTON_MENU_3
        strcpy(pSeFileName, "Huf8_HomeButtonSe.arc");
        nSize = MyContentReadFile(&hCnt6, aSeFullPath, (void **)&sound_data_ptr, &Allocator2, &Allocator1);
#else
        strcpy(pFileName, "Huf8_HomeButtonSe.brsar");
        nSize = MyContentReadFile(&hCnt4, aFullPath, &pTempBuf, &Allocator2, &Allocator1);
        nResult = NANDCreate(pNandSoundFullPath, NAND_PERM_OWNER_READ|NAND_PERM_OWNER_WRITE, 0);
        verbose(OSReport("NANDCreate: %d\n", nResult););
        nResult = NANDOpen(pNandSoundFullPath, &nfi, NAND_ACCESS_WRITE);
        verbose(OSReport("NANDOpen: %d\n", nResult););
        nResult = NANDWrite(&nfi, pTempBuf, nSize);
        verbose(OSReport("NANDWrite: %d\n", nResult););
        nResult = NANDClose(&nfi);
        verbose(OSReport("NANDClose: %d\n", nResult););
        VCMVFreeAndClearPointer(&pTempBuf);
#endif

        nSize = MyContentReadFile(&hCnt5, "Opera.arc", &pTempBuf, &Allocator2, &Allocator1);
        nResult = NANDCreate(pOperaIniFilesFullPath, NAND_PERM_OWNER_READ|NAND_PERM_OWNER_WRITE, 0);
        verbose(OSReport("NANDCreate: %d\n", nResult););
        nResult = NANDOpen(pOperaIniFilesFullPath, &nfi, NAND_ACCESS_WRITE);
        verbose(OSReport("NANDOpen: %d\n", nResult););
        nResult = NANDWrite(&nfi, pTempBuf, nSize);
        verbose(OSReport("NANDWrite: %d\n", nResult););
        nResult = NANDClose(&nfi);
        verbose(OSReport("NANDClose: %d\n", nResult););
        VCMVFreeAndClearPointer(&pTempBuf);
    }


#if USE_MEMORY_PROTOCOL
    strcpy(pTopPageURL, "arc:/html/");
#else
    strcpy(pTopPageURL, "file:/flash/tmp/html.arc/html/");
#endif
    pTopPage = &pTopPageURL[strlen(pTopPageURL)];


#if defined REGION_JPN

    // For JAPANESE releases:
    hbmInfo.region=SCGetLanguage();

    switch (hbmInfo.region) {
    case SC_LANG_KOREAN:
        OSHalt("Warning: Wrong Language Setting! \n");
        break;
    case SC_LANG_SIMP_CHINESE:
        OSHalt("Warning: Wrong Language Setting! \n");
        break;
    default:
    case SC_LANG_JAPANESE:
        strcpy(pFileName, "LZ77_homeBtn.arc");
        strcpy(pTopPage,  "index/index_Frameset.html");
        break;
    }

#elif defined REGION_EUR

    // For EUROPEAN releases:
    hbmInfo.region=SCGetLanguage();
    switch (hbmInfo.region) {
    case SC_LANG_GERMAN:
        strcpy(pFileName, "LZ77_homeBtn_GER.arc");
        strcpy(pTopPage,  "startup_noe.html");
        break;
    case SC_LANG_FRENCH:
        strcpy(pFileName, "LZ77_homeBtn_FRA.arc");
        strcpy(pTopPage,  "startup_fra.html");
        break;
    case SC_LANG_SPANISH:
        strcpy(pFileName, "LZ77_homeBtn_SPA.arc");
        strcpy(pTopPage,  "startup_esp.html");
        break;
    case SC_LANG_ITALIAN:
        strcpy(pFileName, "LZ77_homeBtn_ITA.arc");
        strcpy(pTopPage,  "startup_ita.html");
        break;
    case SC_LANG_DUTCH:
        strcpy(pFileName, "LZ77_homeBtn_NED.arc");
        strcpy(pTopPage,  "startup_hol.html");
        break;
    case SC_LANG_KOREAN:
        OSHalt("Warning: Wrong Language Setting! \n");
        break;
    case SC_LANG_SIMP_CHINESE:
        OSHalt("Warning: Wrong Language Setting! \n");
        break;
    default:
    case SC_LANG_ENGLISH:
        strcpy(pFileName, "LZ77_homeBtn_ENG.arc");
        strcpy(pTopPage,  "startup.html");
        break;
    }

#elif defined REGION_KOR

    // For KOREAN releases:
    hbmInfo.region=SCGetLanguage();

    switch (hbmInfo.region) {
    case SC_LANG_KOREAN:
        strcpy(pFileName, "LZ77_homeBtn_KOR.arc");
        strcpy(pTopPage,  "index/index_Frameset.html");
        break;
    default:
        OSHalt("Warning: Wrong Language Setting! \n");
    }

#elif defined REGION_CHN

    // For CHINESE releases:
    hbmInfo.region=SCGetLanguage();

    switch (hbmInfo.region) {
    case SC_LANG_SIMP_CHINESE:
        strcpy(pFileName, "LZ77_homeBtn_CHN.arc");
        strcpy(pTopPage,  "startup.html");
        break;
    case SC_LANG_TRAD_CHINESE:
        strcpy(pFileName, "LZ77_homeBtn_CHN.arc");
        strcpy(pTopPage,  "startup.html");
        break;
    default:
        OSHalt("Warning: Wrong Language Setting! \n");
    }

#else
    //#elif defined REGION_USA

    // For US releases:
    hbmInfo.region=SCGetLanguage();
    switch (hbmInfo.region) {
    case SC_LANG_FRENCH:
        strcpy(pFileName, "LZ77_homeBtn_FRA.arc");
        strcpy(pTopPage,  "startup_fra.html");
        break;
    case SC_LANG_SPANISH:
        strcpy(pFileName, "LZ77_homeBtn_SPA.arc");
        strcpy(pTopPage,  "startup_esp.html");
        break;
    case SC_LANG_KOREAN:
        OSHalt("Warning: Wrong Language Setting! \n");
        break;
    case SC_LANG_SIMP_CHINESE:
        OSHalt("Warning: Wrong Language Setting! \n");
        break;
    default:
    case SC_LANG_ENGLISH:
        strcpy(pFileName, "LZ77_homeBtn_ENG.arc");
        strcpy(pTopPage,  "startup.html");
        break;
    }

#endif

    verbose(OSReport("Language = %d\n", hbmInfo.region););
    MyContentReadFile(&hCnt4, aFullPath, &hbmInfo.layoutBuf, &Allocator2, &Allocator1);
    strcpy(pFileName, "Huf8_SpeakerSe.arc");
    MyContentReadFile(&hCnt4, aFullPath, &hbmInfo.spkSeBuf, &Allocator2, &Allocator1);
#ifdef HBM_NO_SAVE
    strcpy(pFileName, "home_nosave.csv");
#else
    strcpy(pFileName, "home.csv");
#endif

    MyContentReadFile(&hCnt5, pFileName, &hbmInfo.msgBuf, &Allocator2, &Allocator1);
    strcpy(pFileName, "config.txt");
    hbmInfo.configBufSize  = MyContentReadFile(&hCnt4, aFullPath, &hbmInfo.configBuf, &Allocator2, &Allocator1);
    hbmInfo.sound_callback = MyHBMSoundCallback;
    hbmInfo.backFlag       = 0;     // Make background half transparent, so the game pause screen can be seen through it
    hbmInfo.cursor         = 0;
    hbmInfo.adjust.x       = 832.f / 608.f;
    hbmInfo.adjust.y       = 1.0f;
    hbmInfo.frameDelta     = 1.0f;

    strcpy(pFileName, "homeBtnIcon.tpl");
    MyContentReadFile(&hCnt4, aFullPath, (void **)&sBanHbmIcon.pTpl, &Allocator2, &Allocator1);
    TPLBind(sBanHbmIcon.pTpl);

    hbmInfo.memSize = HBM_MEM_SIZE;
    VCMVAllocIfNecessary(&hbmInfo.mem, HBM_MEM_SIZE, &Allocator2, &Allocator1);
    hbmInfo.pAllocator = NULL;
    hbmInfo.messageFlag = 0;    // Set to HBMMSG_NOSAVE_WIIMENU if the game supports the Suspend feature.

    verbose(
    OSReport("HBMCreate(&hbmInfo)\n");
    OSReport("hbmInfo.layoutBuf = %p\n", hbmInfo.layoutBuf);
    OSReport("hbmInfo.spkSeBuf  = %p\n", hbmInfo.spkSeBuf);
    OSReport("hbmInfo.msgBuf    = %p\n", hbmInfo.msgBuf);
    OSReport("hbmInfo.configBuf = %p\n", hbmInfo.configBuf);
    OSReport("hbmInfo.mem       = %p\n", hbmInfo.mem);
    OSReport("hbmInfo.sound_callback = %p\n", hbmInfo.sound_callback);
    OSReport("hbmInfo.backFlag  = %p\n", hbmInfo.backFlag);
    OSReport("hbmInfo.region    = %p\n", hbmInfo.region);
    OSReport("hbmInfo.cursor    = %p\n", hbmInfo.cursor);
    OSReport("hbmInfo.memSize   = %p\n", hbmInfo.memSize);
    OSReport("hbmInfo.frameDelta= %.1f\n", hbmInfo.frameDelta);
    OSReport("hbmInfo.adjust.x  = %.1f\n", hbmInfo.adjust.x);
    OSReport("hbmInfo.adjust.y  = %.1f\n", hbmInfo.adjust.y);
    OSReport("hbmInfo.pAllocator= %p\n", hbmInfo.pAllocator);
    );

    VCMVSetHbmInfo(&hbmInfo);
    HBMCreate(&hbmInfo);
    verbose(OSReport("HBMCreateNandSound()\n"););
#if HOME_BUTTON_MENU_3
    VCMVAllocIfNecessary(&pHbmSoundInstanceBuf, HBM_MEM_SIZE_SOUND, &Allocator2, &Allocator1);
    HBMCreateSound(sound_data_ptr, pHbmSoundInstanceBuf, HBM_MEM_SIZE_SOUND);
    CNTReleaseHandle(&hCnt6);
#else
    VCMVAllocIfNecessary(&pHbmSoundInstanceBuf, HBM_MEM2_SIZE_NAND, &Allocator2, &Allocator1);
    HBMCreateNandSound(pNandSoundFullPath, pHbmSoundInstanceBuf, HBM_MEM2_SIZE_NAND);
#endif
    CNTReleaseHandle(&hCnt4);
}

/*---------------------------------------------------------------------------*
    Name:         SetupHbmGX
*---------------------------------------------------------------------------*/
void SetupHbmGX(void)
{
    // GX Initialization for the box cursors and Ban icon
    GXClearVtxDesc();
    GXSetVtxAttrFmt(GX_VTXFMT4, GX_VA_POS,  GX_POS_XY,  GX_F32, 0);
    GXSetVtxAttrFmt(GX_VTXFMT4, GX_VA_CLR0, GX_CLR_RGB, GX_RGB8, 0);
    GXSetVtxDesc(GX_VA_POS,  GX_DIRECT);
    GXSetVtxDesc(GX_VA_CLR0, GX_DIRECT);
    GXSetNumChans(1);
    GXSetNumTexGens(0);
    GXSetNumTevStages(1);
    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
    GXSetTevOp(GX_TEVSTAGE0, GX_PASSCLR);
    GXSetBlendMode(GX_BM_NONE, GX_BL_ZERO, GX_BL_ZERO, GX_LO_CLEAR);
    GXSetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
    GXSetCurrentMtx(GX_PNMTX1);
}

/*---------------------------------------------------------------------------*
    Name:         DrawBoxCursors
*---------------------------------------------------------------------------*/
void DrawBoxCursors(void)
{
    // Draw simple box cursors.
    s32 nI;
    for(nI=0; nI<PAD_MAX_CONTROLLERS; nI++) {
        if (VCMV_HBMControllerData.wiiCon[nI].kpad) {
            f32 rX = VCMV_HBMControllerData.wiiCon[nI].pos.x * 0.5f * nHbmEfbWidth;
            f32 rY = VCMV_HBMControllerData.wiiCon[nI].pos.y * 0.5f * HBM_EFB_HEIGHT;
            u8 nC = nGameFadeBrightnessLevel;
            GXBegin(GX_QUADS, GX_VTXFMT4, 4);
            GXPosition2f32(-6+rX, -6-rY); GXColor3u8(nC, nC, nC);
            GXPosition2f32(-6+rX,  6-rY); GXColor3u8(nC, nC, nC);
            GXPosition2f32( 6+rX,  6-rY); GXColor3u8(nC, nC, nC);
            GXPosition2f32( 6+rX, -6-rY); GXColor3u8(nC, nC, nC);
            GXEnd();
        }
    }
}

//===========================================================================
// MAIN PROGRAM
//===========================================================================
void Test(void)
{
    // Initialize
    VIInit();
    SCInit();
    while (SC_STATUS_OK!=SCCheckStatus()) {} // Wait for SCInit() to complete
    OSInitFastCast(); // Used by the Home Button Menu
    OSSetResetCallback(MyResetButtonCallback);
    OSSetPowerCallback(MyPowerButtonCallback);
    MyInitAllocators();
    WPADRegisterAllocator(MyAllocMem2, MyFreeMem2);
    VCMVRegisterAllocators(&Allocator1, &Allocator2);
    MyInitAudio();
    VISetBlack(TRUE);
    VIFlush();

    // Manual Viewer uses KPAD. Game application may or may not use KPAD.
    verbose(OSReport("KPADInit()\n"););

    KPADInit();
    {
        s32 nI;
        for(nI=0; nI<WPAD_MAX_CONTROLLERS; nI++) {
            KPADEnableAimingMode(nI);
        }
    }

    verbose(OSReport("PADInit()\n"););
    PADInit();
    MyInitDisplayMode();
    verbose(OSReport("MyInitGX()\n"););
    MyInitGX();
    VISetBlack(FALSE);
    VIFlush();

#ifdef NANDAPP
    verbose(OSReport("CNTInit() - NANDAPP\n"););
#else
    verbose(OSReport("CNTInit() - DVDAPP\n"););
#endif

    CNTInit();
    CNTInitHandle(5, &hCnt5, &Allocator2);
    LoadTexture();
    MyDrawInit();

    bHomeButtonMenu = FALSE;
    sBanHbmIcon.bOnFlag = FALSE;

    nHbmVcmvState = E_InGame;

    verbose(OSReport("MyInitHomeButtonMenu()\n"););
    MyInitHomeButtonMenu();

    {
        Mtx mv;
        MTXIdentity(mv);
        GXLoadPosMtxImm(mv, GX_PNMTX1);
    }

    if (nHbmAspectRatio) {
        HBMSetAdjustFlag(1); // 16:9
        rHbmGxHalfWidth = 416.0;
        nHbmViWidth = HBM_VI_WIDTH_WIDE;
    } else {
        HBMSetAdjustFlag(0); // 4:3
        rHbmGxHalfWidth = 304.0;
        nHbmViWidth = HBM_VI_WIDTH_NORMAL;
    }

    GXSetCullMode(GX_CULL_NONE);

    GXSetZMode(GX_FALSE, GX_ALWAYS, GX_FALSE);

    nGameFadeBrightnessLevel = 255;
    pCurrentRenderMode = pRmGame;

    while(1) {
        MyReadControllers();

        if (bResetButtonPressed || bPowerButtonPressed) {
            switch(nHbmVcmvState) {
                    case E_GameToHbmTransition2:
                    case E_HbmToGameTransition:
                    case E_InHbm: {

                        if (!bCalledHBMBlackOut) {
                            bCalledHBMBlackOut = TRUE;
                            HBMStartBlackOut();
                        }

                        break;
                                  }
                    default:
                        nHbmVcmvState = E_BlackOutTransition;
                        break;
            }
        }

        switch(nHbmVcmvState) {

                case E_InGamePlusBanIcon:
                    ASSERT(nHbmVcmvState == E_InGamePlusBanIcon);
                    verbose(OSReport("E_InGamePlusBanIcon\n"););

                    if (sBanHbmIcon.bOnFlag==FALSE) {
                        nHbmVcmvState = E_InGame;
                    }

                    break;

FadeInGameTransition:
                case E_FadeInGameTransition:
                    ASSERT(nHbmVcmvState == E_FadeInGameTransition);
                    verbose(OSReport("E_FadeInGameTransition: %d/%d\n", nTransitionFrame, nFadeInGameTransitionMaxFrame););
                    nTransitionFrame++;
                    nGameFadeBrightnessLevel = (u8)(nTransitionFrame * 255 / nFadeInGameTransitionMaxFrame);

                    if (nTransitionFrame < nFadeInGameTransitionMaxFrame) {
                        // Fade back up to normal brightness after switching to interlace mode
                        // Note: If the game is using interlace or progressive mode, set nFadeInGameTransitionMaxFrame=0
                        if (nTransitionFrame<=0) {
                            nGameFadeBrightnessLevel=0;

                            if (VIGetNextField()==VI_FIELD_ABOVE) {
                                pCurrentRenderMode = pRmGame;
                                nCurrentEfbRenderWidth = nGameEfbWidth;
                            }
                        }
                        break;
                    }
                    pCurrentRenderMode = pRmGame;
                    nCurrentEfbRenderWidth = nGameEfbWidth;
                    nTransitionFrame = 0;
                    nHbmVcmvState = E_InGame;
                    verbose(OSReport("E_InGame\n"););
                    GXInitTexObjLOD(&toSample, GX_NEAR, GX_NEAR, 0, 0, 0, GX_FALSE, GX_FALSE, GX_ANISO_1);
                    // no break, intentional fall-through

                case E_InGame:
                    ASSERT(nHbmVcmvState == E_InGame);
#if SIMULATE_GAME_MEMORY_USAGE
                    VCMVAllocIfNecessary((void**)&pGameMem1, GAME_MEM1_SIZE, &Allocator1, &Allocator1);
                    VCMVAllocIfNecessary((void**)&pGameMem2, GAME_MEM2_SIZE, &Allocator2, &Allocator2);
                    {
                        // Simulate some game code overwriting memory
                        int nI;
                        for(nI=0; nI<100000; nI++) {
                            pGameMem1[nGameMem1Idx]++;
                            pGameMem2[nGameMem2Idx]++;
                            nGameMem1Idx = (nGameMem1Idx+1)%GAME_MEM1_SIZE;
                            nGameMem2Idx = (nGameMem2Idx+1)%GAME_MEM2_SIZE;
                        }
                    }
#endif
                    nGameFadeBrightnessLevel = 255;

                    if (!bAnyHomeButtonPressed) {
                        break;
                    }

                    nTransitionFrame = 0;
#if SIMULATE_GAME_MEMORY_USAGE
                    VCMVFreeAndClearPointer((void**)&pGameMem1);
                    VCMVFreeAndClearPointer((void**)&pGameMem2);
#endif
                    nHbmVcmvState = E_GameToHbmTransition1;
                    GXInitTexObjLOD(&toSample, GX_LINEAR, GX_LINEAR, 0, 0, 0, GX_FALSE, GX_FALSE, GX_ANISO_1);
                    // no break, intentional fall-through

                case E_GameToHbmTransition1:
                    ASSERT(nHbmVcmvState == E_GameToHbmTransition1);
                    verbose(OSReport("E_GameToHbmTransition1: %d/%d\n", nTransitionFrame, nGameToHbmTransition1MaxFrame););
                    nTransitionFrame++;
                    nGameFadeBrightnessLevel = (u8)(255 - (nTransitionFrame * 255 / nGameToHbmTransition1MaxFrame));

                    if (nTransitionFrame < nGameToHbmTransition1MaxFrame) {
                        // Fade to black before switching from non-interlace mode to interlace mode
                        // Note: If the game is using interlace or progressive mode, set nGameToHbmTransition1MaxFrame=0
                        break;
                    }

                    HBMInit();
                    bHomeButtonMenu = TRUE;
                    nTransitionFrame = -BLACKOUT_TIME;
                    nHbmVcmvState = E_GameToHbmTransition2;
                    // no break, intentional fall-through

                case E_GameToHbmTransition2:
                    ASSERT(nHbmVcmvState == E_GameToHbmTransition2);
                    verbose(OSReport("E_GameToHbmTransition2: %d/%d\n", nTransitionFrame, nGameToHbmTransition2MaxFrame););
                    nTransitionFrame++;
                    nGameFadeBrightnessLevel = (u8)(nTransitionFrame * 255 / nGameToHbmTransition2MaxFrame);

                    if (nTransitionFrame < nGameToHbmTransition2MaxFrame) {
                        // Fade back up to normal brightness after switching to interlace mode
                        // Note: If the game is using interlace or progressive mode, set nGameToHbmTransition2MaxFrame=0
                        if (nTransitionFrame<=0) {
                            nGameFadeBrightnessLevel=0;
                            if (VIGetNextField()==VI_FIELD_ABOVE) {
                                pCurrentRenderMode = pRmHBM;
                                nCurrentEfbRenderWidth = nHbmEfbWidth;
                            }
                        }
                        // no break, intentional fall-through
                    } else {
                        nGameFadeBrightnessLevel = 255;
                        pCurrentRenderMode = pRmHBM;
                        nCurrentEfbRenderWidth = nHbmEfbWidth;
                        nTransitionFrame = 0;
                        nHbmVcmvState = E_InHbm;
                        // no break, intentional fall-through
                    }

InHbm:
                case E_InHbm:
                    UpdateInitialFocusController();

                    // Update Home Button Menu.  HOME�{�^�����j���[�X�V
                    if (HBMCalc(&VCMV_HBMControllerData) == HBM_SELECT_NULL) {
                        HBMUpdateSound();
                        break;
                    } else {
                        s32 nI;
                        verbose(OSReport("HBM finished: %d\n", HBMGetSelectBtnNum()););
                        for(nI=0; nI<WPAD_MAX_CONTROLLERS; nI++) {
                            WPADStopMotor(nI);
                        }
                        bHomeButtonMenu = FALSE;

                        switch(HBMGetSelectBtnNum()) {

                            case HBM_SELECT_BTN1:
                                goto ReturnToMenu;
                            case HBM_SELECT_BTN2:
                                nGameFadeBrightnessLevel=0; // HBM has already finished the BlackOut
                                bResetButtonPressed=TRUE;
#if INITIALIZE_IN_THREAD
                                if (OSGetIdleFunction()) {
                                    // This can happen if the user presses RESET after clicking the User-Manual button,
                                    // and before the HBM has fully faded out.
                                    goto ContinueVcmvInitialization;
                                }
#endif
                                goto BlackOutTransition;
                            case HBM_SELECT_BTN3:
                                // Initialize and Run the manual viewer
                                nHbmVcmvState = E_HbmToVcmvTransition;
#if INITIALIZE_IN_THREAD
                                verbose(OSReport("Waiting for Manual Viewer initialization to finish..\n"););
                                // The screen is already black at this point

ContinueVcmvInitialization:
                                while (OSGetIdleFunction()) {
                                    VIWaitForRetrace(); // Yields this thread to allow the initialization thread to continue
                                }

                                VCMVFreeAndClearPointer(&pMyVcmvInitThreadStack);
#else
                                MyInitializeManualViewer(0);
#endif
                                OSDisableInterrupts();

                                if (!(bResetButtonPressed || bPowerButtonPressed)) {
                                    verbose(OSReport("Running Manual Viewer\n"););
                                    nHbmVcmvState = E_InVcmv;
                                    RunManualViewer();
                                    verbose(OSReport("Manual Viewer Finished\n"););
                                } else {
                                    verbose(OSReport("Reset/Power pressed during VCMV Initialization\n"););
                                }

                                MyCloseManualViewer();
                                OSEnableInterrupts();
                                bHomeButtonMenu = FALSE;

                                // NOTE: We don't want the compiler to optimize this part, so bResetButtonPressed
                                //       and bPowerButtonPressed are declared as volatile
                                if (bResetButtonPressed || bPowerButtonPressed) {
                                    goto BlackOutTransition;
                                }

                                nTransitionFrame = -BLACKOUT_TIME;
                                nHbmVcmvState = E_FadeInGameTransition;
                                goto FadeInGameTransition;
                            case HBM_SELECT_HOMEBTN:
                                break;
                        }
                        nTransitionFrame = -BLACKOUT_TIME;
                        nHbmVcmvState = E_FadeInGameTransition;
                        goto FadeInGameTransition;
                    }
                    // no break, intentional fall-through

                case E_HbmToGameTransition:
                    ASSERT(nHbmVcmvState == E_HbmToGameTransition);
                    verbose(OSReport("E_HbmToGameTransition: %d/%d\n", nTransitionFrame, nHbmToGameTransitionMaxFrame););
                    nTransitionFrame++;

                    if (nTransitionFrame > nHbmToGameTransitionMaxFrame) {
                        nTransitionFrame = nHbmToGameTransitionMaxFrame;
                    }

                    if (nTransitionFrame < 10) {
                        nGameFadeBrightnessLevel = 255;
                    } else {
                        nGameFadeBrightnessLevel = (u8)(255 - ((nTransitionFrame-10) * 255 / (nHbmToGameTransitionMaxFrame-10)));
                    }

                    goto InHbm;

                case E_HbmToVcmvTransition:
                    ASSERT(nHbmVcmvState == E_HbmToVcmvTransition);
                    break;

BlackOutTransition:
                    nHbmVcmvState = E_BlackOutTransition;
                case E_BlackOutTransition:
                    ASSERT(nHbmVcmvState == E_BlackOutTransition);
                    verbose(OSReport("E_BlackOutTransition: %d\n", nGameFadeBrightnessLevel););

                    if (nGameFadeBrightnessLevel > 0) {
                        nGameFadeBrightnessLevel = (u8)((nGameFadeBrightnessLevel-4)&0xF8); // Fadeout in steps of 8, not 4
                    } else {
                        if (bPowerButtonPressed) {
                            goto ReturnToMenu;
                        }
                        if (bResetButtonPressed) {
                            ResetGame();
                            break;
                        }
                    }

                    break;

                case E_ResartGameAfterResetTransition:
                    ASSERT(nHbmVcmvState == E_ResartGameAfterResetTransition);

                    if (nGameFadeBrightnessLevel < 255) {
                        nGameFadeBrightnessLevel = (u8)((nGameFadeBrightnessLevel+4)|0x7); // Fadein in steps of 8, not 4
                    } else {
                        nHbmVcmvState = E_InGame;
                    }

                    break;

                default:
                    verbose(OSReport("Warning: unexpected nHbmVcmvState (%d)\n", nHbmVcmvState););
                    break;
        }

        GXInvalidateVtxCache();
        GXInvalidateTexAll();

        GameDrawTick();

        if (sBanHbmIcon.bOnFlag) {
            DrawBanIcon();
        }

        {
            Mtx44 projMtx;
            MTXOrtho(projMtx, HBM_EFB_HEIGHT*0.5f, -HBM_EFB_HEIGHT*0.5f, -rHbmGxHalfWidth, rHbmGxHalfWidth, 0.0f, 500.0f);
            GXSetProjection(projMtx, GX_ORTHOGRAPHIC);
            GXSetCullMode(GX_CULL_NONE);
            SetupHbmGX();

            if (bHomeButtonMenu) {
                HBMDraw();
            }

            if (!bHomeButtonMenu) {
                f32 rHalfWidth  = (f32)(pCurrentRenderMode->viWidth * nHbmEfbWidth) / (f32)(nHbmViWidth * 2);
                f32 rHalfHeight = (f32)(pCurrentRenderMode->viHeight * HBM_EFB_HEIGHT) / (f32)(HBM_VI_HEIGHT * 2);

                verbose(
                {
                    static u8 bFirst=1;

                    if (bFirst) {
                        bFirst=0;
                        OSReport("nGameViWidth=%d, nHbmEfbWidth=%d, nHbmViWidth=%d\n", nGameViWidth, nHbmEfbWidth, nHbmViWidth);
                        OSReport("pCurrentRenderMode->efbHeight=%d, viHeight=%d, HBM_EFB_HEIGHT=%d\n", pCurrentRenderMode->efbHeight, pCurrentRenderMode->viHeight, HBM_EFB_HEIGHT);
                        OSReport("nGameXfbWidth=%d, pCurrentRenderMode->fbWidth=%d\n", nGameXfbWidth, pCurrentRenderMode->fbWidth);
                        OSReport("rHalfWidth=%.1f, rHalfHeight=%.1f\n", rHalfWidth, rHalfHeight);
                    }
                }
                );

                MTXOrtho(projMtx, rHalfHeight, -rHalfHeight, -rHalfWidth, rHalfWidth, 0.0f, 500.0f);
                GXSetProjection(projMtx, GX_ORTHOGRAPHIC);
                DrawBoxCursors();
            }
        }
        MyDrawDone();
    }

ReturnToMenu:
    VCMVFreeAndClearPointer(&hbmInfo.mem);
    CNTReleaseHandle(&hCnt5);
    MyFreeMem2(apXFB[1]);
    MyFreeMem2(apXFB[0]);
    OSReport("End of VCMV + HBM Sample\n");
    OSReturnToMenu();

    {
        ARCHandle ah;
        ARCDir dir;
        ARCOpenDir(&ah, ".", &dir);
    }
}

void main(void) { Test(); }