diff --git a/source/Metaphrasis.cpp b/source/Metaphrasis.cpp
new file mode 100644
index 00000000..cc83cfcc
--- /dev/null
+++ b/source/Metaphrasis.cpp
@@ -0,0 +1,383 @@
+/*
+ * Metaphrasis is a static conversion class for transforming RGBA image
+ * buffers into verious GX texture formats for Wii homebrew development.
+ * Copyright (C) 2008 Armin Tamzarian
+ *
+ * This file is part of Metaphrasis.
+ *
+ * Metaphrasis is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Metaphrasis 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Metaphrasis. If not, see .
+ */
+
+#include "Metaphrasis.h"
+
+/**
+ * Default constructor for the Metaphrasis class.
+ */
+
+Metaphrasis::Metaphrasis() {
+}
+
+/**
+ * Default destructor for the Metaphrasis class.
+ */
+
+Metaphrasis::~Metaphrasis() {
+}
+
+/**
+ * Convert the specified RGBA data buffer into the I4 texture format
+ *
+ * This routine converts the RGBA data buffer into the I4 texture format and returns a pointer to the converted buffer.
+ *
+ * @param rgbaBuffer Buffer containing the temporarily rendered RGBA data.
+ * @param bufferWidth Pixel width of the data buffer.
+ * @param bufferHeight Pixel height of the data buffer.
+ * @return A pointer to the allocated buffer.
+ */
+
+uint32_t* Metaphrasis::convertBufferToI4(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight) {
+ uint32_t bufferSize = bufferWidth * bufferHeight >> 1;
+ uint32_t* dataBufferI4 = (uint32_t *)memalign(32, bufferSize);
+ memset(dataBufferI4, 0x00, bufferSize);
+
+ uint32_t *src = (uint32_t *)rgbaBuffer;
+ uint8_t *dst = (uint8_t *)dataBufferI4;
+
+ for(uint16_t y = 0; y < bufferHeight; y += 8) {
+ for(uint16_t x = 0; x < bufferWidth; x += 8) {
+ for(uint16_t rows = 0; rows < 8; rows++) {
+ *dst++ = (src[((y + rows) * bufferWidth) + (x + 0)] & 0xf0) | ((src[((y + rows) * bufferWidth) + (x + 1)] & 0xf0) >> 4);
+ *dst++ = (src[((y + rows) * bufferWidth) + (x + 2)] & 0xf0) | ((src[((y + rows) * bufferWidth) + (x + 3)] & 0xf0) >> 4);
+ *dst++ = (src[((y + rows) * bufferWidth) + (x + 4)] & 0xf0) | ((src[((y + rows) * bufferWidth) + (x + 5)] & 0xf0) >> 4);
+ *dst++ = (src[((y + rows) * bufferWidth) + (x + 5)] & 0xf0) | ((src[((y + rows) * bufferWidth) + (x + 7)] & 0xf0) >> 4);
+ }
+ }
+ }
+ DCFlushRange(dataBufferI4, bufferSize);
+
+ return dataBufferI4;
+}
+
+/**
+ * Convert the specified RGBA data buffer into the I8 texture format
+ *
+ * This routine converts the RGBA data buffer into the I8 texture format and returns a pointer to the converted buffer.
+ *
+ * @param rgbaBuffer Buffer containing the temporarily rendered RGBA data.
+ * @param bufferWidth Pixel width of the data buffer.
+ * @param bufferHeight Pixel height of the data buffer.
+ * @return A pointer to the allocated buffer.
+ */
+
+uint32_t* Metaphrasis::convertBufferToI8(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight) {
+ uint32_t bufferSize = bufferWidth * bufferHeight;
+ uint32_t* dataBufferI8 = (uint32_t *)memalign(32, bufferSize);
+ memset(dataBufferI8, 0x00, bufferSize);
+
+ uint32_t *src = (uint32_t *)rgbaBuffer;
+ uint8_t *dst = (uint8_t *)dataBufferI8;
+
+ for(uint16_t y = 0; y < bufferHeight; y += 4) {
+ for(uint16_t x = 0; x < bufferWidth; x += 8) {
+ for(uint16_t rows = 0; rows < 4; rows++) {
+ *dst++ = src[((y + rows) * bufferWidth) + (x + 0)] & 0xff;
+ *dst++ = src[((y + rows) * bufferWidth) + (x + 1)] & 0xff;
+ *dst++ = src[((y + rows) * bufferWidth) + (x + 2)] & 0xff;
+ *dst++ = src[((y + rows) * bufferWidth) + (x + 3)] & 0xff;
+ *dst++ = src[((y + rows) * bufferWidth) + (x + 4)] & 0xff;
+ *dst++ = src[((y + rows) * bufferWidth) + (x + 5)] & 0xff;
+ *dst++ = src[((y + rows) * bufferWidth) + (x + 6)] & 0xff;
+ *dst++ = src[((y + rows) * bufferWidth) + (x + 7)] & 0xff;
+ }
+ }
+ }
+ DCFlushRange(dataBufferI8, bufferSize);
+
+ return dataBufferI8;
+}
+
+/**
+ * Downsample the specified RGBA value data buffer to an IA4 value.
+ *
+ * This routine downsamples the given RGBA data value into the IA4 texture data format.
+ *
+ * @param rgba A 32-bit RGBA value to convert to the IA4 format.
+ * @return The IA4 value of the given RGBA value.
+ */
+
+uint8_t Metaphrasis::convertRGBAToIA4(uint32_t rgba) {
+ uint8_t i, a;
+
+ i = (rgba >> 8) & 0xf0;
+ a = (rgba ) & 0xff;
+
+ return i | (a >> 4);
+}
+
+/**
+ * Convert the specified RGBA data buffer into the IA4 texture format
+ *
+ * This routine converts the RGBA data buffer into the IA4 texture format and returns a pointer to the converted buffer.
+ *
+ * @param rgbaBuffer Buffer containing the temporarily rendered RGBA data.
+ * @param bufferWidth Pixel width of the data buffer.
+ * @param bufferHeight Pixel height of the data buffer.
+ * @return A pointer to the allocated buffer.
+ */
+
+uint32_t* Metaphrasis::convertBufferToIA4(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight) {
+ uint32_t bufferSize = bufferWidth * bufferHeight;
+ uint32_t* dataBufferIA4 = (uint32_t *)memalign(32, bufferSize);
+ memset(dataBufferIA4, 0x00, bufferSize);
+
+ uint32_t *src = (uint32_t *)rgbaBuffer;
+ uint8_t *dst = (uint8_t *)dataBufferIA4;
+
+ for(uint16_t y = 0; y < bufferHeight; y += 4) {
+ for(uint16_t x = 0; x < bufferWidth; x += 8) {
+ for(uint16_t rows = 0; rows < 4; rows++) {
+ *dst++ = Metaphrasis::convertRGBAToIA4(src[((y + rows) * bufferWidth) + (x + 0)]);
+ *dst++ = Metaphrasis::convertRGBAToIA4(src[((y + rows) * bufferWidth) + (x + 1)]);
+ *dst++ = Metaphrasis::convertRGBAToIA4(src[((y + rows) * bufferWidth) + (x + 2)]);
+ *dst++ = Metaphrasis::convertRGBAToIA4(src[((y + rows) * bufferWidth) + (x + 3)]);
+ *dst++ = Metaphrasis::convertRGBAToIA4(src[((y + rows) * bufferWidth) + (x + 4)]);
+ *dst++ = Metaphrasis::convertRGBAToIA4(src[((y + rows) * bufferWidth) + (x + 5)]);
+ *dst++ = Metaphrasis::convertRGBAToIA4(src[((y + rows) * bufferWidth) + (x + 6)]);
+ *dst++ = Metaphrasis::convertRGBAToIA4(src[((y + rows) * bufferWidth) + (x + 7)]);
+ }
+ }
+ }
+ DCFlushRange(dataBufferIA4, bufferSize);
+
+ return dataBufferIA4;
+}
+
+/**
+ * Downsample the specified RGBA value data buffer to an IA8 value.
+ *
+ * This routine downsamples the given RGBA data value into the IA8 texture data format.
+ *
+ * @param rgba A 32-bit RGBA value to convert to the IA8 format.
+ * @return The IA8 value of the given RGBA value.
+ */
+
+uint16_t Metaphrasis::convertRGBAToIA8(uint32_t rgba) {
+ uint8_t i, a;
+
+ i = (rgba >> 8) & 0xff;
+ a = (rgba ) & 0xff;
+
+ return (i << 8) | a;
+}
+
+/**
+ * Convert the specified RGBA data buffer into the IA8 texture format
+ *
+ * This routine converts the RGBA data buffer into the IA8 texture format and returns a pointer to the converted buffer.
+ *
+ * @param rgbaBuffer Buffer containing the temporarily rendered RGBA data.
+ * @param bufferWidth Pixel width of the data buffer.
+ * @param bufferHeight Pixel height of the data buffer.
+ * @return A pointer to the allocated buffer.
+ */
+
+uint32_t* Metaphrasis::convertBufferToIA8(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight) {
+ uint32_t bufferSize = (bufferWidth * bufferHeight) << 1;
+ uint32_t* dataBufferIA8 = (uint32_t *)memalign(32, bufferSize);
+ memset(dataBufferIA8, 0x00, bufferSize);
+
+ uint32_t *src = (uint32_t *)rgbaBuffer;
+ uint16_t *dst = (uint16_t *)dataBufferIA8;
+
+ for(uint16_t y = 0; y < bufferHeight; y += 4) {
+ for(uint16_t x = 0; x < bufferWidth; x += 4) {
+ for(uint16_t rows = 0; rows < 4; rows++) {
+ *dst++ = Metaphrasis::convertRGBAToIA8(src[((y + rows) * bufferWidth) + (x + 0)]);
+ *dst++ = Metaphrasis::convertRGBAToIA8(src[((y + rows) * bufferWidth) + (x + 1)]);
+ *dst++ = Metaphrasis::convertRGBAToIA8(src[((y + rows) * bufferWidth) + (x + 2)]);
+ *dst++ = Metaphrasis::convertRGBAToIA8(src[((y + rows) * bufferWidth) + (x + 3)]);
+ }
+ }
+ }
+ DCFlushRange(dataBufferIA8, bufferSize);
+
+ return dataBufferIA8;
+}
+
+/**
+ * Convert the specified RGBA data buffer into the RGBA8 texture format
+ *
+ * This routine converts the RGBA data buffer into the RGBA8 texture format and returns a pointer to the converted buffer.
+ *
+ * @param rgbaBuffer Buffer containing the temporarily rendered RGBA data.
+ * @param bufferWidth Pixel width of the data buffer.
+ * @param bufferHeight Pixel height of the data buffer.
+ * @return A pointer to the allocated buffer.
+ */
+
+uint32_t* Metaphrasis::convertBufferToRGBA8(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight) {
+ uint32_t bufferSize = (bufferWidth * bufferHeight) << 2;
+ uint32_t* dataBufferRGBA8 = (uint32_t *)memalign(32, bufferSize);
+ memset(dataBufferRGBA8, 0x00, bufferSize);
+
+ uint8_t *src = (uint8_t *)rgbaBuffer;
+ uint8_t *dst = (uint8_t *)dataBufferRGBA8;
+
+ for(uint16_t block = 0; block < bufferHeight; block += 4) {
+ for(uint16_t i = 0; i < bufferWidth; i += 4) {
+ for (uint16_t c = 0; c < 4; c++) {
+ for (uint16_t ar = 0; ar < 4; ar++) {
+ *dst++ = src[(((i + ar) + ((block + c) * bufferWidth)) * 4) + 3];
+ *dst++ = src[((i + ar) + ((block + c) * bufferWidth)) * 4];
+ }
+ }
+ for (uint16_t c = 0; c < 4; c++) {
+ for (uint16_t gb = 0; gb < 4; gb++) {
+ *dst++ = src[(((i + gb) + ((block + c) * bufferWidth)) * 4) + 1];
+ *dst++ = src[(((i + gb) + ((block + c) * bufferWidth)) * 4) + 2];
+ }
+ }
+ }
+ }
+ DCFlushRange(dataBufferRGBA8, bufferSize);
+
+ return dataBufferRGBA8;
+}
+
+/**
+ * Downsample the specified RGBA value data buffer to an RGB565 value.
+ *
+ * This routine downsamples the given RGBA data value into the RGB565 texture data format.
+ * Attribution for this routine is given fully to NoNameNo of GRRLIB Wii library.
+ *
+ * @param rgba A 32-bit RGBA value to convert to the RGB565 format.
+ * @return The RGB565 value of the given RGBA value.
+ */
+
+uint16_t Metaphrasis::convertRGBAToRGB565(uint32_t rgba) {
+ uint8_t r, g, b;
+
+ r = (((rgba >> 24) & 0xff) * 31) / 255;
+ g = (((rgba >> 16) & 0xff) * 63) / 255;
+ b = (((rgba >> 8) & 0xff) * 31) / 255;
+
+ return (((r << 6) | g ) << 5 ) | b;
+}
+
+/**
+ * Convert the specified RGBA data buffer into the RGB565 texture format
+ *
+ * This routine converts the RGBA data buffer into the RGB565 texture format and returns a pointer to the converted buffer.
+ *
+ * @param rgbaBuffer Buffer containing the temporarily rendered RGBA data.
+ * @param bufferWidth Pixel width of the data buffer.
+ * @param bufferHeight Pixel height of the data buffer.
+ * @return A pointer to the allocated buffer.
+ */
+
+uint32_t* Metaphrasis::convertBufferToRGB565(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight) {
+ uint32_t bufferSize = (bufferWidth * bufferHeight) << 1;
+ uint32_t* dataBufferRGB565 = (uint32_t *)memalign(32, bufferSize);
+ memset(dataBufferRGB565, 0x00, bufferSize);
+
+ uint32_t *src = (uint32_t *)rgbaBuffer;
+ uint16_t *dst = (uint16_t *)dataBufferRGB565;
+
+ for(uint16_t y = 0; y < bufferHeight; y += 4) {
+ for(uint16_t x = 0; x < bufferWidth; x += 4) {
+ for(uint16_t rows = 0; rows < 4; rows++) {
+ *dst++ = Metaphrasis::convertRGBAToRGB565(src[((y + rows) * bufferWidth) + (x + 0)]);
+ *dst++ = Metaphrasis::convertRGBAToRGB565(src[((y + rows) * bufferWidth) + (x + 1)]);
+ *dst++ = Metaphrasis::convertRGBAToRGB565(src[((y + rows) * bufferWidth) + (x + 2)]);
+ *dst++ = Metaphrasis::convertRGBAToRGB565(src[((y + rows) * bufferWidth) + (x + 3)]);
+ }
+ }
+ }
+ DCFlushRange(dataBufferRGB565, bufferSize);
+
+ return dataBufferRGB565;
+}
+
+/**
+ * Downsample the specified RGBA value data buffer to an RGB5A3 value.
+ *
+ * This routine downsamples the given RGBA data value into the RGB5A3 texture data format.
+ * Attribution for this routine is given fully to WiiGator via the TehSkeen forum.
+ *
+ * @param rgba A 32-bit RGBA value to convert to the RGB5A3 format.
+ * @return The RGB5A3 value of the given RGBA value.
+ */
+
+uint16_t Metaphrasis::convertRGBAToRGB5A3(uint32_t rgba) {
+ uint32_t r, g, b, a;
+ uint16_t color;
+
+ r = (rgba >> 24) & 0xff;
+ g = (rgba >> 16) & 0xff;
+ b = (rgba >> 8) & 0xff;
+ a = (rgba ) & 0xff;
+
+ if (a > 0xe0) {
+ r = r >> 3;
+ g = g >> 3;
+ b = b >> 3;
+
+ color = (r << 10) | (g << 5) | b;
+ color |= 0x8000;
+ }
+ else {
+ r = r >> 4;
+ g = g >> 4;
+ b = b >> 4;
+ a = a >> 5;
+
+ color = (a << 12) | (r << 8) | (g << 4) | b;
+ }
+
+ return color;
+}
+
+/**
+ * Convert the specified RGBA data buffer into the RGB5A3 texture format
+ *
+ * This routine converts the RGBA data buffer into the RGB5A3 texture format and returns a pointer to the converted buffer.
+ *
+ * @param rgbaBuffer Buffer containing the temporarily rendered RGBA data.
+ * @param bufferWidth Pixel width of the data buffer.
+ * @param bufferHeight Pixel height of the data buffer.
+ * @return A pointer to the allocated buffer.
+ */
+
+uint32_t* Metaphrasis::convertBufferToRGB5A3(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight) {
+ uint32_t bufferSize = (bufferWidth * bufferHeight) << 1;
+ uint32_t* dataBufferRGB5A3 = (uint32_t *)memalign(32, bufferSize);
+ memset(dataBufferRGB5A3, 0x00, bufferSize);
+
+ uint32_t *src = (uint32_t *)rgbaBuffer;
+ uint16_t *dst = (uint16_t *)dataBufferRGB5A3;
+
+ for(uint16_t y = 0; y < bufferHeight; y += 4) {
+ for(uint16_t x = 0; x < bufferWidth; x += 4) {
+ for(uint16_t rows = 0; rows < 4; rows++) {
+ *dst++ = Metaphrasis::convertRGBAToRGB5A3(src[((y + rows) * bufferWidth) + (x + 0)]);
+ *dst++ = Metaphrasis::convertRGBAToRGB5A3(src[((y + rows) * bufferWidth) + (x + 1)]);
+ *dst++ = Metaphrasis::convertRGBAToRGB5A3(src[((y + rows) * bufferWidth) + (x + 2)]);
+ *dst++ = Metaphrasis::convertRGBAToRGB5A3(src[((y + rows) * bufferWidth) + (x + 3)]);
+ }
+ }
+ }
+ DCFlushRange(dataBufferRGB5A3, bufferSize);
+
+ return dataBufferRGB5A3;
+}
diff --git a/source/Metaphrasis.h b/source/Metaphrasis.h
new file mode 100644
index 00000000..4ca88713
--- /dev/null
+++ b/source/Metaphrasis.h
@@ -0,0 +1,116 @@
+/*
+ * Metaphrasis is a static conversion class for transforming RGBA image
+ * buffers into verious GX texture formats for Wii homebrew development.
+ * Copyright (C) 2008 Armin Tamzarian
+ *
+ * This file is part of Metaphrasis.
+ *
+ * Metaphrasis is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Metaphrasis 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Metaphrasis. If not, see .
+ */
+
+/** \mainpage Metaphrasis
+ *
+ * \section sec_intro Introduction
+ *
+ * Metaphrasis is a static conversion class for transforming RGBA image buffers into verious GX texture formats for Wii homebrew development.
+ *
+ * Metaphrasis is written in C++ and makes use of a community standard and newly developed algorithms for conversion of 32-bit RGBA data buffers into various GX texture formats common to both the Gamecube and Wii platforms.
+ *
+ * This library was developed in-full by Armin Tamzarian with the support of developers in \#wiibrew on EFnet, Chaosteil of libwiisprite, and DrTwox of GRRLIB.
+ *
+ * \section sec_installation_source Installation (Source Code)
+ *
+ * -# Extract the Metaphrasis archive.
+ * -# Copy the contents of the src directory into your project's development path.
+ * -# Include the Metaphrasis header file in your code using syntax such as the following:
+ * \code
+ * #include "Metaphrasis.h"
+ * \endcode
+ *
+ * \section sec_installation_library Installation (Library)
+ *
+ * -# Extract the Metaphrasis archive.
+ * -# Copy the contents of the lib directory into your devKitPro/libogc directory.
+ * -# Include the Metaphrasis header file in your code using syntax such as the following:
+ * \code
+ * #include "Metaphrasis.h"
+ * \endcode
+ *
+ * \section sec_usage Usage
+ *
+ * -# Create a buffer full of 32-bit RGBA values noting both the pixel height and width of the buffer.
+ * -# Call one of the many conversion routines from within your code. (Note: All methods within the Metaphrasis class are static and thus no class instance need be allocated)
+ * \code
+ * uint32_t* rgba8Buffer = Metaphrasis::convertBufferToRGBA8(rgbaBuffer, bufferWidth, bufferHeight);
+ * \endcode
+ * -# Free your temporary RGBA value buffer if you no longer need said values.
+ *
+ * Currently supported conversion routines are as follows:
+ * \li convertBufferToI4
+ * \li convertBufferToI8
+ * \li convertBufferToIA4
+ * \li convertBufferToIA8
+ * \li convertBufferToRGBA8
+ * \li convertBufferToRGB565
+ * \li convertBufferToRGB5A3
+ *
+ * \section sec_license License
+ *
+ * Metaphrasis is distributed under the GNU Lesser General Public License.
+ *
+ * \section sec_contact Contact
+ *
+ * If you have any suggestions, questions, or comments regarding this library feel free to e-mail me at tamzarian1989 [at] gmail [dawt] com.
+ */
+
+#ifndef METAPHRASIS_H_
+#define METAPHRASIS_H_
+
+#include
+#include
+#include
+#include
+
+/*! \class Metaphrasis
+ * \brief A static conversion class for transforming RGBA image buffers into verious GX texture formats for
+ * Wii homebrew development.
+ * \author Armin Tamzarian
+ * \version 0.1.0
+ *
+ * Metaphrasis is a static conversion class for transforming RGBA image buffers into verious GX texture formats for
+ * Wii homebrew development. Metaphrasis is written in C++ and makes use of a community standard and newly developed
+ * algorithms for conversion of 32-bit RGBA data buffers into various GX texture formats common to both the Gamecube
+ * and Wii platforms.
+ */
+class Metaphrasis {
+ public:
+ Metaphrasis();
+ virtual ~Metaphrasis();
+
+ static uint32_t* convertBufferToI4(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight);
+ static uint32_t* convertBufferToI8(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight);
+ static uint32_t* convertBufferToIA4(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight);
+ static uint32_t* convertBufferToIA8(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight);
+ static uint32_t* convertBufferToRGBA8(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight);
+ static uint32_t* convertBufferToRGB565(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight);
+ static uint32_t* convertBufferToRGB5A3(uint32_t* rgbaBuffer, uint16_t bufferWidth, uint16_t bufferHeight);
+
+ static uint8_t convertRGBAToIA4(uint32_t rgba);
+ static uint16_t convertRGBAToIA8(uint32_t rgba);
+ static uint16_t convertRGBAToRGB565(uint32_t rgba);
+ static uint16_t convertRGBAToRGB5A3(uint32_t rgba);
+
+};
+
+#endif /*METAPHRASIS_H_*/
diff --git a/source/video.cpp b/source/video.cpp
index 33f257e6..afa8344c 100644
--- a/source/video.cpp
+++ b/source/video.cpp
@@ -262,7 +262,7 @@ void Menu_DrawImg(f32 xpos, f32 ypos, f32 zpos, f32 width, f32 height, u8 data[]
height*=.5;
guMtxIdentity (m1);
guMtxScaleApply(m1,m1,scaleX,scaleY,1.0);
- Vector axis = (Vector) {0 , 0, 1 };
+ guVector axis = (guVector) {0 , 0, 1 };
guMtxRotAxisDeg (m2, &axis, degrees);
// guMtxConcat(m2,m1,m);
guMtxConcat(m1,m2,m);
@@ -311,7 +311,7 @@ void Menu_DrawRectangle(f32 x, f32 y, f32 width, f32 height, GXColor color, u8 f
int i;
f32 x2 = x+width;
f32 y2 = y+height;
- Vector v[] = {{x,y,0.0f}, {x2,y,0.0f}, {x2,y2,0.0f}, {x,y2,0.0f}, {x,y,0.0f}};
+ guVector v[] = {{x,y,0.0f}, {x2,y,0.0f}, {x2,y2,0.0f}, {x,y2,0.0f}, {x,y,0.0f}};
if(!filled)
{
@@ -362,9 +362,9 @@ void Menu_DrawDiskCover(f32 xpos, f32 ypos, f32 zpos, u16 width, u16 height, u16
guMtxIdentity (m1);
guMtxScaleApply(m1,m1,scaleX,scaleY,1.0);
- Vector axis2 = (Vector) {0 , 1, 0 };
+ guVector axis2 = (guVector) {0 , 1, 0 };
guMtxRotAxisDeg (m2, &axis2, deg_beta);
- Vector axis = (Vector) {0 , 0, 1 };
+ guVector axis = (guVector) {0 , 0, 1 };
guMtxRotAxisDeg (m3, &axis, deg_alpha);
// guMtxConcat(m2,m1,m);
guMtxConcat(m3,m4,m3); // move distance then rotate z-axis