/*---------------------------------------------------------------------------*
  Project:  Channel jump demo
  File:     ChannelJump.c

  Copyright (C) 2005-2006 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.
  
  $Log: ChannelJump.c,v $
  Revision 1.5  2008/05/30 02:27:03  seiki_masashi
  Rolled back changes to this file following an SDK rollback.

  Revision 1.3  2007/08/01 09:36:29  kitase_hirotake
  Changed TAB to SPACE.

  Revision 1.2  2007/07/31 23:50:12  nishimoto_takashi
  Revised slightly to avoid warnings.

  Revision 1.1  2007/07/30 01:17:38  nishimoto_takashi
  Initial check in.

  
  $NoKeywords: $
  
 *---------------------------------------------------------------------------*/


#include "ChannelJump.h"

/*-----------------------------------------------------------------------------
    Values
  -----------------------------------------------------------------------------*/
static MEMAllocator  s_mem2Allocator ;
static MEMHeapHandle s_handle ;

/*-----------------------------------------------------------------------------
    Functions
  -----------------------------------------------------------------------------*/
/*******************************************************************************
    Initialize memory (MEM2)
 *******************************************************************************/
static void init_memory2( void )
{
    void *lo = OSGetMEM2ArenaLo() ;
    void *hi = OSGetMEM2ArenaHi() ;
    s_handle = MEMCreateFrmHeap( lo, (u32)hi - (u32)lo ) ;
    if ( s_handle == MEM_HEAP_INVALID_HANDLE )
    {
        OSHalt("MEM2 heap allocation error.\n") ;
    }
    else
    {
        OSSetMEM2ArenaLo(hi) ;
        MEMInitAllocatorForFrmHeap( &s_mem2Allocator, s_handle, 32 ) ;   // Buffer requires 32-byte alignment.
    }
}

static void* alloc32( u32 size )
{
    return MEMAllocFromAllocator( &s_mem2Allocator, size ) ;

}

static u8 free32( void *addr )
{
    MEMFreeToAllocator( &s_mem2Allocator, addr ) ;
    return 1 ;
}

/*******************************************************************************
    Camera Setting
 *******************************************************************************/
static void SetupCamera( void )
{
    Mtx44 proj_mtx;
    MTXPerspective( proj_mtx, 45.f, 640.f / 480.f * 0.908f, 1.f, 100.f );
    GXSetProjection( proj_mtx, GX_PERSPECTIVE );
    
       MTXLookAt(View_Mtx, &(Vec){0.f, 3.f, 8.f}, &(Vec){0.f, 1.f, 0.f}, &(Vec){0.f, 0.f, 0.f});
}

/*******************************************************************************
    Render scene.
        DrawLines( void )        : Draw a grid pattern
        DrawRectangles( void )    : Use textures
        DrawBase( void )        : Use vertex color
 *******************************************************************************/
static void DrawLines( void );
static void DrawRectangles( void );
static void DrawBase( void );

static void DrawScene( void )
{
    Mtx mv;
    MTXIdentity(mv);
    MTXRotDeg(mv, 'y', Rot_Deg);
    
    MTXConcat(View_Mtx, mv, mv);
    GXLoadPosMtxImm(mv, GX_PNMTX0);
    
    switch(Scene_No) {
        case 0:
            DrawLines();
            break;
        case 1:
            DrawRectangles();
            break;
        case 2:
            DrawBase();
            break;
    }
}

/*******************************************************************************
    Set data ( set Scene_No as 8 bytes data)
 *******************************************************************************/
static void SetAttachedData()
{
    char data[5];

    switch(Scene_No) {
        case 1:
            (void)strcpy(data, "SCN1");
            break;
        case 2:
            (void)strcpy(data, "SCN2");
            break;
        default:
            (void)strcpy(data, "SCN0");
            break;
    }
    
    // Overwrite binary data in chjump.bin
    (void) memcpy(Template_arc_begin + 0x00000060 + 0x00000020, data, 4);

    OSReport("set data successfully.\n");
}

