Libmii/Rendering Miis

From WiiBrew
Jump to: navigation, search
Libmii Rendering Example
General
Author(s)mdbrim
TypeDemo
Version2.0
Links
Download
Website
Source


This page is for describing how to use libmii to draw your Miis. The goal will be to eventually have instructions and directions for use with each of the popular graphics library and a raw example not requiring a library.

I'll also post the standard basic arrangement of each sprite so that users can easily create the commands for the graphics library of choice.

Any questions, comments, concerns, please email me (mdbrim) and let me know what i can do to help you out, fix something, make it better, etc.

NOTE: The below anchor points are based on the way GRRLIB handles scaling and rotation using anchor points... until further testing is done with your library, things may be different.


Contents

Body Parts

The following discusses each of the body parts and how to arrange each sprite as far as location, size, and rotation and where the anchor fix for each sprite should be in order to scale and rotate around the correct coordinates. The sprite files can be found HERE

Face Shape

  • Image File(s): mii_heads.png (contains the 8 different face shapes)
    • Image Size: 480x240
    • Tile Size: 8 tiles of 120x120
    • Tile Anchor Point: 0,0 (no special anchor point required)
  • Variable(s) from libmii:
Variable Possible Values Notes
mii.faceShape 0 - 7 values correspond with order of tiles
mii.skinColor 0 - 5 see COLORS section below to get translation
  • Notes:

Hair

  • Image File(s): mii_hairs1.png, mii_hairs2.png (contains the parts for the 72 different hair styles)
    • Image Size: 2 files of 960x840
    • Tile Size: 56 tiles of 120x120
    • Tile Anchor Point: 60,0 (allows for easy horizontal flip for reverse part)
  • Variable(s) from libmii:
Variable Possible Values Notes
mii.hairType 0 - 71 values DO NOT align with order of tiles (see note below)
mii.hairColor 0 - 7 see COLORS section below to get translation
mii.hairPart 0 or 1 0 is normal part, 1 is reversed
  • Notes: two arrays have been created called hairbg[72] and hairfg[72]. See the ARRAYS section below for description of how these work.

Eye Brows

  • Image File(s): mii_eyebrows.png (contains the parts for the 24 different eyebrows)
    • Image Size: 324x324
    • Tile Size: 48 tiles of 36x54 (a tile for each eyebrow left and right)
    • Tile Anchor Point: 0,54 (for right eyebrow) 36,54 (for left eyebrow)
  • Variable(s) from libmii:
Variable Possible Values Notes
mii.eyebrowType 0 - 23 values DO NOT align with order of tiles (see note below)
mii.eyebrowRotation 0 - 11 each rotation value equates to 11.25 degrees
mii.eyebrowColor 0 - 7 see COLORS section below to get translation
mii.eyebrowSize 0 - 8 translates from 30% to 110% scale in increments of 10%
mii.eyebrowVertPos 3 - 18 each step is worth 2.8 pixels
mii.eyebrowHorizSpacing 0 - 12 each step is worth 2.6 pixels
  • Notes: an array has been created called eyebrows[24]. See the ARRAYS section below for description of how this works.

Eyes

  • Image File(s): mii_eyes1.png, mii_eyes2.png, mii_eyes3.png (contains the parts for the 48 different eye types)
    • Image Size: 324x864
    • Tile Size: 96 tiles of 54x54 (a tile for each eye left and right)
    • Tile Anchor Point: 18,36 (for right eyebrow) 36,36 (for left eyebrow)
  • Variable(s) from libmii:
Variable Possible Values Notes
mii.eyeType 0 - 47 values DO NOT align with order of tiles (see note below)
mii.eyeRotation 0 - 7 each rotation value equates to 11.25 degrees
mii.eyeColor 0 - 5 see COLORS section below to get translation
mii.eyeSize 0 - 7 translates from 30% to 100% scale in increments of 10%
mii.eyeVertPos 0 - 18 each step is worth 2.8 pixels
mii.eyeHorizSpacing 0 - 12 each step is worth 2.6 pixels
  • Notes: an array has been created called eyes[48]. See the ARRAYS section below for description of how this works.

Noses

  • Image File(s): mii_noses.png (contains the 12 different nose types)
    • Image Size: 300x100
    • Tile Size: 12 tiles of 50x50
    • Tile Anchor Point: 25,30 (for scaling)
  • Variable(s) from libmii:
