GX_LoadTexObj(BarbTex.Texture.TexObj(), GX_TEXMAP0);
GX_LoadTexObj(CelTex.Texture.TexObj(), GX_TEXMAP1);

GX_SetNumTexGens(2);
GX_SetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY);
GX_SetTexCoordGen(GX_TEXCOORD1, GX_TG_SRTG, GX_TG_COLOR0, GX_IDENTITY);

GX_SetNumTevStages(2);
GX_SetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0);
GX_SetTevOrder(GX_TEVSTAGE1, GX_TEXCOORD1, GX_TEXMAP1, GX_COLOR0A0);

object.RenderModel();

// Re-add the <> symbols on the include because Phorum will clear its contents for some reason
#include stdio.h
#include stdlib.h
#include string.h
#include malloc.h
#include unistd.h
#include network.h
#include errno.h

#include gccore.h
#include fat.h


#define HOST_NAME   "www.wiibrew.org"
#define GET_ADDR    "/"


#define MAX_MSG_LEN     4096


// Stuff for video and framebuffer
GXRModeObj	*videoMode;	// Video mode registers
void		*xfb=NULL;	// External framebuffer


// Declaration of the video init routine
void initVideo();


// Structure for holding socket data
typedef struct {
    sockaddr_in socketAddr;
    int         socket;
    char        socketBuff[MAX_MSG_LEN];
} hostSocket;


// Connect function
hostSocket *Connect(const char *ipAddr, int port) {

    hostSocket *handle = (hostSocket*)malloc(sizeof(hostSocket));
    memset(handle, 0x00, sizeof(hostSocket));


    // Set appropriate values to the socket address
    handle->socketAddr.sin_family = AF_INET;
    handle->socketAddr.sin_port = htons(port);
    handle->socketAddr.sin_addr.s_addr = inet_addr(ipAddr);


    // Create a socket handle
    handle->socket = net_socket(AF_INET, SOCK_STREAM, IPPROTO_IP);

    if (handle->socket < 0) {
        printf("Cannot create socket.\n");
        free(handle);
        return(NULL);
    }


    printf("Socket created... Connecting to address %s... ", ipAddr);


    // Establish connection
    if (net_connect(handle->socket, (struct sockaddr*)&handle->socketAddr, sizeof(sockaddr_in)) == -1) {

        printf("Connect failed.\n");
        net_close(handle->socket);
        free(handle);
        return(NULL);

    }


    return(handle);

}


// Main function
int main(int argc, char *argv[]) {

	// Initialize video for console display
	initVideo();

	// Initialize console
	console_init(xfb, 20, 20, videoMode->fbWidth, videoMode->xfbHeight, videoMode->fbWidth*2);


    // Initialize file system for dumping received data to a file for analysis
	fatInitDefault();


	// Print Hello World message
	printf("\nInitializing network... ");
	if (net_init()) {
        printf("Failed to initialize network.\n");
        exit(EXIT_FAILURE);
	}
	printf("Ok!\n");


    // Get IP addresses of domain and print out the results
    printf("Resolving IP addresses to domain %s... ", HOST_NAME);
    hostent *host = net_gethostbyname(HOST_NAME);
    if (!host) {
        printf("Could not resolve domain address.\n");
        exit(EXIT_FAILURE);
    }
    printf("Ok!\n");

    printf("Address list:\n");
    for(int i=0; host->h_addr_list != NULL; i++) {
        printf(" %s\n", inet_ntoa(*((in_addr*)host->h_addr_list)));
    }

    char *ipAddr = strdup(inet_ntoa(*((in_addr*)host->h_addr_list[0])));


    printf("Connecting to %s... ", ipAddr);
    hostSocket *socket = Connect(ipAddr, 80);
    if (!socket) {
        exit(EXIT_FAILURE);
    }
    printf("Ok!\n");

    free(ipAddr);


    // Send GET request
    printf("Sending GET request... ");

    sprintf(socket->socketBuff, "GET %s HTTP/1.1\r\nHost: %s\r\n\r\n", GET_ADDR, HOST_NAME);
    if (net_send(socket->socket, socket->socketBuff, strlen(socket->socketBuff), 0) < 0) {

        printf("Could not send request.\n");
        net_close(socket->socket);
        exit(EXIT_FAILURE);

    }

    printf("Ok.\n");


    // Print out and dump received data into a file
    FILE *fp = fopen("/dump.bin", "w");
    printf("\nReceived data:\n");

    while(1) {

        int bytes = net_recv(socket->socket, socket->socketBuff, MAX_MSG_LEN, 0);

        // net_recv() will return 0 if the connection has been closed by the server
        if (bytes <= 0)
            break;

        // Write to file
        if (fp != NULL)
            fwrite(socket->socketBuff, 1, bytes, fp);

        // Print the data
        socket->socketBuff[bytes-1] = 0x00;
        printf("%s", socket->socketBuff);

    }


    // Close socket and file
    net_close(socket->socket);
    fclose(fp);

    printf("\n\nReceive complete and socket is closed.\n");


	// Wait until reset is pressed
	while(SYS_ResetButtonDown() == false) {
		VIDEO_WaitVSync();
	}

	printf("Exiting...\n");

}