/*******************************************************************************
    Send a test message. (Channel Jump and data)
 *******************************************************************************/
static void PostMessage()
{
    NWC24Err        err;
    NWC24MsgObj     msgObj;
    NWC24UserId        testIdTo;
    
    // Initializes the object, specifies Wii-to-Wii message.
    err = NWC24InitMsgObj(&msgObj, NWC24_MSGTYPE_WII_MENU);
    if ( err != NWC24_OK )
    {
        OSReport("NWC24InitMsgObj(): error %d\n", err);
        return;
    }

    // To address (by user id)
    err = NWC24GetMyUserId(&testIdTo);
    if( err != NWC24_OK )
    {
        OSReport("NWC24GetMyUserId(): error %d\n", err);
        return;
    }
    
    err = NWC24SetMsgToId(&msgObj, testIdTo);
    if ( err != NWC24_OK )
    {
        OSReport("NWC24SetMsgToId(): error %d\n", err);
        return;
    }
    
    // Subject
    err = NWC24SetMsgSubject(&msgObj, MsgSubject, (u32)strlen(MsgSubject));
    if ( err != NWC24_OK )
    {
        OSReport("NWC24SetMsgSubject(): error %d\n", err);
        return;
    }
    
    // Message body (text)
    err = NWC24SetMsgText(&msgObj, (const char*)MsgText, (u32)sizeof(MsgText) - 2,
                          NWC24_UTF_16BE, NWC24_ENC_BASE64);
    if ( err != NWC24_OK )
    {
        OSReport("NWC24SetMsgText(): error %d\n", err);
        return;
    }
    
    // Edit chjump.bin file.
    SetAttachedData();
    
    // Attach a NWC24CHJumpObj.
    err = NWC24SetMsgAttached(&msgObj, (const char*)Template_arc_begin,
                             (u32)(Template_arc_end - Template_arc_begin), NWC24_APP_WII_MSGBOARD);
    if ( err != NWC24_OK )
    {
        OSReport("NWC24SetMsgAttached(): error %d\n", err);
        return;
    }
    
    // Set alternate name.
    MsgAltName[9] = (wchar_t)(L'0' + Scene_No);
    
    err = NWC24SetMsgAltName(&msgObj, (const u16*)MsgAltName, (u32)sizeof(MsgAltName) - 2);
    if ( err != NWC24_OK )
    {
        OSReport("NWC24SetMsgAltName(): error %d\n", err);
        return;
    }
    
    // Commit settings and post the message into the send box.
    err = NWC24CommitMsg(&msgObj);
    if ( err != NWC24_OK )
    {
        OSReport("NWC24CommitMsg: error %d\n", err);
        return;
    }
    
    OSReport("Posted a test message successfully.\n");
    
    return;
}

/*******************************************************************************
    Main
 *******************************************************************************/