Variable Possible Values Notes
mii.noseType 0 - 11 values DO NOT align with order of tiles (see note below)
mii.noseSize 0 - 8 translates from 20% to 100% scale in increments of 10%
mii.noseVertPos 0 - 18 each step is worth 2.6 pixels
  • Notes: an array has been created called noses[12]. See the ARRAYS section below for description of how this works.

Mouth

  • Image File(s): mii_lips.png (contains the 24 different mouth types)
    • Image Size: 300x300
    • Tile Size: 24 tiles of 60x60
    • Tile Anchor Point: 30,30 (for scaling)
  • Variable(s) from libmii:
Variable Possible Values Notes
mii.lipType 0 - 23 values DO NOT align with order of tiles (see note below)
mii.lipColor 0 - 2 see COLORS section below to get translation
mii.lipSize 0 - 8 translates from 20% to 100% scale in increments of 10%
mii.lipVertPos 0 - 18 each step is worth 2.6 pixels
  • Notes: an array has been created called lips[24]. See the ARRAYS section below for description of how this works.

Beard

  • Image File(s): mii_beards.png (contains the 3 different beard types)
    • Image Size: 960x420
    • Tile Size: 24 tiles of 120x140 (each beard type on each face shape)
    • Tile Anchor Point: 0,0 (no special anchor point required)
  • Variable(s) from libmii:
Variable Possible Values Notes
mii.beardType 0 - 3 0 for no beard, 1-3 corresponds to beard tiles.
mii.facialHairColor 0 - 7 see COLORS section below to get translation
  • Notes: beard tiles are done for each face shape to align beard with bottom of face.

Mustache

  • Image File(s): mii_mustache.png (contains the 3 different mustache styles)
    • Image Size: 180x60
    • Tile Size: 3 tiles of 60x60
    • Tile Anchor Point: 30,10 (for scaling)
  • Variable(s) from libmii:
Variable Possible Values Notes
mii.mustacheType 0 - 3 0 for no mustache, 1-3 corresponds to mustache tiles.
mii.facialHairColor 0 - 7 see COLORS section below to get translation
mii.mustacheSize 0 - 8 translates from 20% to 100% scale in increments of 10%
mii.mustacheVertPos 0 - 16 each step is worth 2.9 pixels
  • Notes:

Glasses

  • Image File(s): mii_glasses.png (contains the 8 different glasses styles)
    • Image Size: 720x216
    • Tile Size: 11 tiles of 180x72 (8 glasses frames + 3 shaded lenses)
    • Tile Anchor Point: 90,32 (for scaling)
  • Variable(s) from libmii:
Variable Possible Values Notes
mii.glassesType 0 - 8 0 for no glasses, 1-8 corresponds to glasses tiles.
mii.glassesColor 0 - 5 see COLORS section below to get translation
mii.glassesSize 0 - 7 translates from 10% to 80% scale in increments of 10%
mii.glassesVertPos 0 - 20 each step is worth 2.6 pixels
  • Notes: glasses are drawn frames only unless sunglasses are chosen. Then it is frames and shaded lenses.

Facial Features

  • Image File(s): mii_features.png (contains the 11 different facial features)
    • Image Size: 960x720
    • Tile Size: 48 tiles of 120x120 (to build features for each face type)
    • Tile Anchor Point: 0,0 (no special anchor point required)
  • Variable(s) from libmii:
Variable Possible Values Notes
mii.facialFeature 0 - 11 0 for no feature, 1-11 corresponds to feature tiles (see note).
mii.skinColor 0 - 5 used only for makeup coloring. see COLORS section below to get translation
  • Notes: some facial features change based on face shape and some are universal regardless of face shape. See below in the ARRAYS section for description on building features to match face shape.

Mole

  • Image File(s): mii_mole.png (contains the mole graphic)
    • Image Size: 12x12
    • Tile Size: N/A (no tiles for the mole, just the one image)
    • Image Anchor Point: 6,6 (for scaling)
  • Variable(s) from libmii:
Variable Possible Values Notes
mii.mole 0 - 1 0 for no mole, 1 for a mole.
mii.moleSize 0 - 8 translates from 20% to 100% scale in increments of 10%
mii.moleVertPos 0 - 30 each step is worth 2.8 pixels
mii.moleHorizPos 0 - 16 each step is worth 4 pixels
  • Notes:

Layers

The images need to be drawn in the following order to ensure the layering is correct. Images drawn first will be on the bottom with the last image drawn being on the top.

  1. Hair (background (tiles 17 - 55 of mii_hairs2.png))
  2. Head
  3. Facial Feature
  4. Beard
  5. Mole
  6. Left and Right Eyes
  7. Left and Right Eyebrows
  8. Mouth
  9. Mustache
  10. Nose
  11. Hair (foreground (mii_hairs1.png and tiles 1 - 16 of mii_hairs2.png))
  12. Glasses

Colors

The following elements have colors involved. The colors that I have defaulted to below could probably use some tweaking. If you find better colors through your testing please let me know! All colors are given in Hex values and correspond to the value returned by their respective variables.

Skin Colors

in an array called skincol[]

  • 0 = ECCFBD
  • 1 = F7BC7D
  • 2 = D78A48
  • 3 = F5B189
  • 4 = 995122
  • 5 = 563010

Hair Colors

in an array called haircol[]

  • 0 = 111111
  • 1 = 332222
  • 2 = 441111
  • 3 = BB6644
  • 4 = 8888AA
  • 5 = 443322
  • 6 = 996644
  • 7 = DDBB99

Eyebrow Colors

  • SAME AS HAIR COLORS

Eye Colors

in an array called eyecol[]

  • 0 = 000000
  • 1 = 778887
  • 2 = 7E6355
  • 3 = 888940
  • 4 = 6A84D0
  • 5 = 409B5A

Lip Colors

in an array called lipcol[]

  • 0 = C76C46
  • 1 = E44E3A
  • 2 = D88789

Glasses Colors

in an array called glassescol[]

  • 0 = 626D6C
  • 1 = 85703A
  • 2 = AB4E37
  • 3 = 426996
  • 4 = B97F27
  • 5 = BDBFB9

Facial Hair Colors

  • SAME AS HAIR COLORS

Arrays

Some variables do not correspond with the same order tiles in the images. The following arrays are defined to align the variables from libmii with the tile order of the sprites in the img files. The image files contain the tiles in the same order you see them on the Mii build screen.

Hair

Hair is probably the most complicated one. Due to the large number of hair styles and file size limitations (1024 x 1024), the tiles had to be put onto two separate images (mii_hairs1.png and mii_hairs2.png). Hair also contains multiple layers with longer hair style having parts that I call background hair that goes behind the head (pony tails, long hair, etc) and then foreground hair which goes on top and in front of the head (most hair styles including bangs etc). ALL of the tiles in mii_hairs1.png are foreground hair parts as are the first 16 tiles of mii_hairs2.png. The rest of mii_hairs2.png is background hair.

  • The first array is for foreground hair and is called hairfg[72]. It has 72 elements and is defined as follows:
    • int hairfg[72] = {59,42,65,49,40,44,52,47,45,63,51,54,36,37,48,70,61,56,64,43,53,58,50,27,69,41,39,46,66,71,33,11,12,0,35,57,30,14,25,4,1,31,26,24,3,6,62,13,15,7,19,2,17,67,29,20,9,34,18,8,22,60,23,55,21,32,16,28,10,38,5,68};
  • The second array is for background hair and is called hairbg[72]. It has 72 elements and is defined as follows:
    • int hairbg[72]={56,56,56,56,56,56,56,56,56,56,56,56,16,56,56,56,56,56,17,18,56,19,20,56,56,56,21,56,56,56,56,56,56,56,56,56,22,23,56,56,24,25,56,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,56,56,48,49,50,51,52,53,56};
  • The purpose of hairfg is to translate the mii.hairType variable into the correct foreground hair sprite. For example: if mii.hairType returns 32 then we would use hairfg[mii.hairType] to get the proper tile which would be tile 12 (hairfg[32]=12). This would draw the correct fg hair tile from the mii.hairType variable.
  • The purpose of hairbg is to then take whatever foreground hair was drawn and add any corresponding background hair. For example we would use hairbg[hairfg[mii.hairType]] to get the correct background hair drawn. So, using our above example mii.hairType 32 corresponds foreground hair 12 which has a corresponding background hair of 16 (hairbg[hairfg[32]]=16).
  • SO the value mii.hairType returns a foreground hair tile of 12 and a background hair tile of 16 thus allowing us to draw the proper hair style.
  • You'll notice that hairbg array has the number 56 repeat alot. Tile 56 is a blank tile so all the foreground hairs that correspond to that slot have no background hair therefore none is drawn.
  • Because the foreground hair parts are split into two files, we use an if statement to make sure we draw from the correct img file.
    • If hairfg[mii.hairType] is < 56 we draw from the first image file using the hairfg[mii.hairType] tile number.
    • If hairfg[mii.hairType] is => 56 we draw from the second image file using the hairfg[mii.hairType]-56 tile number.
  • Background hair is always pulled from the second image file.