// Simple video init routine for displaying a text console
void initVideo() {

	// Initialize video subsystem
	VIDEO_Init();

	// Get preferred video mode according to the console's configuration
	videoMode = VIDEO_GetPreferredMode(NULL);

	// Create external framebuffer and clear it
	// (only one framebuffer since we're only going to display a text console)
	xfb = MEM_K0_TO_K1(SYS_AllocateFramebuffer(videoMode));
	VIDEO_ClearFrameBuffer(videoMode, xfb, 0x00000000);

	// Configure video system, set framebuffer and clear display mask
	VIDEO_Configure(videoMode);
	VIDEO_SetNextFramebuffer(xfb);
	VIDEO_SetBlack(FALSE);
	VIDEO_Flush();

}

git clone git://github.com/blackberry/box2d
cd Box2D/Build
cmake -DBOX2D_BUILD_EXAMPLES=OFF -DCMAKE_INSTALL_PREFIX=$DEVKITPRO/libogc \
  -DCMAKE_CXX_COMPILER=$DEVKITPPC/bin/powerpc-eabi-g++ \
  -DCMAKE_SYSTEM_NAME=Generic -DBOX2D_INSTALL=ON ..
make all install
cd $DEVKITPRO/libogc/lib
rm -rf Box2D
mv libBox2D.a wii

LIBS += -lBox2D

#include <Box2D/Box2D.h>

u32* tmp = xfb; //xfb is the external framebuffer
tmp[x+(640*y)/2] = 0x00FF0000; // a color

    // Before starting rendering
    guMtxIdentity(mGXmodelView2D);
    guMtxTransApply (mGXmodelView2D, mGXmodelView2D, 0.0F, 0.0F, -5.0F);
    GX_LoadPosMtxImm(mGXmodelView2D, GX_PNMTX0);


    // Begin Draw, set mode to Quads
    GX_Begin(GX_QUADS, GX_VTXFMT0, 4);
    
    // Top Left
    GX_Position2f32(quadCoords[0][0], quadCoords[0][1]);
    GX_TexCoord2f32(texCoords[0][0], texCoords[0][1]);

    // Top Right
    GX_Position2f32(quadCoords[1][0], quadCoords[1][1]);
    GX_TexCoord2f32(texCoords[1][0], texCoords[1][1]);
    
    // Bottom Right
    GX_Position2f32(quadCoords[2][0], quadCoords[2][1]);
    GX_TexCoord2f32(texCoords[2][0], texCoords[2][1]);
    
    // Bottom Left
    GX_Position2f32(quadCoords[3][0], quadCoords[3][1]);
    GX_TexCoord2f32(texCoords[3][0], texCoords[3][1]);
    
    // End Draw
    GX_End();


    // After rendering
    GX_DrawDone();
    
    GX_SetZMode(GX_TRUE, GX_LEQUAL, GX_TRUE);
    GX_SetBlendMode(GX_BM_BLEND, GX_BL_SRCALPHA, GX_BL_INVSRCALPHA, GX_LO_CLEAR);
    GX_SetAlphaUpdate(GX_TRUE);
    GX_SetColorUpdate(GX_TRUE);
    GX_CopyDisp(mFrameBuffers[mFrameBufferIndex], GX_TRUE);
    
    VIDEO_SetNextFramebuffer(mFrameBuffers[mFrameBufferIndex]);
    
    if(mFirstFrameBuffer)
    {
        VIDEO_SetBlack(FALSE);
        mFirstFrameBuffer = 0;
    }
    VIDEO_Flush();
    VIDEO_WaitVSync();
    mFrameBufferIndex ^= 1;