void main(int argc, char * argv[])
{    
    NWC24Err    err;
    s32         tmp, count;
    char*        libWorkMem;
    
    // Initialize (KPAD, NWC24)
    DEMOInit(NULL);
    
    init_memory2();
    WPADRegisterAllocator( alloc32, free32 );
    KPADInit();
    
    VFInit();
    
    libWorkMem = MEMAllocFromAllocator(&s_mem2Allocator, NWC24_WORK_MEM_SIZE);
    
    if( NWC24_OK != ( err = NWC24OpenLib(libWorkMem)) ) 
    {
        OSReport("NWC24penLib() Error: %d\n", err);
        OSHalt("Failed.\n");
    }
    
    count = 0;
    Rot_Deg = 0;
    
    // output
    OSReport("*******************************************************\n");
    OSReport("Start Channel Jump demo.\n");
    OSReport("*******************************************************\n");
    
#ifdef _DEBUG
    OSReport("This is a DEBUG build.\n");
    OSReport("argc : %d\n", argc);
#else
    OSReport("This is a NON-DEBUG/optimized build.\n");
#endif // _DEBUG

    // texture
    GXInitTexObj( &TextureD, (void*)Default_tex, 8,  8, GX_TF_RGB5A3, GX_CLAMP, GX_CLAMP, GX_FALSE);
    GXInitTexObj( &Texture1, (void*)No1_tex, 16, 16, GX_TF_RGB5A3, GX_CLAMP, GX_CLAMP, GX_FALSE);
    GXInitTexObj( &Texture2, (void*)No2_tex, 16, 16, GX_TF_RGB5A3, GX_CLAMP, GX_CLAMP, GX_FALSE);
    
    GXInitTexObjLOD( &TextureD, GX_LINEAR, GX_LINEAR, 0.f, 0.f, 0.f, GX_FALSE, GX_FALSE, GX_ANISO_1);
    GXInitTexObjLOD( &Texture1, GX_LINEAR, GX_LINEAR, 0.f, 0.f, 0.f, GX_FALSE, GX_FALSE, GX_ANISO_1);
    GXInitTexObjLOD( &Texture2, GX_LINEAR, GX_LINEAR, 0.f, 0.f, 0.f, GX_FALSE, GX_FALSE, GX_ANISO_1);
    
    OSReport("Texture loaded.\n");
    
    if(argc > 1) {        // Set Scene_No by the string sent from a message.    
#ifdef _DEBUG
    int i;
    for(i=1; i < argc; i++)
    {
        OSReport("argv[%d]: %s\n", i, argv[i]);
    }
#endif // _DEBUG
        if(strcmp(argv[1], "SCN1") == 0)    Scene_No = 1;
        else if(strcmp(argv[1], "SCN2") == 0)    Scene_No = 2;
        else    Scene_No = 0;
    }
    else {
        Scene_No = 0;
    }
    
    // Draw
    while(1)
    {            
        DEMOBeforeRender();
            SetupCamera();
            DrawScene();
            GXDrawDone();
            
            // Text
            DEMOInitCaption(DM_FT_OPQ, 320, 240);
            DEMOPrintf(0, 0,0, "Demo Channnel - Scene %d", Scene_No);
            DEMOPrintf(0,15,0, "HOME -> return to Menu");
            DEMOPrintf(0,25,0, "+, -, RIGHT, LEFT -> change scene");
            DEMOPrintf(0,35,0, "A -> post a message");
            
            if( argc != 0)
                DEMOPrintf(0,45,0, "ID: %s", argv[0]);

            if( count > 0 ){
                DEMOPrintf(0, 200, 0, "Posting......");
            }
            else if(Kpad_s[0][0].trig & KPAD_BUTTON_HOME ) {
                DEMOPrintf(0, 210, 0, "Return to Menu...");
            }

            GXDrawDone();
            
        DEMODoneRender();
        
        // Input processing
        if( count <= 0 ){
            if( Kpad_s[0][0].trig & KPAD_BUTTON_HOME ) {
                OSReport("Return to Menu.\n");
                break;
            }
            else if(Kpad_s[0][0].trig & (KPAD_BUTTON_RIGHT | KPAD_BUTTON_PLUS)) {
                Scene_No += 1;
                if(Scene_No == 3)    Scene_No = 0;
            }
            else if(Kpad_s[0][0].trig & (KPAD_BUTTON_LEFT | KPAD_BUTTON_MINUS)) {
                if(Scene_No == 0)    Scene_No = 3;
                Scene_No -= 1;
            }
            else if( Kpad_s[0][0].trig & KPAD_BUTTON_A) {
                OSReport("Posted a Message.\n");
                PostMessage();
                count = 60;
            }
            else if( Kpad_s[0][0].hold & KPAD_BUTTON_B ) {
                if(Rot_Deg == 360)    Rot_Deg= 0;
                Rot_Deg += 1;
            }
        }
        else
            count--;
        
        tmp = KPADRead( 0, &Kpad_s[0][0], KPAD_MAX_READ_BUFS);
    }
    
    if( NWC24_OK != (err = NWC24CloseLib()) )
    {
        OSReport("NWC24CloseLib() Error: %d\n", err);
        OSHalt("Failed.\n");
    }
    
    MEMFreeToAllocator(&s_mem2Allocator, libWorkMem);
    
    VFFinalize();
    
    OSReport("Sample complete\n");
    OSReturnToMenu();
}