Eyebrows

The eyebrow tile set contains left eyebrows in tiles 0 thru 23, and right eyebrows in tiles 53-30 (notice the right eyebrows are backwards. They are arranged that way to pull from the ends of the tilesets (this will be more clear when we put it all together)).

  • The eyebrow array is called eyebrows[24]. It has 24 elements and is defined as follows:
    • int eyebrows[24] = {1,3,14,15,11,10,0,6,8,4,13,12,2,19,16,18,22,9,21,5,17,7,20,23};
  • The purpose of eyebrows is to translate the mii.eyebrowType variable into the correct right and left eyebrow tile. For example if mii.eyebrowType returns 4, we would use eyebrows[mii.eyebrowType] to draw the left eyebrow (tile 11) and 53-eyebrows[mii.eyebrowType] to draw the right eyebrow (tile 42).

Eyes

The eyes tile set contains three image files (mii_eyes1.png, mii_eyes2.png and mii.eyes3.png). The purpose of the three files it layer the eyes with a white layer for the whites of the eye, a dark layer for the eye drawing itself, and a color layer for the eye color portion. All three tile sets use the same variable to select a tile and like the eyebrows, the tiles are drawn for both left eye and right eye.

  • The eye array is called eyes[48]. It has 48 elements and is defined as follows:
    • int eyes[48] = {2,6,0,42,1,24,29,36,3,16,45,13,17,26,46,9,8,5,33,14,11,20,44,18,30,21,7,10,34,41,31,32,15,12,19,23,27,28,38,4,22,25,39,43,37,40,35,47};
  • The purpose of eyes is to translate the mii.eyeType variable into the correct right and left eyebrow tile. For example if mii.eyeType returns 9, we would use eyes[mii.eyeType] to draw the left eye (tile 16) and 95-eyes[mii.eyeType] to draw the right eye (tile 79).
  • These tiles are used for all three image files to build up a full eye.

Noses

The nose tile set contains the noses in tiles 0 thru 11.

  • The nose array is called noses[12]. It has 12 elements and is defined as follows:
    • int noses[12] = {5,0,2,3,7,6,4,10,8,9,1,11};
  • The purpose of noses is to translate the mii.noseType variable into the correct nose tile. For example if mii.noseType returns 4, we would use noses[mii.noseType] to draw the correct nose (tile 7).

Mouth

The mouth tile set contains the lips in tiles 0 thru 23.

  • The mouth array is called lips[24]. It has 24 elements and is defined as follows:
    • int lips[24] = {6,1,14,16,17,5,10,12,7,13,8,19,23,11,22,18,9,15,21,2,20,3,4,0};
  • The purpose of lips is to translate the mii.lipType variable into the correct lip tile. For example if mii.lipType returns 2, we would use lips[mii.lipType] to draw the correct mouth (tile 14).
  • There is an additional check to see if lips[mii.lipType] = 1, 6, 11, 17, or 19 because those tiles have lip colors associated with them.

Facial Features

Like the hair tiles, this is also somewhat of a complicated animal! The facial features are stored in mii_features.png. Some facial features depend on the type of head used and some do not. Therefore those features that are faceShape dependent have multiple tiles drawn to line up with the correct faceShape. Features that are the same for all faceShapes are drawn just once.

  • An IF statement is used to determine what tile to draw based on each facial feature.
    • if(mii.facialFeature==0) feature=39;