var.SX2 = (wiimote2.Exp0 & 0x3F) - 31
var.SY2 = (wiimote2.Exp1 & 0x3F) - 31
var.BE2 = !(wiimote2.Exp5 & 0x10)
var.BM2 = !(wiimote2.Exp4 & 0x10)
var.BP2 = !(wiimote2.Exp4 & 0x04)
var.ED2 = ((wiimote2.Exp2 & 0x60) >> 2) + ((wiimote2.Exp3 & 0xE0) >> 5)
var.CS2 = ((wiimote2.Exp2 & 0x1E) >> 1) - 8
var.LTT2 = (wiimote2.Exp3 & 0x1F)
if (wiimote2.Exp4 & 0x01) var.LTT2 = var.LTT2 - 32

if not var.LTT2 == 0 then midi.Control77 = MapRange(var.LTT2,-30,30,0,1)

	GRRLIB_SetTexture(TextrueHere,0);
	GRRLIB_ObjectView(x,y,z, 0,0,0, 0.5,0.5,0.5);
	GX_Begin(GX_QUADS, GX_VTXFMT0, 24);
	
	/* Top */
	GX_Position3f32(-1.0f,1.0f,1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(0.0f,0.0f);
	GX_Position3f32(1.0f,1.0f,1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(1.0f,0.0f);
	GX_Position3f32(1.0f,-1.0f,1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(1.0f,1.0f);
	GX_Position3f32(-1.0f,-1.0f,1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(0.0f,1.0f);

	/* Bottom */
	GX_Position3f32(1.0f,1.0f,-1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(0.0f,0.0f);
	GX_Position3f32(-1.0f,1.0f,-1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(1.0f,0.0f);
	GX_Position3f32(-1.0f,-1.0f,-1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(1.0f,1.0f);
	GX_Position3f32(1.0f,-1.0f,-1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(0.0f,1.0f);

	/* Front */
	GX_Position3f32(1.0f,1.0f,1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(0.0f,0.0f);
	GX_Position3f32(1.0f,1.0f,-1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(1.0f,0.0f);
	GX_Position3f32(1.0f,-1.0f,-1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(1.0f,1.0f);
	GX_Position3f32(1.0f,-1.0f,1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(0.0f,1.0f);

	/* Back */
	GX_Position3f32(-1.0f,1.0f,-1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(0.0f,0.0f);
	GX_Position3f32(-1.0f,1.0f,1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(1.0f,0.0f);
	GX_Position3f32(-1.0f,-1.0f,1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(1.0f,1.0f);
	GX_Position3f32(-1.0f,-1.0f,-1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(0.0f,1.0f);

	/* Left */
	GX_Position3f32(-1.0f,1.0f,-1.0f); 
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(0.0f,0.0f);
	GX_Position3f32(1.0f,1.0f,-1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(1.0f,0.0f);
	GX_Position3f32(1.0f,1.0f,1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(1.0f,1.0f);
	GX_Position3f32(-1.0f,1.0f,1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(0.0f,1.0f);

	/* Right */
	GX_Position3f32(1.0f,-1.0f,-1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(0.0f,0.0f);
	GX_Position3f32(-1.0f,-1.0f,-1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(1.0f,0.0f);
	GX_Position3f32(-1.0f,-1.0f,1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(1.0f,1.0f);
	GX_Position3f32(1.0f,-1.0f,1.0f);
	GX_Color1u32(0xFFFFFFFF);
	GX_TexCoord2f32(0.0f,1.0f);
	
	GX_End();

if (CONF_GetAspectRatio() == CONF_ASPECT_16_9) {
// do widescreen specific stuff
} else { // CONF_ASPECT_4_3 or error/unknown value
// do non-widescreen stuff
}

if (CONF_GetAspectRatio() == CONF_ASPECT_16_9)
{
	// do widescreen specific stuff
	ML_DrawBackground(&boardBGw);
	ML_SetBackgroundSize(&boardBGw, 850, 480);
}
else // CONF_ASPECT_4_3 or error/unknown value
{
	// do non-widescreen stuff
	ML_DrawBackground(&boardBGs);
	ML_SetBackgroundSize(&boardBGs, 640, 480);
}

	s32 result = LWP_CreateThread(&main_thread[current_thread], thread_func, NULL, 0, STACKSIZE, 66+current_thread);
      if (result == 0) return true;

	if(threading_debug) printf("thread failed to create.\n");
	return false;

#include stdio.h
#include stdlib.h
#include string.h
#include malloc.h
#include math.h
#include gccore.h
#include wiiuse/wpad.h

// My test texture (any 128x256 texture should do)
#include "sampletex_tpl.h"
#include "sampletex.h"


#define DEFAULT_FIFO_SIZE	(256*1024)


GXRModeObj	*rmode		= NULL;
void		*gp_fifo	= NULL;
GXColor		ClearColor	= {0, 0, 0, 0xff};

Mtx			myView, myModel, myModelView;
Mtx44		myPersp;
void		*myFB[2]	= { NULL, NULL};
int			ActiveFB	= 0;


TPLFile		sampleTPL;
GXTexObj	texture;

// Function prototypes
int main();
void init();


int main() {
	
	
	// Initialize everything
	init();
	
	
	while(1) {
		
		WPAD_ScanPads();
		
		if (WPAD_ButtonsDown(0) & WPAD_BUTTON_HOME) exit(0);
		
		
		// Prepare for rendering
		GX_SetViewport(0, 0, rmode->fbWidth, rmode->efbHeight, 0, 1);
		
		
		// Set appropriate texturing modes
		GX_SetTevOp(GX_TEVSTAGE0, GX_MODULATE);
		GX_SetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD0, GX_TEXMAP0, GX_COLOR0A0);
		
		
		// 'Bind' to our texture
		GX_LoadTexObj(&texture, GX_TEXMAP0);
		
		
		
		// Set geometry stuff
		guMtxIdentity(myModelView);
		guMtxTransApply (myModelView, myModelView, 0.0F, 0.0F, 0.0F);
		GX_LoadPosMtxImm(myModelView, GX_PNMTX0);
		
		
		// Draw the texture
		GX_Begin(GX_QUADS, GX_VTXFMT0, 4);
			
			// Top-left
			GX_Position2f32(0, 0);
			GX_Color3f32(1.0f, 1.0f, 1.0f);
			GX_TexCoord2f32(0, 0);
			
			// Top-right
			GX_Position2f32(256, 0);
			GX_Color3f32(1.0f, 1.0f, 1.0f);
			GX_TexCoord2f32(1, 0);
			
			// Bottom-right
			GX_Position2f32(256, 512);
			GX_Color3f32(1.0f, 1.0f, 1.0f);
			GX_TexCoord2f32(1, 1);
			
			// Bottom-left
			GX_Position2f32(0, 512);
			GX_Color3f32(1.0f, 1.0f, 1.0f);
			GX_TexCoord2f32(0, 1);
			
		GX_End();
		
		
		/*
		// Draw a plain quad
		GX_Begin(GX_QUADS, GX_VTXFMT1, 4);
			
			// Top-left
			GX_Position2f32(300, 40);
			GX_Color3f32(1.0f, 1.0f, 1.0f);
			
			// Top-right
			GX_Position2f32(500, 40);
			GX_Color3f32(1.0f, 1.0f, 1.0f);
			
			// Bottom-right
			GX_Position2f32(500, 80);
			GX_Color3f32(1.0f, 1.0f, 1.0f);
			
			// Bottom-left
			GX_Position2f32(300, 80);
			GX_Color3f32(1.0f, 1.0f, 1.0f);
			
		GX_End();
		*/
		
		
		// Display the rendered scene
		
		
		ActiveFB ^= 1;
		GX_SetZMode(GX_FALSE, GX_LEQUAL, GX_FALSE);
		GX_SetColorUpdate(GX_TRUE);
		GX_CopyDisp(myFB[ActiveFB], GX_TRUE);
		
		GX_DrawDone();
		
		VIDEO_SetNextFramebuffer(myFB[ActiveFB]);
		VIDEO_Flush();
		VIDEO_WaitVSync();
		
		
	}
	
	
	return(0);
	
}

void init() {
	
	int		aspect=0;
	int		xfbHeight=0;
	float	yscale=0;

	
	if (CONF_GetAspectRatio() == CONF_ASPECT_16_9) {
		aspect = 1;
	} else {
		aspect = 0;
	}
	
	
	// Setup video
	VIDEO_Init();
	
	
	// Allocate memory blocks as our framebuffers (two for double buffering)
	rmode = VIDEO_GetPreferredMode(NULL);
	myFB[0] = MEM_K0_TO_K1(SYS_AllocateFramebuffer(rmode));
	myFB[1] = MEM_K0_TO_K1(SYS_AllocateFramebuffer(rmode));
	
	
	// To fully get rid of the border on widescreen TVs
	if (aspect) {
		rmode->viWidth += 58;
		if (rmode->viWidth > 720)	rmode->viWidth = 720;
	}
	
	
	// More video init stuff
	VIDEO_Configure(rmode);
	VIDEO_SetNextFramebuffer(myFB[ActiveFB]);
	VIDEO_SetBlack(FALSE);
	VIDEO_Flush();
	VIDEO_WaitVSync();
	if (rmode->viTVMode & VI_NON_INTERLACE) VIDEO_WaitVSync();
	
	
	// Setup fifo and the 'flipper'
	gp_fifo = memalign(32, DEFAULT_FIFO_SIZE);
	memset(gp_fifo, 0, DEFAULT_FIFO_SIZE);
	
	
	// Initialize the GX system
	GX_Init(gp_fifo, DEFAULT_FIFO_SIZE);
	
	
	// Clears the bg to color and z buffer
	GX_SetCopyClear(ClearColor, 0x00ffffff);
	
	
	// More GX setup stuff
	GX_SetViewport(0, 0, rmode->fbWidth, rmode->efbHeight, 0, 1);
	yscale = GX_GetYScaleFactor(rmode->efbHeight, rmode->xfbHeight);
	xfbHeight = GX_SetDispCopyYScale(yscale);
	GX_SetScissor(0, 0, rmode->fbWidth, rmode->efbHeight);
	GX_SetDispCopySrc(0, 0, rmode->fbWidth, rmode->efbHeight);
	GX_SetDispCopyDst(rmode->fbWidth, xfbHeight);
	GX_SetCopyFilter(rmode->aa, rmode->sample_pattern, GX_TRUE, rmode->vfilter);
	GX_SetFieldMode(rmode->field_rendering, ((rmode->viHeight == 2*rmode->xfbHeight)?GX_ENABLE:GX_DISABLE));
	
	if (rmode->aa)
		GX_SetPixelFmt(GX_PF_RGB565_Z16, GX_ZC_LINEAR);
	else
		GX_SetPixelFmt(GX_PF_RGB8_Z24, GX_ZC_LINEAR);
	
	GX_SetCullMode(GX_CULL_NONE);
	GX_CopyDisp(myFB[ActiveFB], GX_TRUE);
	GX_SetDispCopyGamma(GX_GM_1_0);
	
	
	GX_ClearVtxDesc();
	GX_SetVtxDesc(GX_VA_POS, GX_DIRECT);
	GX_SetVtxDesc(GX_VA_CLR0, GX_DIRECT);
	GX_SetVtxDesc(GX_VA_TEX0, GX_DIRECT);

	GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_POS_XY, GX_F32, 0);
	GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_TEX_ST, GX_F32, 0);
	GX_SetVtxAttrFmt(GX_VTXFMT0, GX_VA_CLR0, GX_CLR_RGBA, GX_RGB8, 0);

	
	
	GX_SetNumChans(1);
	GX_SetNumTexGens(1);
	GX_SetTexCoordGen(GX_TEXCOORD0, GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY);
	
	
	GX_InvVtxCache();
	GX_InvalidateTexAll();
	
	
	// Upload our texture	
	TPL_OpenTPLFromMemory(&sampleTPL, (void*)sampletex_tpl, sampletex_tpl_size);
	TPL_GetTexture(&sampleTPL, sampletex, &texture);
	
	
	// Setup orthogonal projection matrix
	if (aspect) {	// Anamorphic widescreen
		guOrtho(myPersp, 0, rmode->viHeight - 1, 0, (rmode->viWidth - 1) + 140, 0, 10);
	} else {		// Normal
		guOrtho(myPersp, 0, rmode->viHeight - 1, 0, rmode->viWidth - 1, 0, 10);
	}
	
	GX_LoadProjectionMtx(myPersp, GX_ORTHOGRAPHIC);
	
	
	WPAD_Init();
	
}

/**
 * main.c - Directory listing example for NTFS-based devices.
 *
 * Copyright (c) 2009 Rhys "Shareese" Koedijk
 *
 * This program/include file is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as published
 * by the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program/include file is distributed in the hope that it will be
 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include 
#include 
#include 

#include 
#include 

#include 
#include 
#include 
#include 
#include 
#include 

static void *xfb = NULL;
static GXRModeObj *rmode = NULL;

void list(const char *path, int depth)
{
    DIR *pdir;
    struct dirent *pent;
    struct stat st;
    char indent[PATH_MAX] = {0};
    char new_path[PATH_MAX] = {0};

    // Open the directory
    pdir = opendir(path);
    if (pdir) {

        // Make this our current directory
        chdir(path);

        // Build a directory indent (for better readability)
        memset(indent, ' ', depth * 2);

        // List the contents of the directory
        while ((pent = readdir(pdir)) != NULL) {
            if ((strcmp(pent->d_name, ".") == 0) || (strcmp(pent->d_name, "..") == 0))
                continue;

            // Get the entries stats
            if (stat(pent->d_name, &st) == -1)
                continue;

            // List the entry
            if (S_ISDIR(st.st_mode)) {
                printf(" D %s%s/\n", indent, pent->d_name);

                // List the directories contents
                sprintf(new_path, "%s/%s", path, pent->d_name);
                list(new_path, depth + 1);
                chdir(path);

            } else if (S_ISREG(st.st_mode)) {
                printf(" F %s%s (%lu)\n", indent, pent->d_name, (unsigned long int)st.st_size);
            } else {
                printf(" ? %s%s\n", indent, pent->d_name);
            }

        }

        // Close the directory
        closedir(pdir);

    } else {
        printf("opendir(%s) failure.\n", path);
    }

    return;
}

//---------------------------------------------------------------------------------
int main(int argc, char **argv) {
//---------------------------------------------------------------------------------

    // Initialise the video system
    VIDEO_Init();

    // This function initialises the attached controllers
    WPAD_Init();

    // Obtain the preferred video mode from the system
    // This will correspond to the settings in the Wii menu
    rmode = VIDEO_GetPreferredMode(NULL);

    // Allocate memory for the display in the uncached region
    xfb = MEM_K0_TO_K1(SYS_AllocateFramebuffer(rmode));

    // Initialise the console, required for printf
    console_init(xfb, 20, 20, rmode->fbWidth, rmode->xfbHeight, rmode->fbWidth * VI_DISPLAY_PIX_SZ);

    // Set up the video registers with the chosen mode
    VIDEO_Configure(rmode);

    // Tell the video hardware where our display memory is
    VIDEO_SetNextFramebuffer(xfb);

    // Make the display visible
    VIDEO_SetBlack(FALSE);

    // Flush the video register changes to the hardware
    VIDEO_Flush();

    // Wait for Video setup to complete
    VIDEO_WaitVSync();
    if(rmode->viTVMode&VI_NON_INTERLACE) VIDEO_WaitVSync();


    // The console understands VT terminal escape codes
    // This positions the cursor on row 2, column 0
    // we can use variables for this with format codes too
    // e.g. printf ("\x1b[%d;%dH", row, column );
    printf("\x1b[2;0H");

    printf("\n");
    printf(" NTFS Directory Listing Example\n");
    printf("\n");
    printf(" - 'LEFT' and 'RIGHT' to select a volume\n");
    printf(" - 'A' to enumerate the selected volume\n");
    printf(" - 'HOME' to quit\n");
    printf("\n");

    bool listed = false;
    ntfs_md *mounts = NULL;
    int mountCount = 0;
    int mountIndex = 0;
    int i;

    // Mount FAT devices
    fatInitDefault();

    // Mount all NTFS volumes on all inserted block devices
    mountCount = ntfsMountAll(&mounts, NTFS_DEFAULT | NTFS_RECOVER);
    if (mountCount == -1)
        printf("Error whilst mounting devices (%i).\n", errno);
    else if (mountCount == 0)
        printf("No NTFS volumes were found and/or mounted.\n");
    else
        printf("%i NTFS volumes(s) mounted!\n\n", mountCount);

    // List all mounted NTFS volumes
    for (i = 0; i < mountCount; i++)
        printf("%i - %s:/ (%s)\n", i + 1, mounts.name, ntfsGetVolumeName(mounts.name));

    printf("\n");
    while (1) {

        // Call WPAD_ScanPads each loop, this reads the latest controller states
        WPAD_ScanPads();

        // WPAD_ButtonsDown tells us which buttons were pressed in this loop
        // this is a "one shot" state which will not fire again until the button has been released
        u32 pressed = WPAD_ButtonsDown(0);

        // Break from main loop
        if (pressed & WPAD_BUTTON_HOME) break;

        // If there is at least one volume mounted and we have not yet listed one...
        if (mountCount > 0 && !listed) {

            // Deincrement the selected volumes index
            if (pressed & WPAD_BUTTON_LEFT)
                mountIndex = MIN(MAX(mountIndex - 1, 0), mountCount - 1);

            // Increment the selected volumes index
            if (pressed & WPAD_BUTTON_RIGHT)
                mountIndex = MIN(MAX(mountIndex + 1, 0), mountCount - 1);

            // Enumerate the selected volumes contents
            if (pressed & WPAD_BUTTON_A) {
                printf("\n\n");

                // List the volumes root directory
                char path[PATH_MAX] = {0};
                strcpy(path, mounts[mountIndex].name);
                strcat(path, ":/");
                list(path, 0);
                listed = true;

                printf("\n");
                printf("Press 'HOME' to quit.\n\n");

            }

            // If we have not listed a volume yet then prompt to select one
            if(!listed) {
                printf("\rSelect a NTFS volume: < %i >", mountIndex + 1);
            }

        }

        // Wait for the next frame
        VIDEO_WaitVSync();

    }

    // Unmount all NTFS volumes and clean up
    if (mounts) {
        for (i = 0; i < mountCount; i++)
            ntfsUnmount(mounts.name, true);
        free(mounts);
    }

    // We return to the launcher application via exit
    exit(0);

    return 0;
}