/*******************************************************************************
    Draw functions
 *******************************************************************************/
static void DrawLines( void )
{
    int i = -5;

    GXClearVtxDesc();
    GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
    GXSetVtxDesc(GX_VA_CLR0, GX_DIRECT);
    
    GXSetVtxAttrFmt(GX_VTXFMT1, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
    GXSetVtxAttrFmt(GX_VTXFMT1, GX_VA_CLR0, GX_CLR_RGB, GX_RGB8, 0);
    
    GXSetNumChans(1);
    GXSetChanCtrl(GX_COLOR0A0, GX_DISABLE, GX_SRC_REG, GX_SRC_VTX, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE);
    GXSetChanCtrl(GX_COLOR1A1, GX_DISABLE, GX_SRC_REG, GX_SRC_VTX, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE);
    GXSetNumTexGens(0);
    GXSetNumTevStages(1);
    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
    GXSetTevOp(GX_TEVSTAGE0, GX_PASSCLR);
    
    for(i=-5 ; i<6 ; i++) {
        GXBegin(GX_LINESTRIP, GX_VTXFMT1, 3);
            GXPosition3f32(1.0f * i, 0.0f,  8.0f);
            GXColor3u8(0, 255, 0);
            GXPosition3f32(1.0f * i, 0.0f,  0.0f);
            GXColor3u8(255, 0, 0);
            GXPosition3f32(1.0f * i, 0.0f, -8.0f);
            GXColor3u8(0, 255, 255);
        GXEnd();
        
        GXBegin(GX_LINESTRIP, GX_VTXFMT1, 3);
            GXPosition3f32(-5.5f, 0.0f, 7.7f - 1.4f * (i+5.f));
            GXColor3u8(0, 0, 255);
            GXPosition3f32( 0.0f, 0.0f, 7.7f - 1.4f * (i+5.f));
            GXColor3u8(255, 255, 255);
            GXPosition3f32( 5.5f, 0.0f, 7.7f - 1.4f * (i+5.f));
            GXColor3u8(0, 255, 255);
        GXEnd();
    }
}

static void DrawBase( void )
{
    GXClearVtxDesc();
    GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
    GXSetVtxDesc(GX_VA_CLR0, GX_DIRECT);
    
    GXSetVtxAttrFmt(GX_VTXFMT1, GX_VA_POS, GX_POS_XYZ, GX_F32, 0);
    GXSetVtxAttrFmt(GX_VTXFMT1, GX_VA_CLR0, GX_CLR_RGB, GX_RGB8, 0);
    
    GXSetNumChans(1);
    GXSetChanCtrl(GX_COLOR0A0, GX_DISABLE, GX_SRC_REG, GX_SRC_VTX, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE);
    GXSetChanCtrl(GX_COLOR1A1, GX_DISABLE, GX_SRC_REG, GX_SRC_VTX, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE);
    GXSetNumTexGens(0);
    GXSetNumTevStages(1);
    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
    GXSetTevOp(GX_TEVSTAGE0, GX_PASSCLR);
        
    GXBegin(GX_QUADS, GX_VTXFMT1, 4);
        GXPosition3f32(-3.0f, 0.0f, -5.0f);
        GXColor3u8(0, 255, 0);
        GXPosition3f32( 3.0f, 0.0f, -5.0f);
        GXColor3u8(0, 255, 255);
        GXPosition3f32( 3.0f, 0.0f,  3.0f);
        GXColor3u8(0, 0, 255);
        GXPosition3f32(-3.0f, 0.0f,  3.0f);
        GXColor3u8(255, 0, 0);
    GXEnd();
}

static void DrawRectangles( void )
{
    GXClearVtxDesc();
    GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
    GXSetVtxDesc(GX_VA_CLR0, 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_CLR0, GX_CLR_RGB, GX_RGB8, 0);
    GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0);
    
    GXSetNumChans(1);
    GXSetChanCtrl(GX_COLOR0A0, GX_DISABLE, GX_SRC_REG, GX_SRC_VTX, GX_LIGHT_NULL, GX_DF_NONE, GX_AF_NONE);
    GXSetChanCtrl(GX_COLOR1A1, GX_DISABLE, GX_SRC_REG, 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);
    GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0);
    GXSetTevDirect( GX_TEVSTAGE0 );
    GXSetTevSwapMode( GX_TEVSTAGE0, GX_TEV_SWAP0, GX_TEV_SWAP0 );
    GXSetTevOp(GX_TEVSTAGE0, GX_REPLACE);
    
    GXSetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_NOOP);
    GXSetZMode( GX_ENABLE, GX_LEQUAL, GX_ENABLE);
    
    //
    GXLoadTexObj( &TextureD, GX_TEXMAP0);            
    GXBegin(GX_QUADS, GX_VTXFMT0, 4);
        GXPosition3f32(-0.5f,  0.0f, -2.5f);
        GXColor3u8(255, 255, 255); GXTexCoord2f32(0.f, 0.f);
        GXPosition3f32( 0.5f,  0.0f, -2.5f);
        GXColor3u8(255, 255, 255); GXTexCoord2f32(1.f, 0.f);
        GXPosition3f32( 0.5f,  0.0f, -1.5f);
        GXColor3u8(255, 255, 255); GXTexCoord2f32(1.f, 1.f);
        GXPosition3f32(-0.5f,  0.0f, -1.5f);
        GXColor3u8(255, 255, 255); GXTexCoord2f32(0.f, 1.f);
    GXEnd();
    
    // 1
    GXLoadTexObj( &Texture1, GX_TEXMAP0 );
    GXBegin(GX_QUADS, GX_VTXFMT0, 4);
        GXPosition3f32(-2.5f, 0.0f, -0.5f);
        GXColor3u8(255, 255, 255); GXTexCoord2f32(1.f, 0.f);
        GXPosition3f32(-1.5f, 0.0f, -0.5f);
        GXColor3u8(255, 255, 255); GXTexCoord2f32(1.f, 1.f);
        GXPosition3f32(-1.5f, 0.0f,  0.5f);
        GXColor3u8(255, 255, 255); GXTexCoord2f32(0.f, 1.f);
        GXPosition3f32(-2.5f, 0.0f,  0.5f);
        GXColor3u8(255, 255, 255); GXTexCoord2f32(0.f, 0.f);
    GXEnd();
    
    // 2
    GXLoadTexObj( &Texture2, GX_TEXMAP0 );
    GXBegin(GX_QUADS, GX_VTXFMT0, 4);
        GXPosition3f32( 1.5f, 0.0f, -0.5f);
        GXColor3u8(255, 255, 255); GXTexCoord2f32(0.f, 1.f);
        GXPosition3f32( 2.5f, 0.0f, -0.5f);
        GXColor3u8(255, 255, 255); GXTexCoord2f32(0.f, 0.f);
        GXPosition3f32( 2.5f, 0.0f,  0.5f);
        GXColor3u8(255, 255, 255); GXTexCoord2f32(1.f, 0.f);
        GXPosition3f32( 1.5f, 0.0f,  0.5f);
        GXColor3u8(255, 255, 255); GXTexCoord2f32(1.f, 1.f);
    GXEnd();
}