else if(mii.facialFeature==1) feature=mii.faceShape;
else if(mii.facialFeature==2) feature=mii.faceShape;
else if(mii.facialFeature==3) feature=33;
else if(mii.facialFeature==4) feature=34;
else if(mii.facialFeature==5) feature=35;
else if(mii.facialFeature==6) feature=36;
else if(mii.facialFeature==7) feature=40+mii.faceShape;
else if(mii.facialFeature==8) feature=38;
else if(mii.facialFeature==9) feature=8+mii.faceShape;
else if(mii.facialFeature==10) feature=16+mii.faceShape;
else if(mii.facialFeature==11) feature=24+mii.faceShape;
  • As you can see, if mii.facialFeature returns a 0, there is no feature (tile 39 is a blank tile).
  • If mii.facialFeature returns a 1, 2, 7, 9, 10, or 11: those are the features that are faceShape dependent so the proper tile number depends on the mii.faceShape variable.
  • If mii.facialFeature is something else... then it just sets the tile to the correct number.
  • There is a further check later on that if mii.facialFeature=2, then it is the makeup feature and makeup color is also needed.

Putting it all together

  • OK, so we've got all our variables translated into tile numbers thanks to some arrays and we've got all of our colors ready to go thanks to some color arrays and we've got our order in which to draw things ready to go so now we will start drawing!!!
  • I'll just give the raw data which can then be translated to your library of choice (all tests were done with GRRLIB so some tweaking may be needed)
  • Because all of these individual parts have different anchor points, we would be unable to properly scale and rotate our final mii because each piece would scale and rotate around its individual anchor point. THEREFORE you should build up your mii, and store the resulting parts into it's OWN image file and then you can do whatever you want with your newly drawn mii image.
    • To do this in GRRLIB, you would use the GRRLIB_CompoStart(); command, build up your mii parts, and then finish with GRRLIB_CompoEnd(200, 160, texturename) which will store your resulting mii into a new image called "texturename". You could then rotate, skew, scale, etc your new texture.
    • Because of this technique, the X,Y coordinates you will see in my example below are just onto the screen so that the above Compo commands can capture the image... you could then display the resulting image wherever you wanted afterwards.
  • We'll be drawing these in the proper order too.
  • REMEMBER TO DEFINE YOUR ANCHOR POINTS. Otherwise these positions, scales, and rotations will be all off!

Hair BG

  • X Pos: 230
  • Y Pos: 210
  • Image File: mii_hairbg.png
  • Rotation: 0
  • Scale: 1
  • Color: haircol[mii.hairColor]
  • Tile Number: hairbg[hairfg[mii.hairType]]

Head

  • X Pos: 230
  • Y Pos: 200
  • Image File: mii_heads.png
  • Rotation: 0
  • Scale: 1
  • Color: skincol[mii.skinColor]
  • Tile Number: mii.faceShape

Facial Feature

  • X Pos: 230
  • Y Pos: 200
  • Image File: mii_features.png
  • Rotation: 0
  • Scale: 1
  • Color: skincol[mii.skinColor]
  • Tile Number: if(feature=2) then tile number is tile 32 and 2... else tile number = feature.

Beard

  • X Pos: 230
  • Y Pos: 200
  • Image File: mii_beards.png
  • Rotation: 0
  • Scale: 1
  • Color: haircol[mii.facialHairColor]
  • Tile Number: ((mii.beardType-1)*8)+mii.faceShape

Mole

  • X Pos: 252+(4*mii.moleHorizPos)
  • Y Pos: 212+(2.8*mii.moleVertPos)
  • Image File: mii_mole.png
  • Rotation: 0
  • Scale: .2+(mii.moleSize*0.1)
  • Color: N/A
  • Tile Number: N/A

Eyes

  • X Pos Left Eye: 272+(2.6*mii.eyeHorizSpacing)
  • X Pos Right Eye: 254-(2.6*mii.eyeHorizSpacing)
  • Y Pos Both Eyes: 184+(2.8*mii.eyeVertPos)
  • Image File: mii_eyes1(2)(3).png
  • Rotation Left Eye: 11.25*(7-mii.eyeRotation)
  • Rotation Right Eye: -11.25*(7-mii.eyeRotation)
  • Scale: .3+(mii.eyeSize*0.1)
  • Color for mii_eyes1 and eyes3: N/A
  • Color for mii_eyes2: eyecol[mii.eyeColor]
  • Tile Number Left Eye: eyes[mii.eyeType]
  • Tile Number Right Eye: 95-eyes[mii.eyeType]

Eyes Brows

  • X Pos Left Eye: 288+(2.6*mii.eyebrowHorizSpacing)
  • X Pos Right Eye: 256-(2.6*mii.eyebrowHorizSpacing)
  • Y Pos Both Eyes: 166+(2.8*mii.eyebrowVertPos)
  • Image File: mii_eyebrows.png
  • Rotation Left Eye: 11.25*(11-mii.eyebrowRotation)
  • Rotation Right Eye: -11.25*(11-mii.eyebrowRotation)
  • Scale: .3+(mii.eyebrowSize*0.1)
  • Color: haircol[mii.eyebrowColor]
  • Tile Number Left Eye: eyebrows[mii.eyebrowType]
  • Tile Number Right Eye: 53-eyebrows[mii.eyebrowType]

Mouth

  • X Pos: 260
  • Y Pos: 220+(2.6*mii.lipVertPos)
  • Image File: mii_lips.png
  • Rotation: 0
  • Scale: .2+(mii.lipSize*0.1)
  • Color: if(lips[mii.lipType]==1 or 6 or 11 or 17 or 19 then: lipcol[mii.lipColor]
  • Color: else: N/A
  • Tile Number: lips[mii.lipType]

Mustache

  • X Pos: 260
  • Y Pos: 244+(2.9*mii.mustacheVertPos)
  • Image File: mii_mustache.png
  • Rotation: 0
  • Scale: .2+(mii.mustacheSize*0.1)
  • Color: haircol[mii.facialHairColor]
  • Tile Number: mii.mustacheType-1

Nose

  • X Pos: 265
  • Y Pos: 220+(2.6*mii.noseVertPos)
  • Image File: mii_noses.png
  • Rotation: 0
  • Scale: .2+(mii.noseSize*0.1)
  • Color: skincol[mii.skinColor]
  • Tile Number: noses[mii.noseType]

Hair FG

  • X Pos: 230
  • Y Pos: 190
  • Image File: mii_hairs1(2).png
  • Rotation: 0
  • Scale: 1 (Horizontal scale set to -1 for reverse part)
  • Color: haircol[mii.HairColor]
  • Tile Number: if(hairfg[mii.hairType]<56) then: hairfg[mii.hairType] on mii_hairs1.png
  • Tile Number: else: hairfg[mii.hairType]-56 on mii_hairs2.png

Glasses

  • X Pos: 200
  • Y Pos: 195+(2.6*mii.glassesVertPos)
  • Image File: mii_glasses.png
  • Rotation: 0
  • Scale: .1+(mii.glassesSize*0.1)
  • Color: FOR mii.glassesType < 6: glassescol[mii.glassesColor]
  • Color: FOR mii.glassesType => 6: the glasses are color N/A and the lenses are color glassescol[mii.glassesColor]
  • Tile Number: For mii.glassesType < 6: mii.glassesType-1
  • Tile Number: For mii.glassesType => 6: the glasses are tile mii.glassesType-1 and the lenses are tile mii.glassesType+2
  • Tile Number: noses[mii.noseType]

Bring my Mii to life!!

Ok, so we've used the above to draw a static version of our mii exactly the way it looks as if a picture was taken of it... but what if i want it to show some life... blink, and or better yet, be able to change expressions based on game play. PIECE OF CAKE!!!

  • Because we are efficient coders, we've put all the above mii building code into it's own function and then when we want to build a mii, we call the function, pass a few variables to it, and it builds up our mii and stores it as an image that we can then later display.
  • Normally, that function just contains the code to draw the default parts that libmii tells us are in our mii. BUT if we passed a few extra variables to our build mii function, we could have it draw our mii with a random smile face or a random sad face to vary expressions... or we could cause it to draw our mii with the eyes closed to allow us to have our mii blink.

To do this, we just need to add those few extra variables to the function maybe making it so if the values are 0, draw the static default version of your mii, and if the values are something else, draw different lips or different eyes to vary expressions.

Make Sense?

  • STILL DOESN'T MAKE SENSE? Just check out the example!!! (it's using GRRLIB) It has code to draw all 100 of your miis statically and code to make your mii blink, give a random happy face, and give a random sad face. The possibilities are pretty much endless!
  • STILL STILL STILL DOESN'T MAKE SENSE? You can email me or find me on the wiibrew forums or in the irc channels #wiidev, #wiihelp, and #grrlib on EFNET... I'm happy to help!
Personal tools
Resources
Community