Directly use files from libgui

Dockerfile

@@ -1,5 +1,3 @@
-FROM wiiuenv/devkitppc:20211229
+FROM ghcr.io/wiiu-env/devkitppc:20240704
-
-COPY --from=wiiuenv/libgui:20220109 /artifacts $DEVKITPRO
 
 WORKDIR project

Makefile

@@ -25,8 +25,11 @@ SOURCES		:=	src \
 				src/gui \
 				src/menu \
 				src/resources \
+				src/sounds \
 				src/system \
-				src/utils
+				src/utils \
+				src/video \
+				src/video/shaders
 DATA		:=	data \
 				data/images \
 				data/sounds \
@@ -46,7 +49,7 @@ CXXFLAGS	:= $(CFLAGS)
 ASFLAGS	:=	-g $(ARCH)
 LDFLAGS	=	-g $(ARCH) $(RPXSPECS) -Wl,-Map,$(notdir $*.map)
 
-LIBS	:=  -lgui -lfreetype -lgd -lpng -ljpeg -lz -lmad -lvorbisidec -logg -lbz2 -lwut 
+LIBS	:=  -lfreetype -lgd -lpng -ljpeg -lz -lmad -lvorbisidec -logg -lbz2 -lwut 
 
 #-------------------------------------------------------------------------------
 # list of directories containing libraries, this must be the top level
@@ -105,7 +108,7 @@ export LIBPATHS	:=	$(foreach dir,$(LIBDIRS),-L$(dir)/lib)
 all: $(BUILD)
 
 $(BUILD):
-	@[ -d $@ ] || mkdir -p $@
+	@$(shell [ ! -d $(BUILD) ] && mkdir -p $(BUILD))
 	@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
 
 #-------------------------------------------------------------------------------

src/Application.cpp

@@ -25,8 +25,8 @@
 #include <gui/VPadController.h>
 #include <gui/WPadController.h>
 #include "resources/Resources.h"
-#include <gui/sounds/SoundHandler.hpp>
+#include <sounds/SoundHandler.hpp>
-#include <gui/memory.h>
+#include "system/memory.h"
 #include "utils/logger.h"
 #include "utils/AsyncExecutor.h"
 #include <thread>

src/Application.h

@@ -18,7 +18,7 @@
 #define _APPLICATION_H
 
 #include "menu/MainWindow.h"
-#include <gui/video/CVideo.h>
+#include <video/CVideo.h>
 #include "system/CThread.h"
 
 // forward declaration

src/StorageUtils.cpp

@@ -0,0 +1,143 @@
+#include <cstdlib>
+#include <malloc.h>
+#include "utils/logger.h"
+
+#include "StorageUtils.h"
+
+#include <coreinit/thread.h>
+#include <coreinit/title.h>
+#include <nn/acp/save.h>
+#include <nn/spm.h>
+#include <nsysuhs/uhs.h>
+#include <sysapp/title.h>
+
+static void InitEmptyExternalStorage() {
+    DEBUG_FUNCTION_LINE("Fallback to empty ExtendedStorage");
+    nn::spm::VolumeId empty{};
+    nn::spm::SetDefaultExtendedStorageVolumeId(empty);
+
+    nn::spm::StorageIndex storageIndex = 0;
+    nn::spm::SetExtendedStorage(&storageIndex);
+}
+
+static int numberUSBStorageDevicesConnected() {
+    DEBUG_FUNCTION_LINE("Check if USB Storage is connected");
+    auto *handle = (UhsHandle *) memalign(0x40, sizeof(UhsHandle));
+    if (!handle) {
+        return -1;
+    }
+    memset(handle, 0, sizeof(UhsHandle));
+    auto *config = (UhsConfig *) memalign(0x40, sizeof(UhsConfig));
+    if (!config) {
+        free(handle);
+        return -2;
+    }
+    memset(config, 0, sizeof(UhsConfig));
+
+    config->controller_num = 0;
+    uint32_t size          = 5120;
+    void *buffer           = memalign(0x40, size);
+    if (!buffer) {
+        free(handle);
+        free(config);
+        return -3;
+    }
+    memset(buffer, 0, size);
+
+    config->buffer      = buffer;
+    config->buffer_size = size;
+
+    if (UhsClientOpen(handle, config) != UHS_STATUS_OK) {
+        DEBUG_FUNCTION_LINE("UhsClient failed");
+        free(handle);
+        free(config);
+        free(buffer);
+        return -4;
+    }
+
+    UhsInterfaceProfile profiles[10];
+    UhsInterfaceFilter filter = {
+            .match_params = MATCH_ANY};
+
+    UHSStatus result;
+    if ((result = UhsQueryInterfaces(handle, &filter, profiles, 10)) <= UHS_STATUS_OK) {
+        DEBUG_FUNCTION_LINE("UhsQueryInterfaces failed");
+        UhsClientClose(handle);
+        free(handle);
+        free(config);
+        free(buffer);
+        return -5;
+    }
+
+    auto found = 0;
+    for (int i = 0; i < (int) result; i++) {
+        if (profiles[i].if_desc.bInterfaceClass == USBCLASS_STORAGE) {
+            DEBUG_FUNCTION_LINE("Found USBCLASS_STORAGE");
+            found++;
+        }
+    }
+
+    UhsClientClose(handle);
+    free(handle);
+    free(config);
+    free(buffer);
+    return found;
+}
+
+void initExternalStorage() {
+    if (OSGetTitleID() == _SYSGetSystemApplicationTitleId(SYSTEM_APP_ID_MII_MAKER)) {
+        // nn::spm functions always call OSFatal when they fail, so we make sure have permission to use
+        // the lib before actually using it.
+        return;
+    }
+    int connectedStorage = 0;
+    if ((connectedStorage = numberUSBStorageDevicesConnected()) <= 0) {
+        nn::spm::Initialize();
+        InitEmptyExternalStorage();
+        nn::spm::Finalize();
+        return;
+    }
+
+    DEBUG_FUNCTION_LINE("Connected StorageDevices = %d", connectedStorage);
+
+    nn::spm::Initialize();
+
+    nn::spm::StorageListItem items[0x20];
+    int tries  = 0;
+    bool found = false;
+
+    while (tries < 1200) { // Wait up to 20 seconds, like the Wii U Menu
+        int32_t numItems = nn::spm::GetStorageList(items, 0x20);
+
+        DEBUG_FUNCTION_LINE("Number of items: %d", numItems);
+
+        for (int32_t i = 0; i < numItems; i++) {
+            if (items[i].type == nn::spm::STORAGE_TYPE_WFS) {
+                nn::spm::StorageInfo info{};
+                if (nn::spm::GetStorageInfo(&info, &items[i].index) == 0) {
+                    DEBUG_FUNCTION_LINE("Using %s for extended storage", info.path);
+
+                    nn::spm::SetExtendedStorage(&items[i].index);
+                    ACPMountExternalStorage();
+
+                    nn::spm::SetDefaultExtendedStorageVolumeId(info.volumeId);
+
+                    found = true;
+                    break;
+                }
+            }
+        }
+        if (found || (connectedStorage == numItems)) {
+            DEBUG_FUNCTION_LINE("Found all expected items, breaking.");
+            break;
+        }
+        OSSleepTicks(OSMillisecondsToTicks(16));
+        tries++;
+    }
+    if (!found) {
+        DEBUG_FUNCTION_LINE("USB Storage is connected but either it doesn't have a WFS partition or we ran into a timeout.");
+        InitEmptyExternalStorage();
+    }
+
+    nn::spm::Finalize();
+}

src/StorageUtils.h

@@ -0,0 +1,3 @@
+#pragma once
+
+void initExternalStorage();

src/entry.cpp

@@ -4,6 +4,7 @@
 #include <whb/log_module.h>
 #include "utils/logger.h"
 #include "Application.h"
+#include "StorageUtils.h"
 
 int32_t main(int32_t argc, char **argv) {
     bool moduleInit;
@@ -14,8 +15,11 @@ int32_t main(int32_t argc, char **argv) {
         cafeInit = WHBLogCafeInit();
         udpInit = WHBLogUdpInit();
     }
+
     DEBUG_FUNCTION_LINE("Starting launchiine " LAUNCHIINE_VERSION "");
 
+    initExternalStorage();
+
     DEBUG_FUNCTION_LINE("Start main application");
     Application::instance()->exec();
 

src/fs/CFile.cpp

@@ -1,13 +1,13 @@
 
-#include <stdarg.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <strings.h>
 #include <fs/CFile.hpp>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <strings.h>
 
 CFile::CFile() {
     iFd      = -1;
-    mem_file = nullptr;
+    mem_file = NULL;
     filesize = 0;
     pos      = 0;
 }
@@ -54,8 +54,9 @@ int32_t CFile::open(const std::string &filepath, eOpenTypes mode) {
     //! the .data sections which is needed for a normal application to re-init
     //! this will be added with launching as RPX
     iFd = ::open(filepath.c_str(), openMode);
-    if (iFd < 0)
+    if (iFd < 0) {
         return iFd;
+    }
 
 
     filesize = ::lseek(iFd, 0, SEEK_END);
@@ -74,11 +75,12 @@ int32_t CFile::open(const uint8_t *mem, int32_t size) {
 }
 
 void CFile::close() {
-    if (iFd >= 0)
+    if (iFd >= 0) {
         ::close(iFd);
+    }
 
     iFd      = -1;
-    mem_file = nullptr;
+    mem_file = NULL;
     filesize = 0;
     pos      = 0;
 }
@@ -86,20 +88,23 @@ void CFile::close() {
 int32_t CFile::read(uint8_t *ptr, size_t size) {
     if (iFd >= 0) {
         int32_t ret = ::read(iFd, ptr, size);
-        if (ret > 0)
+        if (ret > 0) {
             pos += ret;
+        }
         return ret;
     }
 
     int32_t readsize = size;
 
-    if (readsize > (int64_t) (filesize - pos))
+    if (readsize > (int64_t) (filesize - pos)) {
         readsize = filesize - pos;
+    }
 
-    if (readsize <= 0)
+    if (readsize <= 0) {
         return readsize;
+    }
 
-    if (mem_file != nullptr) {
+    if (mem_file != NULL) {
         memcpy(ptr, mem_file + pos, readsize);
         pos += readsize;
         return readsize;
@@ -113,8 +118,9 @@ int32_t CFile::write(const uint8_t *ptr, size_t size) {
         size_t done = 0;
         while (done < size) {
             int32_t ret = ::write(iFd, ptr, size - done);
-            if (ret <= 0)
+            if (ret <= 0) {
                 return ret;
+            }
 
             ptr += ret;
             done += ret;
@@ -144,10 +150,11 @@ int32_t CFile::seek(long int offset, int32_t origin) {
         pos = newPos;
     }
 
-    if (iFd >= 0)
+    if (iFd >= 0) {
         ret = ::lseek(iFd, pos, SEEK_SET);
+    }
 
-    if (mem_file != nullptr) {
+    if (mem_file != NULL) {
         if (pos > filesize) {
             pos = filesize;
         }
@@ -171,5 +178,3 @@ int32_t CFile::fwrite(const char *format, ...) {
 
     return result;
 }
-
-

src/fs/CFile.hpp

@@ -1,10 +1,10 @@
 #ifndef CFILE_HPP_
 #define CFILE_HPP_
 
-#include <stdio.h>
-#include <string>
-#include <string.h>
 #include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <string>
 #include <unistd.h>
 #include <wut_types.h>
 
@@ -30,11 +30,13 @@ public:
     int32_t open(const uint8_t *memory, int32_t memsize);
 
     BOOL isOpen() const {
-        if (iFd >= 0)
+        if (iFd >= 0) {
             return true;
+        }
 
-        if (mem_file)
+        if (mem_file) {
             return true;
+        }
 
         return false;
     }

src/gui/FreeTypeGX.cpp

@@ -0,0 +1,569 @@
+/*
+ * FreeTypeGX is a wrapper class for libFreeType which renders a compiled
+ * FreeType parsable font so a GX texture for Wii homebrew development.
+ * Copyright (C) 2008 Armin Tamzarian
+ * Modified by Dimok, 2015 for WiiU GX2
+ *
+ * This file is part of FreeTypeGX.
+ *
+ * FreeTypeGX 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.
+ *
+ * FreeTypeGX 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 FreeTypeGX.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <gui/FreeTypeGX.h>
+#include <video/CVideo.h>
+#include <video/shaders/Texture2DShader.h>
+
+using namespace std;
+
+#define ALIGN4(x) (((x) + 3) & ~3)
+
+/**
+ * Default constructor for the FreeTypeGX class.
+ */
+FreeTypeGX::FreeTypeGX(const uint8_t *fontBuffer, FT_Long bufferSize, bool lastFace) {
+    int32_t faceIndex = 0;
+    GX2InitSampler(&ftSampler, GX2_TEX_CLAMP_MODE_CLAMP_BORDER, GX2_TEX_XY_FILTER_MODE_LINEAR);
+
+    FT_Init_FreeType(&ftLibrary);
+    faceMutex.lock();
+    if (lastFace) {
+
+        FT_New_Memory_Face(ftLibrary, (FT_Byte *) fontBuffer, bufferSize, -1, &ftFace);
+        faceIndex = ftFace->num_faces - 1; // Use the last face
+        FT_Done_Face(ftFace);
+        ftFace = NULL;
+    }
+    FT_New_Memory_Face(ftLibrary, (FT_Byte *) fontBuffer, bufferSize, faceIndex, &ftFace);
+
+    ftKerningEnabled = FT_HAS_KERNING(ftFace);
+    faceMutex.unlock();
+}
+
+/**
+ * Default destructor for the FreeTypeGX class.
+ */
+FreeTypeGX::~FreeTypeGX() {
+    unloadFont();
+
+    faceMutex.lock();
+    FT_Done_Face(ftFace);
+    faceMutex.unlock();
+    FT_Done_FreeType(ftLibrary);
+}
+
+/**
+ * Convert a short char string to a wide char string.
+ *
+ * This routine converts a supplied short character string into a wide character string.
+ * Note that it is the user's responsibility to clear the returned buffer once it is no longer needed.
+ *
+ * @param strChar   Character string to be converted.
+ * @return Wide character representation of supplied character string.
+ */
+
+wchar_t *FreeTypeGX::charToWideChar(const char *strChar) {
+    if (!strChar) { return NULL; }
+
+    size_t len        = strlen(strChar) + 1;
+    wchar_t *strWChar = new (std::nothrow) wchar_t[len];
+    if (!strWChar) { return NULL; }
+
+    size_t bt = mbstowcs(strWChar, strChar, len);
+    if (bt == (size_t) -1) {
+        return NULL;
+    }
+
+    if (bt < --len) {
+        strWChar[bt] = 0;
+    }
+
+    return strWChar;
+}
+
+char *FreeTypeGX::wideCharToUTF8(const wchar_t *strChar) {
+    if (!strChar) {
+        return NULL;
+    }
+
+    size_t len = 0;
+    wchar_t wc;
+
+    for (size_t i = 0; strChar[i]; ++i) {
+        wc = strChar[i];
+        if (wc < 0x80) {
+            ++len;
+        } else if (wc < 0x800) {
+            len += 2;
+        } else if (wc < 0x10000) {
+            len += 3;
+        } else {
+            len += 4;
+        }
+    }
+
+    char *pOut = new (std::nothrow) char[len];
+    if (!pOut) {
+        return NULL;
+    }
+
+    size_t n = 0;
+
+    for (size_t i = 0; strChar[i]; ++i) {
+        wc = strChar[i];
+        if (wc < 0x80) {
+            pOut[n++] = (char) wc;
+        } else if (wc < 0x800) {
+            pOut[n++] = (char) ((wc >> 6) | 0xC0);
+            pOut[n++] = (char) ((wc & 0x3F) | 0x80);
+        } else if (wc < 0x10000) {
+            pOut[n++] = (char) ((wc >> 12) | 0xE0);
+            pOut[n++] = (char) (((wc >> 6) & 0x3F) | 0x80);
+            pOut[n++] = (char) ((wc & 0x3F) | 0x80);
+        } else {
+            pOut[n++] = (char) (((wc >> 18) & 0x07) | 0xF0);
+            pOut[n++] = (char) (((wc >> 12) & 0x3F) | 0x80);
+            pOut[n++] = (char) (((wc >> 6) & 0x3F) | 0x80);
+            pOut[n++] = (char) ((wc & 0x3F) | 0x80);
+        }
+    }
+    pOut[n] = '\0';
+    return pOut;
+}
+
+/**
+ * Clears all loaded font glyph data.
+ *
+ * This routine clears all members of the font map structure and frees all allocated memory back to the system.
+ */
+void FreeTypeGX::unloadFont() {
+    map<int16_t, ftGX2Data>::iterator itr;
+    map<wchar_t, ftgxCharData>::iterator itr2;
+
+    fontDataMutex.lock();
+    for (itr = fontData.begin(); itr != fontData.end(); itr++) {
+        for (itr2 = itr->second.ftgxCharMap.begin(); itr2 != itr->second.ftgxCharMap.end(); itr2++) {
+            if (itr2->second.texture) {
+                if (itr2->second.texture->surface.image) {
+                    free(itr2->second.texture->surface.image);
+                }
+                delete itr2->second.texture;
+                itr2->second.texture = NULL;
+            }
+        }
+    }
+
+    fontData.clear();
+    fontDataMutex.unlock();
+}
+
+/**
+ * Caches the given font glyph in the instance font texture buffer.
+ *
+ * This routine renders and stores the requested glyph's bitmap and relevant information into its own quickly addressible
+ * structure within an instance-specific map.
+ *
+ * @param charCode  The requested glyph's character code.
+ * @return A pointer to the allocated font structure.
+ */
+ftgxCharData *FreeTypeGX::cacheGlyphData(wchar_t charCode, int16_t pixelSize) {
+    fontDataMutex.lock();
+    auto itr = fontData.find(pixelSize);
+    if (itr != fontData.end()) {
+        auto itr2 = itr->second.ftgxCharMap.find(charCode);
+        if (itr2 != itr->second.ftgxCharMap.end()) {
+            // Used cached value;
+            fontDataMutex.unlock();
+            return &itr2->second;
+        }
+    }
+
+    ftGX2Data *ftData = &fontData[pixelSize];
+
+    faceMutex.lock();
+
+    FT_Set_Pixel_Sizes(ftFace, 0, pixelSize);
+
+    ftData->ftgxAlign.ascender  = (int16_t) ftFace->size->metrics.ascender >> 6;
+    ftData->ftgxAlign.descender = (int16_t) ftFace->size->metrics.descender >> 6;
+
+    FT_UInt gIndex;
+    uint16_t textureWidth = 0, textureHeight = 0;
+
+    gIndex = FT_Get_Char_Index(ftFace, (FT_ULong) charCode);
+    if (gIndex != 0 && FT_Load_Glyph(ftFace, gIndex, FT_LOAD_DEFAULT | FT_LOAD_RENDER) == 0) {
+        if (ftFace->glyph->format == FT_GLYPH_FORMAT_BITMAP) {
+            FT_Bitmap *glyphBitmap = &ftFace->glyph->bitmap;
+
+            textureWidth  = ALIGN4(glyphBitmap->width);
+            textureHeight = ALIGN4(glyphBitmap->rows);
+            if (textureWidth == 0) {
+                textureWidth = 4;
+            }
+            if (textureHeight == 0) {
+                textureHeight = 4;
+            }
+
+            ftgxCharData *charData    = &ftData->ftgxCharMap[charCode];
+            charData->renderOffsetX   = (int16_t) ftFace->glyph->bitmap_left;
+            charData->glyphAdvanceX   = (uint16_t) (ftFace->glyph->advance.x >> 6);
+            charData->glyphAdvanceY   = (uint16_t) (ftFace->glyph->advance.y >> 6);
+            charData->glyphIndex      = (uint32_t) gIndex;
+            charData->renderOffsetY   = (int16_t) ftFace->glyph->bitmap_top;
+            charData->renderOffsetMax = (int16_t) ftFace->glyph->bitmap_top;
+            charData->renderOffsetMin = (int16_t) glyphBitmap->rows - ftFace->glyph->bitmap_top;
+
+            int16_t oldMax        = ftData->ftgxAlign.max;
+            ftData->ftgxAlign.max = charData->renderOffsetMax > oldMax ? charData->renderOffsetMax : oldMax;
+
+            int16_t oldMin        = ftData->ftgxAlign.min;
+            ftData->ftgxAlign.min = charData->renderOffsetMin > oldMin ? charData->renderOffsetMin : oldMin;
+
+            //! Initialize texture
+            charData->texture = new GX2Texture;
+            if (charData->texture) {
+                GX2InitTexture(charData->texture, textureWidth, textureHeight, 1, 0, GX2_SURFACE_FORMAT_UNORM_R5_G5_B5_A1, GX2_SURFACE_DIM_TEXTURE_2D, GX2_TILE_MODE_LINEAR_ALIGNED);
+
+                if (!loadGlyphData(glyphBitmap, charData)) {
+                    delete charData->texture;
+                    ftData->ftgxCharMap.erase(charCode);
+                    charData = NULL;
+                }
+            } else {
+                charData = NULL;
+            }
+            faceMutex.unlock();
+            fontDataMutex.unlock();
+            return charData;
+        }
+    }
+    faceMutex.unlock();
+    fontDataMutex.unlock();
+    return NULL;
+}
+
+/**
+ * Locates each character in this wrapper's configured font face and proccess them.
+ *
+ * This routine locates each character in the configured font face and renders the glyph's bitmap.
+ * Each bitmap and relevant information is loaded into its own quickly addressible structure within an instance-specific map.
+ */
+uint16_t FreeTypeGX::cacheGlyphDataComplete(int16_t pixelSize) {
+    uint32_t i = 0;
+    FT_UInt gIndex;
+
+    faceMutex.lock();
+    FT_ULong charCode = FT_Get_First_Char(ftFace, &gIndex);
+    while (gIndex != 0) {
+        if (cacheGlyphData(charCode, pixelSize) != NULL) { ++i; }
+        charCode = FT_Get_Next_Char(ftFace, charCode, &gIndex);
+    }
+    faceMutex.unlock();
+    return (uint16_t) (i);
+}
+
+/**
+ * Loads the rendered bitmap into the relevant structure's data buffer.
+ *
+ * This routine does a simple byte-wise copy of the glyph's rendered 8-bit grayscale bitmap into the structure's buffer.
+ * Each byte is converted from the bitmap's intensity value into the a uint32_t RGBA value.
+ *
+ * @param bmp   A pointer to the most recently rendered glyph's bitmap.
+ * @param charData  A pointer to an allocated ftgxCharData structure whose data represent that of the last rendered glyph.
+ */
+
+bool FreeTypeGX::loadGlyphData(FT_Bitmap *bmp, ftgxCharData *charData) {
+    charData->texture->surface.image = (uint8_t *) memalign(charData->texture->surface.alignment, charData->texture->surface.imageSize);
+    if (!charData->texture->surface.image) {
+        return false;
+    }
+
+    memset(charData->texture->surface.image, 0x00, charData->texture->surface.imageSize);
+
+    uint8_t *src  = (uint8_t *) bmp->buffer;
+    uint16_t *dst = (uint16_t *) charData->texture->surface.image;
+    uint32_t x, y;
+
+    for (y = 0; y < bmp->rows; y++) {
+        for (x = 0; x < bmp->width; x++) {
+            uint8_t intensity                             = src[y * bmp->width + x] >> 3;
+            dst[y * charData->texture->surface.pitch + x] = intensity ? ((intensity << 11) | (intensity << 6) | (intensity << 1) | 1) : 0;
+        }
+    }
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU_TEXTURE, charData->texture->surface.image, charData->texture->surface.imageSize);
+    return true;
+}
+
+/**
+ * Determines the x offset of the rendered string.
+ *
+ * This routine calculates the x offset of the rendered string based off of a supplied positional format parameter.
+ *
+ * @param width Current pixel width of the string.
+ * @param format	Positional format of the string.
+ */
+int16_t FreeTypeGX::getStyleOffsetWidth(uint16_t width, uint16_t format) {
+    if (format & FTGX_JUSTIFY_LEFT) {
+        return 0;
+    } else if (format & FTGX_JUSTIFY_CENTER) {
+        return -(width >> 1);
+    } else if (format & FTGX_JUSTIFY_RIGHT) {
+        return -width;
+    }
+    return 0;
+}
+
+/**
+ * Determines the y offset of the rendered string.
+ *
+ * This routine calculates the y offset of the rendered string based off of a supplied positional format parameter.
+ *
+ * @param offset	Current pixel offset data of the string.
+ * @param format	Positional format of the string.
+ */
+int16_t FreeTypeGX::getStyleOffsetHeight(int16_t format, uint16_t pixelSize) {
+    fontDataMutex.lock();
+    auto itr = fontData.find(pixelSize);
+    if (itr == fontData.end()) {
+        fontDataMutex.unlock();
+        return 0;
+    }
+    int16_t res = 0;
+    switch (format & FTGX_ALIGN_MASK) {
+        case FTGX_ALIGN_TOP:
+            res = itr->second.ftgxAlign.descender;
+            break;
+        case FTGX_ALIGN_MIDDLE:
+        default:
+            res = (itr->second.ftgxAlign.ascender + itr->second.ftgxAlign.descender + 1) >> 1;
+            break;
+        case FTGX_ALIGN_BOTTOM:
+            res = itr->second.ftgxAlign.ascender;
+            break;
+        case FTGX_ALIGN_BASELINE:
+            res = 0;
+            break;
+        case FTGX_ALIGN_GLYPH_TOP:
+            res = itr->second.ftgxAlign.max;
+            break;
+        case FTGX_ALIGN_GLYPH_MIDDLE:
+            res = (itr->second.ftgxAlign.max + itr->second.ftgxAlign.min + 1) >> 1;
+            break;
+        case FTGX_ALIGN_GLYPH_BOTTOM:
+            res = itr->second.ftgxAlign.min;
+            break;
+    }
+
+    fontDataMutex.unlock();
+    return res;
+}
+
+/**
+ * Processes the supplied text string and prints the results at the specified coordinates.
+ *
+ * This routine processes each character of the supplied text string, loads the relevant preprocessed bitmap buffer,
+ * a texture from said buffer, and loads the resultant texture into the EFB.
+ *
+ * @param x Screen X coordinate at which to output the text.
+ * @param y Screen Y coordinate at which to output the text. Note that this value corresponds to the text string origin and not the top or bottom of the glyphs.
+ * @param text  NULL terminated string to output.
+ * @param color Optional color to apply to the text characters. If not specified default value is ftgxWhite: (GXColor){0xff, 0xff, 0xff, 0xff}
+ * @param textStyle Flags which specify any styling which should be applied to the rendered string.
+ * @return The number of characters printed.
+ */
+
+uint16_t FreeTypeGX::drawText(CVideo *video, int16_t x, int16_t y, int16_t z, const wchar_t *text, int16_t pixelSize, const glm::vec4 &color, uint16_t textStyle, uint16_t textWidth, const float &textBlur, const float &colorBlurIntensity,
+                              const glm::vec4 &blurColor, const float &superSamplingScale) {
+    if (!text) { return 0; }
+
+    uint16_t fullTextWidth = (textWidth > 0) ? textWidth : getWidth(text, pixelSize);
+    uint16_t x_pos = x, printed = 0;
+    uint16_t x_offset = 0, y_offset = 0;
+    FT_Vector pairDelta;
+
+    if (textStyle & FTGX_JUSTIFY_MASK) {
+        x_offset = getStyleOffsetWidth(fullTextWidth, textStyle);
+    }
+    if (textStyle & FTGX_ALIGN_MASK) {
+        y_offset = getStyleOffsetHeight(textStyle, pixelSize);
+    }
+
+    int32_t i = 0;
+    while (text[i]) {
+        ftgxCharData *glyphData = cacheGlyphData(text[i], pixelSize);
+
+        if (glyphData != NULL) {
+            if (ftKerningEnabled && i > 0) {
+                fontDataMutex.lock();
+                faceMutex.lock();
+                FT_Get_Kerning(ftFace, fontData[pixelSize].ftgxCharMap[text[i - 1]].glyphIndex, glyphData->glyphIndex, FT_KERNING_DEFAULT, &pairDelta);
+                faceMutex.unlock();
+                fontDataMutex.unlock();
+                x_pos += (pairDelta.x >> 6);
+            }
+            copyTextureToFramebuffer(video, glyphData->texture, x_pos + glyphData->renderOffsetX + x_offset, y + glyphData->renderOffsetY - y_offset, z, color, textBlur, colorBlurIntensity, blurColor, superSamplingScale);
+
+            x_pos += glyphData->glyphAdvanceX;
+            ++printed;
+        }
+        ++i;
+    }
+
+    return printed;
+}
+
+
+/**
+ * Processes the supplied string and return the width of the string in pixels.
+ *
+ * This routine processes each character of the supplied text string and calculates the width of the entire string.
+ * Note that if precaching of the entire font set is not enabled any uncached glyph will be cached after the call to this function.
+ *
+ * @param text  NULL terminated string to calculate.
+ * @return The width of the text string in pixels.
+ */
+uint16_t FreeTypeGX::getWidth(const wchar_t *text, int16_t pixelSize) {
+    if (!text) { return 0; }
+
+    uint16_t strWidth = 0;
+    int32_t i         = 0;
+    while (text[i]) {
+        strWidth += getCharWidth(text[i], pixelSize, i > 0 ? text[i - 1] : 0);
+        ++i;
+    }
+    return strWidth;
+}
+
+/**
+ * Single char width
+ */
+uint16_t FreeTypeGX::getCharWidth(const wchar_t wChar, int16_t pixelSize, const wchar_t prevChar) {
+    uint16_t strWidth       = 0;
+    ftgxCharData *glyphData = cacheGlyphData(wChar, pixelSize);
+
+    if (glyphData != NULL) {
+        if (ftKerningEnabled && prevChar != 0x0000) {
+            FT_Vector pairDelta;
+            faceMutex.lock();
+            fontDataMutex.lock();
+            FT_Get_Kerning(ftFace, fontData[pixelSize].ftgxCharMap[prevChar].glyphIndex, glyphData->glyphIndex, FT_KERNING_DEFAULT, &pairDelta);
+            fontDataMutex.unlock();
+            faceMutex.unlock();
+            strWidth += pairDelta.x >> 6;
+        }
+        strWidth += glyphData->glyphAdvanceX;
+    }
+
+    return strWidth;
+}
+
+/**
+ * Processes the supplied string and return the height of the string in pixels.
+ *
+ * This routine processes each character of the supplied text string and calculates the height of the entire string.
+ * Note that if precaching of the entire font set is not enabled any uncached glyph will be cached after the call to this function.
+ *
+ * @param text  NULL terminated string to calculate.
+ * @return The height of the text string in pixels.
+ */
+uint16_t FreeTypeGX::getHeight(const wchar_t *text, int16_t pixelSize) {
+    if (text == NULL) {
+        return 0;
+    }
+
+    int16_t strMax = 0, strMin = 0;
+    int32_t i = 0;
+    while (text[i]) {
+        ftgxCharData *glyphData = cacheGlyphData(text[i], pixelSize);
+
+        if (glyphData != NULL) {
+            strMax = glyphData->renderOffsetMax > strMax ? glyphData->renderOffsetMax : strMax;
+            strMin = glyphData->renderOffsetMin > strMin ? glyphData->renderOffsetMin : strMin;
+        }
+
+        ++i;
+    }
+
+    return strMax + strMin;
+}
+
+/**
+ * Copies the supplied texture quad to the EFB.
+ *
+ * This routine uses the in-built GX quad builder functions to define the texture bounds and location on the EFB target.
+ *
+ * @param texObj	A pointer to the glyph's initialized texture object.
+ * @param texWidth  The pixel width of the texture object.
+ * @param texHeight The pixel height of the texture object.
+ * @param screenX   The screen X coordinate at which to output the rendered texture.
+ * @param screenY   The screen Y coordinate at which to output the rendered texture.
+ * @param color Color to apply to the texture.
+ */
+void FreeTypeGX::copyTextureToFramebuffer(CVideo *pVideo, GX2Texture *texture, int16_t x, int16_t y, int16_t z, const glm::vec4 &color, const float &defaultBlur, const float &blurIntensity, const glm::vec4 &blurColor,
+                                          const float &superSamplingScale) {
+    static const float imageAngle = 0.0f;
+    static const float blurScale  = (2.0f);
+
+    float offsetLeft = blurScale * (1.0f / superSamplingScale) * ((float) x + 0.5f * (float) texture->surface.width) * (float) pVideo->getWidthScaleFactor();
+    float offsetTop  = blurScale * (1.0f / superSamplingScale) * ((float) y - 0.5f * (float) texture->surface.height) * (float) pVideo->getHeightScaleFactor();
+
+    float widthScale  = blurScale * (1.0f / superSamplingScale) * (float) texture->surface.width * pVideo->getWidthScaleFactor();
+    float heightScale = blurScale * (1.0f / superSamplingScale) * (float) texture->surface.height * pVideo->getHeightScaleFactor();
+
+    glm::vec3 positionOffsets(offsetLeft, offsetTop, (float) z);
+
+    //! blur doubles  due to blur we have to scale the texture
+    glm::vec3 scaleFactor(widthScale, heightScale, 1.0f);
+
+    glm::vec3 blurDirection;
+    blurDirection[2] = 1.0f;
+
+    Texture2DShader::instance()->setShaders();
+    Texture2DShader::instance()->setAttributeBuffer();
+    Texture2DShader::instance()->setAngle(imageAngle);
+    Texture2DShader::instance()->setOffset(positionOffsets);
+    Texture2DShader::instance()->setScale(scaleFactor);
+    Texture2DShader::instance()->setTextureAndSampler(texture, &ftSampler);
+
+    if (blurIntensity > 0.0f) {
+        //! glow blur color
+        Texture2DShader::instance()->setColorIntensity(blurColor);
+
+        //! glow blur horizontal
+        blurDirection[0] = blurIntensity;
+        blurDirection[1] = 0.0f;
+        Texture2DShader::instance()->setBlurring(blurDirection);
+        Texture2DShader::instance()->draw();
+
+        //! glow blur vertical
+        blurDirection[0] = 0.0f;
+        blurDirection[1] = blurIntensity;
+        Texture2DShader::instance()->setBlurring(blurDirection);
+        Texture2DShader::instance()->draw();
+    }
+
+    //! set text color
+    Texture2DShader::instance()->setColorIntensity(color);
+
+    //! blur horizontal
+    blurDirection[0] = defaultBlur;
+    blurDirection[1] = 0.0f;
+    Texture2DShader::instance()->setBlurring(blurDirection);
+    Texture2DShader::instance()->draw();
+
+    //! blur vertical
+    blurDirection[0] = 0.0f;
+    blurDirection[1] = defaultBlur;
+    Texture2DShader::instance()->setBlurring(blurDirection);
+    Texture2DShader::instance()->draw();
+}

src/gui/FreeTypeGX.h

@@ -0,0 +1,163 @@
+/*
+ * FreeTypeGX is a wrapper class for libFreeType which renders a compiled
+ * FreeType parsable font into a GX texture for Wii homebrew development.
+ * Copyright (C) 2008 Armin Tamzarian
+ * Modified by Dimok, 2015 for WiiU GX2
+ *
+ * This file is part of FreeTypeGX.
+ *
+ * FreeTypeGX 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.
+ *
+ * FreeTypeGX 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 FreeTypeGX.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <ft2build.h>
+#include <string>
+#include FT_FREETYPE_H
+#include FT_BITMAP_H
+
+#include <malloc.h>
+#include <map>
+#include <mutex>
+#include <string.h>
+#include <wchar.h>
+
+
+#include <gui/gx2_ext.h>
+
+#include <gx2/sampler.h>
+#include <gx2/texture.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+
+/*! \struct ftgxCharData_
+ *
+ * Font face character glyph relevant data structure.
+ */
+typedef struct ftgxCharData_ {
+    int16_t renderOffsetX;  /**< Texture X axis bearing offset. */
+    uint16_t glyphAdvanceX; /**< Character glyph X coordinate advance in pixels. */
+    uint16_t glyphAdvanceY; /**< Character glyph Y coordinate advance in pixels. */
+    uint32_t glyphIndex;    /**< Charachter glyph index in the font face. */
+
+    int16_t renderOffsetY;   /**< Texture Y axis bearing offset. */
+    int16_t renderOffsetMax; /**< Texture Y axis bearing maximum value. */
+    int16_t renderOffsetMin; /**< Texture Y axis bearing minimum value. */
+
+    GX2Texture *texture;
+} ftgxCharData;
+
+/*! \struct ftgxDataOffset_
+ *
+ * Offset structure which hold both a maximum and minimum value.
+ */
+typedef struct ftgxDataOffset_ {
+    int16_t ascender;  /**< Maximum data offset. */
+    int16_t descender; /**< Minimum data offset. */
+    int16_t max;       /**< Maximum data offset. */
+    int16_t min;       /**< Minimum data offset. */
+} ftgxDataOffset;
+
+typedef struct ftgxCharData_ ftgxCharData;
+typedef struct ftgxDataOffset_ ftgxDataOffset;
+#define _TEXT(t)                L##t /**< Unicode helper macro. */
+
+#define FTGX_NULL               0x0000
+#define FTGX_JUSTIFY_LEFT       0x0001
+#define FTGX_JUSTIFY_CENTER     0x0002
+#define FTGX_JUSTIFY_RIGHT      0x0004
+#define FTGX_JUSTIFY_MASK       0x000f
+
+#define FTGX_ALIGN_TOP          0x0010
+#define FTGX_ALIGN_MIDDLE       0x0020
+#define FTGX_ALIGN_BOTTOM       0x0040
+#define FTGX_ALIGN_BASELINE     0x0080
+#define FTGX_ALIGN_GLYPH_TOP    0x0100
+#define FTGX_ALIGN_GLYPH_MIDDLE 0x0200
+#define FTGX_ALIGN_GLYPH_BOTTOM 0x0400
+#define FTGX_ALIGN_MASK         0x0ff0
+
+#define FTGX_STYLE_UNDERLINE    0x1000
+#define FTGX_STYLE_STRIKE       0x2000
+#define FTGX_STYLE_MASK         0xf000
+
+/**< Constant color value used only to sanitize Doxygen documentation. */
+static const GX2ColorF32 ftgxWhite = (GX2ColorF32){
+        1.0f, 1.0f, 1.0f, 1.0f};
+
+
+//! forward declaration
+class CVideo;
+
+/*! \class FreeTypeGX
+ * \brief Wrapper class for the libFreeType library with GX rendering.
+ * \author Armin Tamzarian
+ * \version 0.2.4
+ *
+ * FreeTypeGX acts as a wrapper class for the libFreeType library. It supports precaching of transformed glyph data into
+ * a specified texture format. Rendering of the data to the EFB is accomplished through the application of high performance
+ * GX texture functions resulting in high throughput of string rendering.
+ */
+class FreeTypeGX {
+private:
+    FT_Library ftLibrary;  /**< FreeType FT_Library instance. */
+    FT_Face ftFace;        /**< FreeType reusable FT_Face typographic object. */
+    bool ftKerningEnabled; /**< Flag indicating the availability of font kerning data. */
+    uint8_t vertexIndex;   /**< Vertex format descriptor index. */
+    GX2Sampler ftSampler;
+    std::recursive_mutex faceMutex;
+    std::recursive_mutex fontDataMutex;
+
+    typedef struct _ftGX2Data {
+        ftgxDataOffset ftgxAlign;
+        std::map<wchar_t, ftgxCharData> ftgxCharMap;
+    } ftGX2Data;
+
+    std::map<int16_t, ftGX2Data> fontData; /**< Map which holds the glyph data structures for the corresponding characters in one size. */
+
+    int16_t getStyleOffsetWidth(uint16_t width, uint16_t format);
+
+    int16_t getStyleOffsetHeight(int16_t format, uint16_t pixelSize);
+
+    void unloadFont();
+
+    ftgxCharData *cacheGlyphData(wchar_t charCode, int16_t pixelSize);
+
+    uint16_t cacheGlyphDataComplete(int16_t pixelSize);
+
+    bool loadGlyphData(FT_Bitmap *bmp, ftgxCharData *charData);
+
+    void copyTextureToFramebuffer(CVideo *pVideo, GX2Texture *tex, int16_t screenX, int16_t screenY, int16_t screenZ, const glm::vec4 &color, const float &textBlur, const float &colorBlurIntensity, const glm::vec4 &blurColor,
+                                  const float &superSamplingScale);
+
+public:
+    FreeTypeGX(const uint8_t *fontBuffer, FT_Long bufferSize, bool lastFace = false);
+
+    ~FreeTypeGX();
+
+    uint16_t drawText(CVideo *pVideo, int16_t x, int16_t y, int16_t z, const wchar_t *text, int16_t pixelSize, const glm::vec4 &color,
+                      uint16_t textStyling, uint16_t textWidth, const float &textBlur, const float &colorBlurIntensity, const glm::vec4 &blurColor, const float &superSamplingScale);
+
+
+    uint16_t getWidth(const wchar_t *text, int16_t pixelSize);
+
+    uint16_t getCharWidth(const wchar_t wChar, int16_t pixelSize, const wchar_t prevChar = 0x0000);
+
+    uint16_t getHeight(const wchar_t *text, int16_t pixelSize);
+
+    static wchar_t *charToWideChar(const char *p);
+
+    static char *wideCharToUTF8(const wchar_t *strChar);
+};

src/gui/GameBgImage.cpp

@@ -0,0 +1,40 @@
+#include <gui/GameBgImage.h>
+#include <video/CVideo.h>
+#include <video/shaders/Shader3D.h>
+
+GameBgImage::GameBgImage(const std::string &filename, GuiImageData *preloadImage)
+    : GuiImageAsync(filename, preloadImage) {
+    identity     = glm::mat4(1.0f);
+    alphaFadeOut = glm::vec4(1.0f, 0.075f, 5.305f, 2.0f);
+}
+
+GameBgImage::~GameBgImage() {
+}
+
+void GameBgImage::draw(CVideo *pVideo) {
+    if (!getImageData() || !getImageData()->getTexture()) {
+        return;
+    }
+
+    //! first setup 2D GUI positions
+    float currPosX   = getCenterX();
+    float currPosY   = getCenterY();
+    float currPosZ   = getDepth();
+    float currScaleX = getScaleX() * (float) getWidth() * pVideo->getWidthScaleFactor();
+    float currScaleY = getScaleY() * (float) getHeight() * pVideo->getHeightScaleFactor();
+    float currScaleZ = getScaleZ() * (float) getWidth() * pVideo->getDepthScaleFactor();
+
+    glm::mat4 m_modelView = glm::translate(identity, glm::vec3(currPosX, currPosY, currPosZ));
+    m_modelView           = glm::scale(m_modelView, glm::vec3(currScaleX, currScaleY, currScaleZ));
+
+    Shader3D::instance()->setShaders();
+    Shader3D::instance()->setProjectionMtx(identity);
+    Shader3D::instance()->setViewMtx(identity);
+    Shader3D::instance()->setModelViewMtx(m_modelView);
+    Shader3D::instance()->setTextureAndSampler(getImageData()->getTexture(), getImageData()->getSampler());
+    Shader3D::instance()->setAlphaFadeOut(alphaFadeOut);
+    Shader3D::instance()->setDistanceFadeOut(0.0f);
+    Shader3D::instance()->setColorIntensity(glm::vec4(1.0f, 1.0f, 1.0f, getAlpha()));
+    Shader3D::instance()->setAttributeBuffer();
+    Shader3D::instance()->draw();
+}

src/gui/GameBgImage.h

@@ -0,0 +1,24 @@
+#ifndef _GAME_BG_IMAGE_H_
+#define _GAME_BG_IMAGE_H_
+
+#include <gui/GuiImageAsync.h>
+#include <video/shaders/Shader3D.h>
+
+class GameBgImage : public GuiImageAsync {
+public:
+    GameBgImage(const std::string &filename, GuiImageData *preloadImage);
+
+    virtual ~GameBgImage();
+
+    void setAlphaFadeOut(const glm::vec4 &a) {
+       alphaFadeOut = a;
+    }
+
+    void draw(CVideo *pVideo) override;
+
+private:
+    glm::mat4 identity;
+    glm::vec4 alphaFadeOut;
+};
+
+#endif // _GAME_BG_IMAGE_H_

src/gui/GameIcon.cpp

@@ -1,9 +1,9 @@
 #include "GameIcon.h"
 #include "GameIconModel.h"
 #include "Application.h"
-#include <gui/video/CVideo.h>
+#include <video/CVideo.h>
-#include <gui/video/shaders/Shader3D.h>
+#include <video/shaders/Shader3D.h>
-#include <gui/video/shaders/ShaderFractalColor.h>
+#include <video/shaders/ShaderFractalColor.h>
 #include "utils/utils.h"
 #include "utils/logger.h"
 

src/gui/GameIcon.h

@@ -2,7 +2,7 @@
 #define _GAME_ICON_H_
 
 #include <gui/GuiImageAsync.h>
-#include <gui/video/shaders/Shader3D.h>
+#include <video/shaders/Shader3D.h>
 
 class GameIcon : public GuiImage {
 public:

src/gui/GridBackground.cpp

@@ -0,0 +1,104 @@
+#include "utils/utils.h"
+#include <gui/GridBackground.h>
+#include <video/CVideo.h>
+#include <video/shaders/Shader3D.h>
+
+static const float bgRepeat    = 1000.0f;
+static const float bgTexRotate = 39.0f;
+
+GridBackground::GridBackground(GuiImageData *img)
+    : GuiImage(img) {
+    colorIntensity  = glm::vec4(1.0f, 1.0f, 1.0f, 0.9f);
+    alphaFadeOut    = glm::vec4(0.0f);
+    distanceFadeOut = 0.15f;
+
+    vtxCount = 4;
+
+    //! texture and vertex coordinates
+    float *m_posVtxs   = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, vtxCount * Shader3D::cuVertexAttrSize);
+    float *m_texCoords = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, vtxCount * Shader3D::cuTexCoordAttrSize);
+
+    if (m_posVtxs) {
+        int32_t i      = 0;
+        m_posVtxs[i++] = -1.0f;
+        m_posVtxs[i++] = 0.0f;
+        m_posVtxs[i++] = 1.0f;
+        m_posVtxs[i++] = 1.0f;
+        m_posVtxs[i++] = 0.0f;
+        m_posVtxs[i++] = 1.0f;
+        m_posVtxs[i++] = 1.0f;
+        m_posVtxs[i++] = 0.0f;
+        m_posVtxs[i++] = -1.0f;
+        m_posVtxs[i++] = -1.0f;
+        m_posVtxs[i++] = 0.0f;
+        m_posVtxs[i++] = -1.0f;
+        GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, m_posVtxs, vtxCount * Shader3D::cuVertexAttrSize);
+    }
+
+    if (m_texCoords) {
+        glm::vec2 texCoordVec[4];
+        texCoordVec[0][0] = -0.5f * bgRepeat;
+        texCoordVec[0][1] = 0.5f * bgRepeat;
+        texCoordVec[1][0] = 0.5f * bgRepeat;
+        texCoordVec[1][1] = 0.5f * bgRepeat;
+        texCoordVec[2][0] = 0.5f * bgRepeat;
+        texCoordVec[2][1] = -0.5f * bgRepeat;
+        texCoordVec[3][0] = -0.5f * bgRepeat;
+        texCoordVec[3][1] = -0.5f * bgRepeat;
+
+        const float cosRot = cosf(DegToRad(bgTexRotate));
+        const float sinRot = sinf(DegToRad(bgTexRotate));
+
+        glm::mat2 texRotateMtx({cosRot, -sinRot,
+                                sinRot, cosRot});
+
+        for (int32_t i = 0; i < 4; i++) {
+            texCoordVec[i]         = texRotateMtx * texCoordVec[i];
+            m_texCoords[i * 2 + 0] = texCoordVec[i][0];
+            m_texCoords[i * 2 + 1] = texCoordVec[i][1];
+        }
+
+        GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, m_texCoords, vtxCount * Shader3D::cuTexCoordAttrSize);
+    }
+
+    //! assign to internal variables which are const but oh well
+    posVtxs   = m_posVtxs;
+    texCoords = m_texCoords;
+}
+
+GridBackground::~GridBackground() {
+    //! remove image so it can not be drawn anymore from this point on
+    imageData = nullptr;
+
+    //! main image vertexes
+    if (posVtxs) {
+        free((void *) posVtxs);
+        posVtxs = NULL;
+    }
+    if (texCoords) {
+        free((void *) texCoords);
+        texCoords = NULL;
+    }
+}
+
+void GridBackground::drawModel(CVideo *pVideo, const glm::mat4 &modelView) {
+    //! first setup 2D GUI positions
+    float currScaleX = bgRepeat * scaleX * (float) getWidth() * pVideo->getWidthScaleFactor();
+    float currScaleY = 1.0f;
+    float currScaleZ = bgRepeat * scaleZ * (float) getHeight() * pVideo->getDepthScaleFactor();
+
+    m_modelView = glm::scale(modelView, glm::vec3(currScaleX, currScaleY, currScaleZ));
+
+    colorIntensity[3] = getAlpha();
+
+    Shader3D::instance()->setShaders();
+    Shader3D::instance()->setTextureAndSampler(imageData->getTexture(), imageData->getSampler());
+    Shader3D::instance()->setProjectionMtx(pVideo->getProjectionMtx());
+    Shader3D::instance()->setViewMtx(pVideo->getViewMtx());
+    Shader3D::instance()->setModelViewMtx(m_modelView);
+    Shader3D::instance()->setDistanceFadeOut(distanceFadeOut);
+    Shader3D::instance()->setAlphaFadeOut(alphaFadeOut);
+    Shader3D::instance()->setColorIntensity(colorIntensity);
+    Shader3D::instance()->setAttributeBuffer(vtxCount, posVtxs, texCoords);
+    Shader3D::instance()->draw(GX2_PRIMITIVE_MODE_QUADS, vtxCount);
+}

src/gui/GridBackground.h

@@ -0,0 +1,33 @@
+#ifndef _GRID_BACKGROUND_H_
+#define _GRID_BACKGROUND_H_
+
+#include <gui/GuiImage.h>
+
+class GridBackground : public GuiImage {
+public:
+    GridBackground(GuiImageData *imgData);
+
+    virtual ~GridBackground();
+
+    void setColorIntensity(const glm::vec4 &color) {
+        colorIntensity = color;
+    }
+
+    const glm::vec4 &getColorIntensity() const {
+        return colorIntensity;
+    }
+
+    void setDistanceFadeOut(const float &a) {
+        distanceFadeOut = a;
+    }
+
+    void drawModel(CVideo *pVideo, const glm::mat4 &modelView);
+
+private:
+    glm::mat4 m_modelView;
+    glm::vec4 colorIntensity;
+    glm::vec4 alphaFadeOut;
+    float distanceFadeOut;
+};
+
+#endif // _GRID_BACKGROUND_H_

src/gui/Gui.h

@@ -0,0 +1,43 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef __GUI_H
+#define __GUI_H
+
+#include <gui/FreeTypeGX.h>
+#include <gui/GameBgImage.h>
+#include <gui/GridBackground.h>
+#include <gui/GuiButton.h>
+#include <gui/GuiCheckBox.h>
+#include <gui/GuiController.h>
+#include <gui/GuiDragListener.h>
+#include <gui/GuiElement.h>
+#include <gui/GuiFrame.h>
+#include <gui/GuiImage.h>
+#include <gui/GuiImageAsync.h>
+#include <gui/GuiImageData.h>
+#include <gui/GuiParticleImage.h>
+#include <gui/GuiScrollbar.h>
+#include <gui/GuiSelectBox.h>
+#include <gui/GuiSound.h>
+#include <gui/GuiSwitch.h>
+#include <gui/GuiText.h>
+#include <gui/GuiToggle.h>
+#include <gui/GuiTrigger.h>
+#include <gui/VPadController.h>
+#include <gui/WPadController.h>
+
+#endif

src/gui/GuiButton.cpp

@@ -0,0 +1,275 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <gui/GuiButton.h>
+#include <gui/GuiController.h>
+#include <gui/GuiTrigger.h>
+
+/**
+ * Constructor for the GuiButton class.
+ */
+
+GuiButton::GuiButton(float w, float h) {
+    width      = w;
+    height     = h;
+    image      = NULL;
+    imageOver  = NULL;
+    imageHold  = NULL;
+    imageClick = NULL;
+    icon       = NULL;
+    iconOver   = NULL;
+
+    for (int32_t i = 0; i < 4; i++) {
+        label[i]      = NULL;
+        labelOver[i]  = NULL;
+        labelHold[i]  = NULL;
+        labelClick[i] = NULL;
+    }
+    for (int32_t i = 0; i < iMaxGuiTriggers; i++) {
+        trigger[i] = NULL;
+    }
+
+    soundOver      = NULL;
+    soundHold      = NULL;
+    soundClick     = NULL;
+    clickedTrigger = NULL;
+    heldTrigger    = NULL;
+    selectable     = true;
+    holdable       = false;
+    clickable      = true;
+}
+
+/**
+ * Destructor for the GuiButton class.
+ */
+GuiButton::~GuiButton() {
+}
+
+void GuiButton::setImage(GuiImage *img) {
+    image = img;
+    if (img) { img->setParent(this); }
+}
+
+void GuiButton::setImageOver(GuiImage *img) {
+    imageOver = img;
+    if (img) { img->setParent(this); }
+}
+
+void GuiButton::setImageHold(GuiImage *img) {
+    imageHold = img;
+    if (img) { img->setParent(this); }
+}
+
+void GuiButton::setImageClick(GuiImage *img) {
+    imageClick = img;
+    if (img) { img->setParent(this); }
+}
+
+void GuiButton::setIcon(GuiImage *img) {
+    icon = img;
+    if (img) { img->setParent(this); }
+}
+
+void GuiButton::setIconOver(GuiImage *img) {
+    iconOver = img;
+    if (img) { img->setParent(this); }
+}
+
+void GuiButton::setLabel(GuiText *txt, int32_t n) {
+    label[n] = txt;
+    if (txt) { txt->setParent(this); }
+}
+
+void GuiButton::setLabelOver(GuiText *txt, int32_t n) {
+    labelOver[n] = txt;
+    if (txt) { txt->setParent(this); }
+}
+
+void GuiButton::setLabelHold(GuiText *txt, int32_t n) {
+    labelHold[n] = txt;
+    if (txt) { txt->setParent(this); }
+}
+
+void GuiButton::setLabelClick(GuiText *txt, int32_t n) {
+    labelClick[n] = txt;
+    if (txt) { txt->setParent(this); }
+}
+
+void GuiButton::setSoundOver(GuiSound *snd) {
+    soundOver = snd;
+}
+
+void GuiButton::setSoundHold(GuiSound *snd) {
+    soundHold = snd;
+}
+
+void GuiButton::setSoundClick(GuiSound *snd) {
+    soundClick = snd;
+}
+
+void GuiButton::setTrigger(GuiTrigger *t, int32_t idx) {
+    if (idx >= 0 && idx < iMaxGuiTriggers) {
+        trigger[idx] = t;
+    } else {
+        for (int32_t i = 0; i < iMaxGuiTriggers; i++) {
+            if (!trigger[i]) {
+                trigger[i] = t;
+                break;
+            }
+        }
+    }
+}
+
+void GuiButton::resetState(void) {
+    clickedTrigger = NULL;
+    heldTrigger    = NULL;
+    GuiElement::resetState();
+}
+
+/**
+ * Draw the button on screen
+ */
+void GuiButton::draw(CVideo *v) {
+    if (!this->isVisible()) {
+        return;
+    }
+
+    // draw image
+    if ((isDrawOverOnlyWhenSelected() && (isStateSet(STATE_SELECTED) && imageOver)) ||
+        (!isDrawOverOnlyWhenSelected() && (isStateSet(STATE_OVER | STATE_SELECTED | STATE_CLICKED | STATE_HELD) && imageOver))) {
+        imageOver->draw(v);
+    } else if (image) {
+        image->draw(v);
+    }
+
+    if ((isDrawOverOnlyWhenSelected() && (isStateSet(STATE_SELECTED) && iconOver)) ||
+        (!isDrawOverOnlyWhenSelected() && (isStateSet(STATE_OVER | STATE_SELECTED | STATE_CLICKED | STATE_HELD) && iconOver))) {
+        iconOver->draw(v);
+    } else if (icon) {
+        icon->draw(v);
+    }
+
+    // draw text
+    for (int32_t i = 0; i < 4; i++) {
+        if (isStateSet(STATE_OVER | STATE_SELECTED | STATE_CLICKED | STATE_HELD) && labelOver[i]) {
+            labelOver[i]->draw(v);
+        } else if (label[i]) {
+            label[i]->draw(v);
+        }
+    }
+}
+
+void GuiButton::update(GuiController *c) {
+    if (!c || isStateSet(STATE_DISABLED | STATE_HIDDEN | STATE_DISABLE_INPUT, c->chanIdx)) {
+        return;
+    } else if (parentElement && (parentElement->isStateSet(STATE_DISABLED | STATE_HIDDEN | STATE_DISABLE_INPUT, c->chanIdx))) {
+        return;
+    }
+
+    if (selectable) {
+        if (c->data.validPointer && this->isInside(c->data.x, c->data.y)) {
+            if (!isStateSet(STATE_OVER, c->chanIdx)) {
+                setState(STATE_OVER, c->chanIdx);
+
+                //if(this->isRumbleActive())
+                //	this->rumble(t->chan);
+
+                if (soundOver) {
+                    soundOver->Play();
+                }
+
+                if (effectsOver && !effects) {
+                    // initiate effects
+                    effects      = effectsOver;
+                    effectAmount = effectAmountOver;
+                    effectTarget = effectTargetOver;
+                }
+
+                pointedOn(this, c);
+            }
+        } else if (isStateSet(STATE_OVER, c->chanIdx)) {
+            this->clearState(STATE_OVER, c->chanIdx);
+            pointedOff(this, c);
+
+            if (effectTarget == effectTargetOver && effectAmount == effectAmountOver) {
+                // initiate effects (in reverse)
+                effects      = effectsOver;
+                effectAmount = -effectAmountOver;
+                effectTarget = 100;
+            }
+        }
+    }
+
+    for (int32_t i = 0; i < iMaxGuiTriggers; i++) {
+        if (!trigger[i]) {
+            continue;
+        }
+
+        // button triggers
+        if (clickable) {
+
+            int32_t isClicked = trigger[i]->clicked(c);
+
+            if (!clickedTrigger && (isClicked != GuiTrigger::CLICKED_NONE) && (trigger[i]->isClickEverywhere() || (isStateSet(STATE_SELECTED | STATE_OVER, c->chanIdx) && trigger[i]->isSelectionClickEverywhere()) || this->isInside(c->data.x, c->data.y))) {
+                if (soundClick) {
+                    soundClick->Play();
+                }
+
+                clickedTrigger = trigger[i];
+
+                if (!isStateSet(STATE_CLICKED, c->chanIdx)) {
+                    if (isClicked == GuiTrigger::CLICKED_TOUCH) {
+                        setState(STATE_CLICKED_TOUCH, c->chanIdx);
+                    } else {
+                        setState(STATE_CLICKED, c->chanIdx);
+                    }
+                }
+
+                clicked(this, c, trigger[i]);
+            } else if ((isStateSet(STATE_CLICKED, c->chanIdx) || isStateSet(STATE_CLICKED_TOUCH, c->chanIdx)) && (clickedTrigger == trigger[i]) && !isStateSet(STATE_HELD, c->chanIdx) && !trigger[i]->held(c) &&
+                       ((isClicked == GuiTrigger::CLICKED_NONE) || trigger[i]->released(c))) {
+                if ((isStateSet(STATE_CLICKED_TOUCH, c->chanIdx) && this->isInside(c->data.x, c->data.y)) || (isStateSet(STATE_CLICKED, c->chanIdx))) {
+                    clickedTrigger = NULL;
+                    clearState(STATE_CLICKED, c->chanIdx);
+                    released(this, c, trigger[i]);
+                }
+            }
+        }
+
+        if (holdable) {
+            bool isHeld = trigger[i]->held(c);
+
+            if ((!heldTrigger || heldTrigger == trigger[i]) && isHeld && (trigger[i]->isHoldEverywhere() || (isStateSet(STATE_SELECTED | STATE_OVER, c->chanIdx) && trigger[i]->isSelectionClickEverywhere()) || this->isInside(c->data.x, c->data.y))) {
+                heldTrigger = trigger[i];
+
+                if (!isStateSet(STATE_HELD, c->chanIdx)) {
+                    setState(STATE_HELD, c->chanIdx);
+                }
+
+                held(this, c, trigger[i]);
+            } else if (isStateSet(STATE_HELD, c->chanIdx) && (heldTrigger == trigger[i]) && (!isHeld || trigger[i]->released(c))) {
+                //! click is removed at this point and converted to held
+                if (clickedTrigger == trigger[i]) {
+                    clickedTrigger = NULL;
+                    clearState(STATE_CLICKED, c->chanIdx);
+                }
+                heldTrigger = NULL;
+                clearState(STATE_HELD, c->chanIdx);
+                released(this, c, trigger[i]);
+            }
+        }
+    }
+}

src/gui/GuiButton.h

@@ -0,0 +1,135 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef GUI_BUTTON_H_
+#define GUI_BUTTON_H_
+
+#include <gui/GuiController.h>
+#include <gui/GuiElement.h>
+#include <gui/GuiImage.h>
+#include <gui/GuiSound.h>
+#include <gui/GuiText.h>
+#include <gui/GuiTrigger.h>
+#include <gui/gx2_ext.h>
+
+//!Display, manage, and manipulate buttons in the GUI. Buttons can have images, icons, text, and sound set (all of which are optional)
+class GuiButton : public GuiElement {
+public:
+    //!Constructor
+    //!\param w Width
+    //!\param h Height
+    GuiButton(float w, float h);
+
+    //!Destructor
+    virtual ~GuiButton();
+
+    //!Sets the button's image
+    //!\param i Pointer to GuiImage object
+    void setImage(GuiImage *i);
+
+    //!Sets the button's image on over
+    //!\param i Pointer to GuiImage object
+    void setImageOver(GuiImage *i);
+
+    void setIcon(GuiImage *i);
+
+    void setIconOver(GuiImage *i);
+
+    //!Sets the button's image on hold
+    //!\param i Pointer to GuiImage object
+    void setImageHold(GuiImage *i);
+
+    //!Sets the button's image on click
+    //!\param i Pointer to GuiImage object
+    void setImageClick(GuiImage *i);
+
+    //!Sets the button's label
+    //!\param t Pointer to GuiText object
+    //!\param n Index of label to set (optional, default is 0)
+    void setLabel(GuiText *t, int32_t n = 0);
+
+    //!Sets the button's label on over (eg: different colored text)
+    //!\param t Pointer to GuiText object
+    //!\param n Index of label to set (optional, default is 0)
+    void setLabelOver(GuiText *t, int32_t n = 0);
+
+    //!Sets the button's label on hold
+    //!\param t Pointer to GuiText object
+    //!\param n Index of label to set (optional, default is 0)
+    void setLabelHold(GuiText *t, int32_t n = 0);
+
+    //!Sets the button's label on click
+    //!\param t Pointer to GuiText object
+    //!\param n Index of label to set (optional, default is 0)
+    void setLabelClick(GuiText *t, int32_t n = 0);
+
+    //!Sets the sound to play on over
+    //!\param s Pointer to GuiSound object
+    void setSoundOver(GuiSound *s);
+
+    //!Sets the sound to play on hold
+    //!\param s Pointer to GuiSound object
+    void setSoundHold(GuiSound *s);
+
+    //!Sets the sound to play on click
+    //!\param s Pointer to GuiSound object
+    void setSoundClick(GuiSound *s);
+
+    //!Set a new GuiTrigger for the element
+    //!\param i Index of trigger array to set
+    //!\param t Pointer to GuiTrigger
+    void setTrigger(GuiTrigger *t, int32_t idx = -1);
+
+    //!
+    void resetState(void);
+
+    //!Constantly called to draw the GuiButton
+    void draw(CVideo *video)  override;
+
+    //!Constantly called to allow the GuiButton to respond to updated input data
+    //!\param t Pointer to a GuiTrigger, containing the current input data from PAD/WPAD
+    void update(GuiController *c);
+
+    sigslot::signal2<GuiButton *, const GuiController *> selected;
+    sigslot::signal2<GuiButton *, const GuiController *> deSelected;
+    sigslot::signal2<GuiButton *, const GuiController *> pointedOn;
+    sigslot::signal2<GuiButton *, const GuiController *> pointedOff;
+    sigslot::signal3<GuiButton *, const GuiController *, GuiTrigger *> clicked;
+    sigslot::signal3<GuiButton *, const GuiController *, GuiTrigger *> held;
+    sigslot::signal3<GuiButton *, const GuiController *, GuiTrigger *> released;
+
+protected:
+    static const int32_t iMaxGuiTriggers = 10;
+
+    GuiImage *image;      //!< Button image (default)
+    GuiImage *imageOver;  //!< Button image for STATE_SELECTED
+    GuiImage *imageHold;  //!< Button image for STATE_HELD
+    GuiImage *imageClick; //!< Button image for STATE_CLICKED
+    GuiImage *icon;
+    GuiImage *iconOver;
+    GuiText *label[4];                    //!< Label(s) to display (default)
+    GuiText *labelOver[4];                //!< Label(s) to display for STATE_SELECTED
+    GuiText *labelHold[4];                //!< Label(s) to display for STATE_HELD
+    GuiText *labelClick[4];               //!< Label(s) to display for STATE_CLICKED
+    GuiSound *soundOver;                  //!< Sound to play for STATE_SELECTED
+    GuiSound *soundHold;                  //!< Sound to play for STATE_HELD
+    GuiSound *soundClick;                 //!< Sound to play for STATE_CLICKED
+    GuiTrigger *trigger[iMaxGuiTriggers]; //!< GuiTriggers (input actions) that this element responds to
+    GuiTrigger *clickedTrigger;
+    GuiTrigger *heldTrigger;
+};
+
+#endif

src/gui/GuiCheckBox.cpp

@@ -0,0 +1,68 @@
+/****************************************************************************
+ * Copyright (C) 2016,2017 Maschell
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <gui/GuiCheckBox.h>
+#include <gui/GuiImage.h>
+#include <gui/GuiImageData.h>
+
+/**
+ * Constructor for the GuiCheckBox class.
+ */
+
+GuiCheckBox::GuiCheckBox(GuiImage *background, bool checked, float width, float height)
+    : GuiToggle(checked, width, height) {
+    setImageBackground(background);
+}
+
+/**
+ * Destructor for the GuiCheckBox class.
+ */
+GuiCheckBox::~GuiCheckBox() {
+}
+
+void GuiCheckBox::setImageBackground(GuiImage *img) {
+    backgroundImg = img;
+    if (img) {
+        img->setParent(this);
+    }
+}
+
+void GuiCheckBox::setImageSelected(GuiImage *img) {
+    selectedImg = img;
+    if (img) {
+        img->setParent(this);
+    }
+}
+
+void GuiCheckBox::setImageHighlighted(GuiImage *img) {
+    highlightedImg = img;
+    if (img) {
+        img->setParent(this);
+    }
+    setIconOver(img);
+}
+
+void GuiCheckBox::update(GuiController *c) {
+    if (bChanged) {
+        if (selected) {
+            GuiButton::setImage(selectedImg);
+        } else {
+            GuiButton::setImage(backgroundImg);
+        }
+        bChanged = false;
+    }
+    GuiToggle::update(c);
+}

src/gui/GuiCheckBox.h

@@ -0,0 +1,48 @@
+/****************************************************************************
+ * Copyright (C) 2016,2017 Maschell
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef GUI_CHECKBOX_H_
+#define GUI_CHECKBOX_H_
+
+#include <gui/GuiImage.h>
+#include <gui/GuiImageData.h>
+#include <gui/GuiToggle.h>
+
+//!A simple CheckBox
+class GuiCheckBox : public GuiToggle {
+public:
+    //!Constructor
+    //!\param checked Checked
+    GuiCheckBox(GuiImage *background, bool checked, float width = 0.0f, float height = 0.0f);
+
+    //!Destructor
+    virtual ~GuiCheckBox();
+
+    void setImageBackground(GuiImage *img);
+
+    void setImageSelected(GuiImage *img);
+
+    void setImageHighlighted(GuiImage *img);
+
+protected:
+    GuiImage *backgroundImg  = NULL;
+    GuiImage *selectedImg    = NULL;
+    GuiImage *highlightedImg = NULL;
+
+    void update(GuiController *c);
+};
+
+#endif

src/gui/GuiController.h

@@ -0,0 +1,73 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef GUI_CONTROLLER_H_
+#define GUI_CONTROLLER_H_
+
+#include <gui/GuiTrigger.h>
+#include <string.h>
+
+class GuiController {
+public:
+    //!Constructor
+    GuiController(int32_t channel)
+        : chan(channel) {
+        memset(&lastData, 0, sizeof(lastData));
+        memset(&data, 0, sizeof(data));
+
+        switch (chan) {
+            default:
+            case GuiTrigger::CHANNEL_1:
+                chanIdx = 0;
+                break;
+            case GuiTrigger::CHANNEL_2:
+                chanIdx = 1;
+                break;
+            case GuiTrigger::CHANNEL_3:
+                chanIdx = 2;
+                break;
+            case GuiTrigger::CHANNEL_4:
+                chanIdx = 3;
+                break;
+            case GuiTrigger::CHANNEL_5:
+                chanIdx = 4;
+                break;
+        }
+    }
+
+    //!Destructor
+    virtual ~GuiController() {}
+
+    virtual bool update(int32_t width, int32_t height) = 0;
+
+    typedef struct {
+        uint32_t buttons_h;
+        uint32_t buttons_d;
+        uint32_t buttons_r;
+        bool validPointer;
+        bool touched;
+        float pointerAngle;
+        int32_t x;
+        int32_t y;
+    } PadData;
+
+    int32_t chan;
+    int32_t chanIdx;
+    PadData data;
+    PadData lastData;
+};
+
+#endif

src/gui/GuiDragListener.cpp

@@ -0,0 +1,80 @@
+/****************************************************************************
+ * Copyright (C) 2016 Maschell
+ * based on GuiButton by dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <gui/GuiController.h>
+#include <gui/GuiDragListener.h>
+
+/**
+ * Constructor for the GuiDragListener class.
+ */
+
+GuiDragListener::GuiDragListener(float w, float h) {
+    width  = w;
+    height = h;
+    for (int32_t i = 0; i < iMaxGuiTriggers; i++) {
+        trigger[i] = NULL;
+    }
+}
+
+/**
+ * Destructor for the GuiDragListener class.
+ */
+GuiDragListener::~GuiDragListener() {
+}
+
+void GuiDragListener::setState(int32_t i, int32_t c) {
+    GuiElement::setState(i, c);
+}
+
+void GuiDragListener::setTrigger(GuiTrigger *t, int32_t idx) {
+    if (idx >= 0 && idx < iMaxGuiTriggers) {
+        trigger[idx] = t;
+    } else {
+        for (int32_t i = 0; i < iMaxGuiTriggers; i++) {
+            if (!trigger[i]) {
+                trigger[i] = t;
+                break;
+            }
+        }
+    }
+}
+
+void GuiDragListener::update(GuiController *c) {
+    if (!c || isStateSet(STATE_DISABLED | STATE_HIDDEN | STATE_DISABLE_INPUT, c->chanIdx)) {
+        return;
+    } else if (parentElement && (parentElement->isStateSet(STATE_DISABLED | STATE_HIDDEN | STATE_DISABLE_INPUT, c->chanIdx))) {
+        return;
+    }
+
+    for (int32_t i = 0; i < iMaxGuiTriggers; i++) {
+        if (!trigger[i]) {
+            continue;
+        }
+
+        bool isHeld = trigger[i]->held(c);
+
+
+        if (isHeld && this->isInside(c->data.x, c->data.y)) {
+            int32_t dx = c->data.x - c->lastData.x;
+            int32_t dy = c->data.y - c->lastData.y;
+
+            if (dx == 0 && dy == 0) { continue; }
+
+            dragged(this, c, trigger[i], dx, dy);
+        }
+    }
+}

src/gui/GuiDragListener.h

@@ -0,0 +1,54 @@
+/****************************************************************************
+ * Copyright (C) 2016 Maschell
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef GUI_DRAG_LISTENER_H_
+#define GUI_DRAG_LISTENER_H_
+
+#include <gui/GuiButton.h>
+#include <gui/GuiController.h>
+#include <gui/GuiElement.h>
+#include <gui/GuiTrigger.h>
+
+class GuiDragListener : public GuiElement {
+public:
+    //!Constructor
+    //!\param w Width
+    //!\param h Height
+    GuiDragListener(float w, float h);
+
+    //!Destructor
+    virtual ~GuiDragListener();
+
+    void setState(int32_t i, int32_t c);
+
+    //!Set a new GuiTrigger for the element
+    //!\param i Index of trigger array to set
+    //!\param t Pointer to GuiTrigger
+    void setTrigger(GuiTrigger *t, int32_t idx = -1);
+
+    //!Constantly called to allow the GuiDragListener to respond to updated input data
+    //!\param t Pointer to a GuiTrigger, containing the current input data from PAD/WPAD
+    void update(GuiController *c);
+
+    sigslot::signal5<GuiDragListener *, const GuiController *, GuiTrigger *, int32_t, int32_t> dragged;
+
+protected:
+    static const int32_t iMaxGuiTriggers = 10;
+
+    GuiTrigger *trigger[iMaxGuiTriggers]; //!< GuiTriggers (input actions) that this element responds to
+};
+
+#endif

src/gui/GuiElement.cpp

@@ -0,0 +1,289 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <gui/GuiElement.h>
+
+//! TODO remove this!
+static int32_t screenwidth  = 1280;
+static int32_t screenheight = 720;
+
+/**
+ * Constructor for the Object class.
+ */
+GuiElement::GuiElement() {
+    xoffset = 0.0f;
+    yoffset = 0.0f;
+    zoffset = 0.0f;
+    width   = 0.0f;
+    height  = 0.0f;
+    alpha   = 1.0f;
+    scaleX  = 1.0f;
+    scaleY  = 1.0f;
+    scaleZ  = 1.0f;
+    for (int32_t i = 0; i < 5; i++) {
+        state[i] = STATE_DEFAULT;
+    }
+    stateChan                = -1;
+    parentElement            = NULL;
+    rumble                   = true;
+    selectable               = false;
+    clickable                = false;
+    holdable                 = false;
+    drawOverOnlyWhenSelected = false;
+    visible                  = true;
+    yoffsetDyn               = 0;
+    xoffsetDyn               = 0;
+    alphaDyn                 = -1;
+    scaleDyn                 = 1;
+    effects                  = EFFECT_NONE;
+    effectAmount             = 0;
+    effectTarget             = 0;
+    effectsOver              = EFFECT_NONE;
+    effectAmountOver         = 0;
+    effectTargetOver         = 0;
+    angle                    = 0.0f;
+
+    // default alignment - align to top left
+    alignment = (ALIGN_CENTER | ALIGN_MIDDLE);
+}
+
+/**
+ * Get the left position of the GuiElement.
+ * @see SetLeft()
+ * @return Left position in pixel.
+ */
+float GuiElement::getLeft() {
+    float pWidth  = 0;
+    float pLeft   = 0;
+    float pScaleX = 1.0f;
+
+    if (parentElement) {
+        pWidth  = parentElement->getWidth();
+        pLeft   = parentElement->getLeft();
+        pScaleX = parentElement->getScaleX();
+    }
+
+    pLeft += xoffsetDyn;
+
+    float x = pLeft;
+
+    //! TODO: the conversion from int to float and back to int is bad for performance, change that
+    if (alignment & ALIGN_CENTER) {
+        x = pLeft + pWidth * 0.5f * pScaleX - width * 0.5f * getScaleX();
+    } else if (alignment & ALIGN_RIGHT) {
+        x = pLeft + pWidth * pScaleX - width * getScaleX();
+    }
+
+    return x + xoffset;
+}
+
+/**
+ * Get the top position of the GuiElement.
+ * @see SetTop()
+ * @return Top position in pixel.
+ */
+float GuiElement::getTop() {
+    float pHeight = 0;
+    float pTop    = 0;
+    float pScaleY = 1.0f;
+
+    if (parentElement) {
+        pHeight = parentElement->getHeight();
+        pTop    = parentElement->getTop();
+        pScaleY = parentElement->getScaleY();
+    }
+
+    pTop += yoffsetDyn;
+
+    float y = pTop;
+
+    //! TODO: the conversion from int to float and back to int is bad for performance, change that
+    if (alignment & ALIGN_MIDDLE) {
+        y = pTop + pHeight * 0.5f * pScaleY - getHeight() * 0.5f * getScaleY();
+    } else if (alignment & ALIGN_BOTTOM) {
+        y = pTop + pHeight * pScaleY - getHeight() * getScaleY();
+    }
+
+    return y + yoffset;
+}
+
+void GuiElement::setEffect(int32_t eff, int32_t amount, int32_t target) {
+    if (eff & EFFECT_SLIDE_IN) {
+        // these calculations overcompensate a little
+        if (eff & EFFECT_SLIDE_TOP) {
+            if (eff & EFFECT_SLIDE_FROM) {
+                yoffsetDyn = (int32_t) -getHeight() * scaleY;
+            } else {
+                yoffsetDyn = -screenheight;
+            }
+        } else if (eff & EFFECT_SLIDE_LEFT) {
+            if (eff & EFFECT_SLIDE_FROM) {
+                xoffsetDyn = (int32_t) -getWidth() * scaleX;
+            } else {
+                xoffsetDyn = -screenwidth;
+            }
+        } else if (eff & EFFECT_SLIDE_BOTTOM) {
+            if (eff & EFFECT_SLIDE_FROM) {
+                yoffsetDyn = (int32_t) getHeight() * scaleY;
+            } else {
+                yoffsetDyn = screenheight;
+            }
+        } else if (eff & EFFECT_SLIDE_RIGHT) {
+            if (eff & EFFECT_SLIDE_FROM) {
+                xoffsetDyn = (int32_t) getWidth() * scaleX;
+            } else {
+                xoffsetDyn = screenwidth;
+            }
+        }
+    }
+    if ((eff & EFFECT_FADE) && amount > 0) {
+        alphaDyn = 0;
+    } else if ((eff & EFFECT_FADE) && amount < 0) {
+        alphaDyn = alpha;
+    }
+    effects |= eff;
+    effectAmount = amount;
+    effectTarget = target;
+}
+
+//!Sets an effect to be enabled on wiimote cursor over
+//!\param e Effect to enable
+//!\param a Amount of the effect (usage varies on effect)
+//!\param t Target amount of the effect (usage varies on effect)
+void GuiElement::setEffectOnOver(int32_t e, int32_t a, int32_t t) {
+    effectsOver |= e;
+    effectAmountOver = a;
+    effectTargetOver = t;
+}
+
+void GuiElement::resetEffects() {
+    yoffsetDyn       = 0;
+    xoffsetDyn       = 0;
+    alphaDyn         = -1;
+    scaleDyn         = 1;
+    effects          = EFFECT_NONE;
+    effectAmount     = 0;
+    effectTarget     = 0;
+    effectsOver      = EFFECT_NONE;
+    effectAmountOver = 0;
+    effectTargetOver = 0;
+}
+
+void GuiElement::updateEffects() {
+    if (!this->isVisible() && parentElement) {
+        return;
+    }
+
+    if (effects & (EFFECT_SLIDE_IN | EFFECT_SLIDE_OUT | EFFECT_SLIDE_FROM)) {
+        if (effects & EFFECT_SLIDE_IN) {
+            if (effects & EFFECT_SLIDE_LEFT) {
+                xoffsetDyn += effectAmount;
+
+                if (xoffsetDyn >= 0) {
+                    xoffsetDyn = 0;
+                    effects    = 0;
+                    effectFinished(this);
+                }
+            } else if (effects & EFFECT_SLIDE_RIGHT) {
+                xoffsetDyn -= effectAmount;
+
+                if (xoffsetDyn <= 0) {
+                    xoffsetDyn = 0;
+                    effects    = 0;
+                    effectFinished(this);
+                }
+            } else if (effects & EFFECT_SLIDE_TOP) {
+                yoffsetDyn += effectAmount;
+
+                if (yoffsetDyn >= 0) {
+                    yoffsetDyn = 0;
+                    effects    = 0;
+                    effectFinished(this);
+                }
+            } else if (effects & EFFECT_SLIDE_BOTTOM) {
+                yoffsetDyn -= effectAmount;
+
+                if (yoffsetDyn <= 0) {
+                    yoffsetDyn = 0;
+                    effects    = 0;
+                    effectFinished(this);
+                }
+            }
+        } else {
+            if (effects & EFFECT_SLIDE_LEFT) {
+                xoffsetDyn -= effectAmount;
+
+                if (xoffsetDyn <= -screenwidth) {
+                    effects = 0; // shut off effect
+                    effectFinished(this);
+                } else if ((effects & EFFECT_SLIDE_FROM) && xoffsetDyn <= -getWidth()) {
+                    effects = 0; // shut off effect
+                    effectFinished(this);
+                }
+            } else if (effects & EFFECT_SLIDE_RIGHT) {
+                xoffsetDyn += effectAmount;
+
+                if (xoffsetDyn >= screenwidth) {
+                    effects = 0; // shut off effect
+                    effectFinished(this);
+                } else if ((effects & EFFECT_SLIDE_FROM) && xoffsetDyn >= getWidth() * scaleX) {
+                    effects = 0; // shut off effect
+                    effectFinished(this);
+                }
+            } else if (effects & EFFECT_SLIDE_TOP) {
+                yoffsetDyn -= effectAmount;
+
+                if (yoffsetDyn <= -screenheight) {
+                    effects = 0; // shut off effect
+                    effectFinished(this);
+                } else if ((effects & EFFECT_SLIDE_FROM) && yoffsetDyn <= -getHeight()) {
+                    effects = 0; // shut off effect
+                    effectFinished(this);
+                }
+            } else if (effects & EFFECT_SLIDE_BOTTOM) {
+                yoffsetDyn += effectAmount;
+
+                if (yoffsetDyn >= screenheight) {
+                    effects = 0; // shut off effect
+                    effectFinished(this);
+                } else if ((effects & EFFECT_SLIDE_FROM) && yoffsetDyn >= getHeight()) {
+                    effects = 0; // shut off effect
+                    effectFinished(this);
+                }
+            }
+        }
+    } else if (effects & EFFECT_FADE) {
+        alphaDyn += effectAmount * (1.0f / 255.0f);
+
+        if (effectAmount < 0 && alphaDyn <= 0) {
+            alphaDyn = 0;
+            effects  = 0; // shut off effect
+            effectFinished(this);
+        } else if (effectAmount > 0 && alphaDyn >= alpha) {
+            alphaDyn = alpha;
+            effects  = 0; // shut off effect
+            effectFinished(this);
+        }
+    } else if (effects & EFFECT_SCALE) {
+        scaleDyn += effectAmount * 0.01f;
+
+        if ((effectAmount < 0 && scaleDyn <= (effectTarget * 0.01f)) || (effectAmount > 0 && scaleDyn >= (effectTarget * 0.01f))) {
+            scaleDyn = effectTarget * 0.01f;
+            effects  = 0; // shut off effect
+            effectFinished(this);
+        }
+    }
+}

src/gui/GuiElement.h

@@ -0,0 +1,610 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef GUI_ELEMENT_H_
+#define GUI_ELEMENT_H_
+
+#include <string>
+#include <vector>
+
+#include <malloc.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <wchar.h>
+
+#include <gui/gx2_ext.h>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <gui/sigslot.h>
+
+
+enum {
+    EFFECT_NONE             = 0x00,
+    EFFECT_SLIDE_TOP        = 0x01,
+    EFFECT_SLIDE_BOTTOM     = 0x02,
+    EFFECT_SLIDE_RIGHT      = 0x04,
+    EFFECT_SLIDE_LEFT       = 0x08,
+    EFFECT_SLIDE_IN         = 0x10,
+    EFFECT_SLIDE_OUT        = 0x20,
+    EFFECT_SLIDE_FROM       = 0x40,
+    EFFECT_FADE             = 0x80,
+    EFFECT_SCALE            = 0x100,
+    EFFECT_COLOR_TRANSITION = 0x200
+};
+
+enum {
+    ALIGN_LEFT       = 0x01,
+    ALIGN_CENTER     = 0x02,
+    ALIGN_RIGHT      = 0x04,
+    ALIGN_TOP        = 0x10,
+    ALIGN_MIDDLE     = 0x20,
+    ALIGN_BOTTOM     = 0x40,
+    ALIGN_TOP_LEFT   = ALIGN_LEFT | ALIGN_TOP,
+    ALIGN_TOP_CENTER = ALIGN_CENTER | ALIGN_TOP,
+    ALIGN_TOP_RIGHT  = ALIGN_RIGHT | ALIGN_TOP,
+    ALIGN_CENTERED   = ALIGN_CENTER | ALIGN_MIDDLE,
+};
+
+//!Forward declaration
+class GuiController;
+
+class CVideo;
+
+//!Primary GUI class. Most other classes inherit from this class.
+class GuiElement {
+public:
+    //!Constructor
+    GuiElement();
+
+    //!Destructor
+    virtual ~GuiElement() {}
+
+    //!Set the element's parent
+    //!\param e Pointer to parent element
+    virtual void setParent(GuiElement *e) {
+        parentElement = e;
+    }
+
+    //!Gets the element's parent
+    //!\return Pointer to parent element
+    virtual GuiElement *getParent() {
+        return parentElement;
+    }
+
+    //!Gets the current leftmost coordinate of the element
+    //!Considers horizontal alignment, x offset, width, and parent element's GetLeft() / GetWidth() values
+    //!\return left coordinate
+    virtual float getLeft();
+
+    //!Gets the current topmost coordinate of the element
+    //!Considers vertical alignment, y offset, height, and parent element's GetTop() / GetHeight() values
+    //!\return top coordinate
+    virtual float getTop();
+
+    //!Gets the current Z coordinate of the element
+    //!\return Z coordinate
+    virtual float getDepth() {
+        float zParent = 0.0f;
+
+        if (parentElement) {
+            zParent = parentElement->getDepth();
+        }
+
+        return zParent + zoffset;
+    }
+
+    virtual float getCenterX(void) {
+        float pCenterX = 0.0f;
+
+        if (parentElement) {
+            pCenterX = parentElement->getCenterX();
+        }
+
+        pCenterX += xoffset + xoffsetDyn;
+
+        if (alignment & ALIGN_LEFT) {
+            float pWidth = 0.0f;
+            float pScale = 0.0f;
+
+            if (parentElement) {
+                pWidth = parentElement->getWidth();
+                pScale = parentElement->getScaleX();
+            }
+
+            pCenterX -= pWidth * 0.5f * pScale - width * 0.5f * getScaleX();
+        } else if (alignment & ALIGN_RIGHT) {
+            float pWidth = 0.0f;
+            float pScale = 0.0f;
+
+            if (parentElement) {
+                pWidth = parentElement->getWidth();
+                pScale = parentElement->getScaleX();
+            }
+
+            pCenterX += pWidth * 0.5f * pScale - width * 0.5f * getScaleX();
+        }
+        return pCenterX;
+    }
+
+    virtual float getCenterY(void) {
+        float pCenterY = 0.0f;
+
+        if (parentElement) {
+            pCenterY = parentElement->getCenterY();
+        }
+
+        pCenterY += yoffset + yoffsetDyn;
+
+        if (alignment & ALIGN_TOP) {
+            float pHeight = 0.0f;
+            float pScale  = 0.0f;
+
+            if (parentElement) {
+                pHeight = parentElement->getHeight();
+                pScale  = parentElement->getScaleY();
+            }
+
+            pCenterY += pHeight * 0.5f * pScale - getHeight() * 0.5f * getScaleY();
+        } else if (alignment & ALIGN_BOTTOM) {
+            float pHeight = 0.0f;
+            float pScale  = 0.0f;
+
+            if (parentElement) {
+                pHeight = parentElement->getHeight();
+                pScale  = parentElement->getScaleY();
+            }
+
+            pCenterY -= pHeight * 0.5f * pScale - getHeight() * 0.5f * getScaleY();
+        }
+        return pCenterY;
+    }
+
+    //!Gets elements xoffset
+    virtual float getOffsetX() {
+        return xoffset;
+    }
+
+    //!Gets elements yoffset
+    virtual float getOffsetY() {
+        return yoffset;
+    }
+
+    //!Gets the current width of the element. Does not currently consider the scale
+    //!\return width
+    virtual float getWidth() {
+        return width;
+    };
+
+    //!Gets the height of the element. Does not currently consider the scale
+    //!\return height
+    virtual float getHeight() {
+        return height;
+    }
+
+    //!Sets the size (width/height) of the element
+    //!\param w Width of element
+    //!\param h Height of element
+    virtual void setSize(float w, float h) {
+        width  = w;
+        height = h;
+    }
+
+    //!Sets the element's visibility
+    //!\param v Visibility (true = visible)
+    virtual void setVisible(bool v) {
+        visible = v;
+        visibleChanged(this, v);
+    }
+
+    //!Checks whether or not the element is visible
+    //!\return true if visible, false otherwise
+    virtual bool isVisible() const {
+        return !isStateSet(STATE_HIDDEN) && visible;
+    };
+
+    //!Checks whether or not the element is selectable
+    //!\return true if selectable, false otherwise
+    virtual bool isSelectable() {
+        return !isStateSet(STATE_DISABLED) && selectable;
+    }
+
+    virtual bool isDrawOverOnlyWhenSelected() {
+        return drawOverOnlyWhenSelected;
+    }
+
+    virtual void setdrawOverOnlyWhenSelected(bool s) {
+        drawOverOnlyWhenSelected = s;
+    }
+
+    //!Checks whether or not the element is clickable
+    //!\return true if clickable, false otherwise
+    virtual bool isClickable() {
+        return !isStateSet(STATE_DISABLED) && clickable;
+    }
+
+    //!Checks whether or not the element is holdable
+    //!\return true if holdable, false otherwise
+    virtual bool isHoldable() {
+        return !isStateSet(STATE_DISABLED) && holdable;
+    }
+
+    //!Sets whether or not the element is selectable
+    //!\param s Selectable
+    virtual void setSelectable(bool s) {
+        selectable = s;
+    }
+
+    //!Sets whether or not the element is clickable
+    //!\param c Clickable
+    virtual void setClickable(bool c) {
+        clickable = c;
+    }
+
+    //!Sets whether or not the element is holdable
+    //!\param c Holdable
+    virtual void setHoldable(bool d) {
+        holdable = d;
+    }
+
+    //!Sets the element's state
+    //!\param s State (STATE_DEFAULT, STATE_SELECTED, STATE_CLICKED, STATE_DISABLED)
+    //!\param c Controller channel (0-3, -1 = none)
+    virtual void setState(int32_t s, int32_t c = -1) {
+        if (c >= 0 && c < 5) {
+            state[c] |= s;
+        } else {
+            for (int32_t i = 0; i < 5; i++) {
+                state[i] |= s;
+            }
+        }
+        stateChan = c;
+        stateChanged(this, s, c);
+    }
+
+    virtual void clearState(int32_t s, int32_t c = -1) {
+        if (c >= 0 && c < 5) {
+            state[c] &= ~s;
+        } else {
+            for (int32_t i = 0; i < 5; i++) {
+                state[i] &= ~s;
+            }
+        }
+        stateChan = c;
+        stateChanged(this, s, c);
+    }
+
+    virtual bool isStateSet(int32_t s, int32_t c = -1) const {
+        if (c >= 0 && c < 5) {
+            return (state[c] & s) != 0;
+        } else {
+            for (int32_t i = 0; i < 5; i++) {
+                if ((state[i] & s) != 0) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+
+    //!Gets the element's current state
+    //!\return state
+    virtual int32_t getState(int32_t c = 0) {
+        return state[c];
+    };
+
+    //!Gets the controller channel that last changed the element's state
+    //!\return Channel number (0-3, -1 = no channel)
+    virtual int32_t getStateChan() {
+        return stateChan;
+    };
+
+    //!Resets the element's state to STATE_DEFAULT
+    virtual void resetState() {
+        for (int32_t i = 0; i < 5; i++) {
+            state[i] = STATE_DEFAULT;
+        }
+        stateChan = -1;
+    }
+
+    //!Sets the element's alpha value
+    //!\param a alpha value
+    virtual void setAlpha(float a) {
+        alpha = a;
+    }
+
+    //!Gets the element's alpha value
+    //!Considers alpha, alphaDyn, and the parent element's getAlpha() value
+    //!\return alpha
+    virtual float getAlpha() {
+        float a;
+
+        if (alphaDyn >= 0) {
+            a = alphaDyn;
+        } else {
+            a = alpha;
+        }
+
+        if (parentElement) {
+            a = (a * parentElement->getAlpha());
+        }
+
+        return a;
+    }
+
+    //!Sets the element's scale
+    //!\param s scale (1 is 100%)
+    virtual void setScale(float s) {
+        scaleX = s;
+        scaleY = s;
+        scaleZ = s;
+    }
+
+    //!Sets the element's scale
+    //!\param s scale (1 is 100%)
+    virtual void setScaleX(float s) {
+        scaleX = s;
+    }
+
+    //!Sets the element's scale
+    //!\param s scale (1 is 100%)
+    virtual void setScaleY(float s) {
+        scaleY = s;
+    }
+
+    //!Sets the element's scale
+    //!\param s scale (1 is 100%)
+    virtual void setScaleZ(float s) {
+        scaleZ = s;
+    }
+
+    //!Gets the element's current scale
+    //!Considers scale, scaleDyn, and the parent element's getScale() value
+    virtual float getScale() {
+        float s = 0.5f * (scaleX + scaleY) * scaleDyn;
+
+        if (parentElement) {
+            s *= parentElement->getScale();
+        }
+
+        return s;
+    }
+
+    //!Gets the element's current scale
+    //!Considers scale, scaleDyn, and the parent element's getScale() value
+    virtual float getScaleX() {
+        float s = scaleX * scaleDyn;
+
+        if (parentElement) {
+            s *= parentElement->getScaleX();
+        }
+
+        return s;
+    }
+
+    //!Gets the element's current scale
+    //!Considers scale, scaleDyn, and the parent element's getScale() value
+    virtual float getScaleY() {
+        float s = scaleY * scaleDyn;
+
+        if (parentElement) {
+            s *= parentElement->getScaleY();
+        }
+
+        return s;
+    }
+
+    //!Gets the element's current scale
+    //!Considers scale, scaleDyn, and the parent element's getScale() value
+    virtual float getScaleZ() {
+        float s = scaleZ;
+
+        if (parentElement) {
+            s *= parentElement->getScaleZ();
+        }
+
+        return s;
+    }
+
+    //!Checks whether rumble was requested by the element
+    //!\return true is rumble was requested, false otherwise
+    virtual bool isRumbleActive() {
+        return rumble;
+    }
+
+    //!Sets whether or not the element is requesting a rumble event
+    //!\param r true if requesting rumble, false if not
+    virtual void setRumble(bool r) {
+        rumble = r;
+    }
+
+    //!Set an effect for the element
+    //!\param e Effect to enable
+    //!\param a Amount of the effect (usage varies on effect)
+    //!\param t Target amount of the effect (usage varies on effect)
+    virtual void setEffect(int32_t e, int32_t a, int32_t t = 0);
+
+    //!Sets an effect to be enabled on wiimote cursor over
+    //!\param e Effect to enable
+    //!\param a Amount of the effect (usage varies on effect)
+    //!\param t Target amount of the effect (usage varies on effect)
+    virtual void setEffectOnOver(int32_t e, int32_t a, int32_t t = 0);
+
+    //!Shortcut to SetEffectOnOver(EFFECT_SCALE, 4, 110)
+    virtual void setEffectGrow() {
+        setEffectOnOver(EFFECT_SCALE, 4, 110);
+    }
+
+    //!Reset all applied effects
+    virtual void resetEffects();
+
+    //!Gets the current element effects
+    //!\return element effects
+    virtual int32_t getEffect() const {
+        return effects;
+    }
+
+    //!\return true if element animation is on going
+    virtual bool isAnimated() const {
+        return (parentElement != 0) && (getEffect() > 0);
+    }
+
+    //!Checks whether the specified coordinates are within the element's boundaries
+    //!\param x X coordinate
+    //!\param y Y coordinate
+    //!\return true if contained within, false otherwise
+    virtual bool isInside(float x, float y) {
+        return (x > (this->getCenterX() - getScaleX() * getWidth() * 0.5f) && x < (this->getCenterX() + getScaleX() * getWidth() * 0.5f) && y > (this->getCenterY() - getScaleY() * getHeight() * 0.5f) && y < (this->getCenterY() + getScaleY() * getHeight() * 0.5f));
+    }
+
+    //!Sets the element's position
+    //!\param x X coordinate
+    //!\param y Y coordinate
+    virtual void setPosition(float x, float y) {
+        xoffset = x;
+        yoffset = y;
+    }
+
+    //!Sets the element's position
+    //!\param x X coordinate
+    //!\param y Y coordinate
+    //!\param z Z coordinate
+    virtual void setPosition(float x, float y, float z) {
+        xoffset = x;
+        yoffset = y;
+        zoffset = z;
+    }
+
+    //!Gets whether or not the element is in STATE_SELECTED
+    //!\return true if selected, false otherwise
+    virtual int32_t getSelected() {
+        return -1;
+    }
+
+    //!Sets the element's alignment respective to its parent element
+    //!Bitwise ALIGN_LEFT | ALIGN_RIGHT | ALIGN_CENTRE, ALIGN_TOP, ALIGN_BOTTOM, ALIGN_MIDDLE)
+    //!\param align Alignment
+    virtual void setAlignment(int32_t a) {
+        alignment = a;
+    }
+
+    //!Gets the element's alignment
+    virtual int32_t getAlignment() const {
+        return alignment;
+    }
+
+    //!Angle of the object
+    virtual void setAngle(float a) {
+        angle = a;
+    }
+
+    //!Angle of the object
+    virtual float getAngle() const {
+        float r_angle = angle;
+        if (parentElement) { r_angle += parentElement->getAngle(); }
+        return r_angle;
+    }
+
+    //!Called constantly to allow the element to respond to the current input data
+    //!\param t Pointer to a GuiController, containing the current input data from PAD/WPAD/VPAD
+    virtual void update(GuiController *t) {}
+
+    //!Called constantly to redraw the element
+    virtual void draw(CVideo *v) {}
+
+    //!Called constantly to process stuff in the element
+    virtual void process() {}
+
+    //!Updates the element's effects (dynamic values)
+    //!Called by Draw(), used for animation purposes
+    virtual void updateEffects();
+
+    typedef struct _POINT {
+        int32_t x;
+        int32_t y;
+    } POINT;
+
+    enum {
+        STATE_DEFAULT       = 0,
+        STATE_SELECTED      = 0x01,
+        STATE_CLICKED       = 0x02,
+        STATE_HELD          = 0x04,
+        STATE_OVER          = 0x08,
+        STATE_HIDDEN        = 0x10,
+        STATE_DISABLE_INPUT = 0x20,
+        STATE_CLICKED_TOUCH = 0x40,
+        STATE_DISABLED      = 0x80
+    };
+
+    //! Switch pointer from control to screen position
+    POINT PtrToScreen(POINT p) {
+        //! TODO for 3D
+        //POINT r = { p.x + getLeft(), p.y + getTop() };
+        return p;
+    }
+
+    //! Switch pointer screen to control position
+    POINT PtrToControl(POINT p) {
+        //! TODO for 3D
+        //POINT r = { p.x - getLeft(), p.y - getTop() };
+        return p;
+    }
+
+    //! Signals
+    sigslot::signal2<GuiElement *, bool> visibleChanged;
+    sigslot::signal3<GuiElement *, int32_t, int32_t> stateChanged;
+    sigslot::signal1<GuiElement *> effectFinished;
+
+protected:
+    bool rumble;                   //!< Wiimote rumble (on/off) - set to on when this element requests a rumble event
+    bool visible;                  //!< Visibility of the element. If false, Draw() is skipped
+    bool selectable;               //!< Whether or not this element selectable (can change to SELECTED state)
+    bool clickable;                //!< Whether or not this element is clickable (can change to CLICKED state)
+    bool holdable;                 //!< Whether or not this element is holdable (can change to HELD state)
+    bool drawOverOnlyWhenSelected; //!< Whether or not this element is holdable (can change to HELD state)
+    float width;                   //!< Element width
+    float height;                  //!< Element height
+    float xoffset;                 //!< Element X offset
+    float yoffset;                 //!< Element Y offset
+    float zoffset;                 //!< Element Z offset
+    float alpha;                   //!< Element alpha value (0-255)
+    float angle;                   //!< Angle of the object (0-360)
+    float scaleX;                  //!< Element scale (1 = 100%)
+    float scaleY;                  //!< Element scale (1 = 100%)
+    float scaleZ;                  //!< Element scale (1 = 100%)
+    int32_t alignment;             //!< Horizontal element alignment, respective to parent element
+    int32_t state[5];              //!< Element state (DEFAULT, SELECTED, CLICKED, DISABLED)
+    int32_t stateChan;             //!< Which controller channel is responsible for the last change in state
+    GuiElement *parentElement;     //!< Parent element
+
+    //! TODO: Move me to some Animator class
+    int32_t xoffsetDyn;       //!< Element X offset, dynamic (added to xoffset value for animation effects)
+    int32_t yoffsetDyn;       //!< Element Y offset, dynamic (added to yoffset value for animation effects)
+    float alphaDyn;           //!< Element alpha, dynamic (multiplied by alpha value for blending/fading effects)
+    float scaleDyn;           //!< Element scale, dynamic (multiplied by alpha value for blending/fading effects)
+    int32_t effects;          //!< Currently enabled effect(s). 0 when no effects are enabled
+    int32_t effectAmount;     //!< Effect amount. Used by different effects for different purposes
+    int32_t effectTarget;     //!< Effect target amount. Used by different effects for different purposes
+    int32_t effectsOver;      //!< Effects to enable when wiimote cursor is over this element. Copied to effects variable on over event
+    int32_t effectAmountOver; //!< EffectAmount to set when wiimote cursor is over this element
+    int32_t effectTargetOver; //!< EffectTarget to set when wiimote cursor is over this element
+};
+
+#endif

src/gui/GuiFrame.cpp

@@ -0,0 +1,234 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <gui/GuiFrame.h>
+
+GuiFrame::GuiFrame(GuiFrame *p) {
+    parent = p;
+    width  = 0;
+    height = 0;
+    dim    = false;
+
+    if (parent) {
+        parent->append(this);
+    }
+}
+
+GuiFrame::GuiFrame(float w, float h, GuiFrame *p) {
+    parent = p;
+    width  = w;
+    height = h;
+    dim    = false;
+
+    if (parent) {
+        parent->append(this);
+    }
+}
+
+GuiFrame::~GuiFrame() {
+    closing(this);
+
+    if (parent) {
+        parent->remove(this);
+    }
+}
+
+void GuiFrame::append(GuiElement *e) {
+    if (e == NULL) {
+        return;
+    }
+
+    remove(e);
+    mutex.lock();
+    elements.push_back(e);
+    e->setParent(this);
+    mutex.unlock();
+}
+
+void GuiFrame::insert(GuiElement *e, uint32_t index) {
+    if (e == NULL || (index >= elements.size())) {
+        return;
+    }
+
+    remove(e);
+    mutex.lock();
+    elements.insert(elements.begin() + index, e);
+    e->setParent(this);
+    mutex.unlock();
+}
+
+void GuiFrame::remove(GuiElement *e) {
+    if (e == NULL) {
+        return;
+    }
+
+    mutex.lock();
+    for (uint32_t i = 0; i < elements.size(); ++i) {
+        if (e == elements[i]) {
+            elements.erase(elements.begin() + i);
+            break;
+        }
+    }
+    mutex.unlock();
+}
+
+void GuiFrame::removeAll() {
+    mutex.lock();
+    elements.clear();
+    mutex.unlock();
+}
+
+void GuiFrame::close() {
+    //Application::instance()->pushForDelete(this);
+}
+
+void GuiFrame::dimBackground(bool d) {
+    dim = d;
+}
+
+GuiElement *GuiFrame::getGuiElementAt(uint32_t index) const {
+    if (index >= elements.size()) {
+        return NULL;
+    }
+
+    return elements[index];
+}
+
+uint32_t GuiFrame::getSize() {
+    return elements.size();
+}
+
+void GuiFrame::resetState() {
+    GuiElement::resetState();
+
+    mutex.lock();
+    for (uint32_t i = 0; i < elements.size(); ++i) {
+        elements[i]->resetState();
+    }
+    mutex.unlock();
+}
+
+void GuiFrame::setState(int32_t s, int32_t c) {
+    GuiElement::setState(s, c);
+    mutex.lock();
+    for (uint32_t i = 0; i < elements.size(); ++i) {
+        elements[i]->setState(s, c);
+    }
+    mutex.unlock();
+}
+
+void GuiFrame::clearState(int32_t s, int32_t c) {
+    GuiElement::clearState(s, c);
+
+    mutex.lock();
+    for (uint32_t i = 0; i < elements.size(); ++i) {
+        elements[i]->clearState(s, c);
+    }
+    mutex.unlock();
+}
+
+void GuiFrame::setVisible(bool v) {
+    visible = v;
+
+    mutex.lock();
+    for (uint32_t i = 0; i < elements.size(); ++i) {
+        elements[i]->setVisible(v);
+    }
+    mutex.unlock();
+}
+
+int32_t GuiFrame::getSelected() {
+    // find selected element
+    int32_t found = -1;
+    mutex.lock();
+    for (uint32_t i = 0; i < elements.size(); ++i) {
+        if (elements[i]->isStateSet(STATE_SELECTED | STATE_OVER)) {
+            found = i;
+            break;
+        }
+    }
+    mutex.unlock();
+    return found;
+}
+
+void GuiFrame::draw(CVideo *v) {
+    if (!this->isVisible() && parentElement) {
+        return;
+    }
+
+    if (parentElement && dim == true) {
+        //GXColor dimColor = (GXColor){0, 0, 0, 0x70};
+        //Menu_DrawRectangle(0, 0, GetZPosition(), screenwidth,screenheight, &dimColor, false, true);
+    }
+
+    mutex.lock();
+    //! render appended items next frame but allow stop of render if size is reached
+    uint32_t size = elements.size();
+
+    for (uint32_t i = 0; i < size && i < elements.size(); ++i) {
+        elements[i]->draw(v);
+    }
+    mutex.unlock();
+}
+
+void GuiFrame::updateEffects() {
+    if (!this->isVisible() && parentElement) {
+        return;
+    }
+
+    GuiElement::updateEffects();
+
+    mutex.lock();
+    //! render appended items next frame but allow stop of render if size is reached
+    uint32_t size = elements.size();
+
+    for (uint32_t i = 0; i < size && i < elements.size(); ++i) {
+        elements[i]->updateEffects();
+    }
+    mutex.unlock();
+}
+
+void GuiFrame::process() {
+    if (!this->isVisible() && parentElement) {
+        return;
+    }
+
+    GuiElement::process();
+
+    mutex.lock();
+    //! render appended items next frame but allow stop of render if size is reached
+    uint32_t size = elements.size();
+
+    for (uint32_t i = 0; i < size && i < elements.size(); ++i) {
+        elements[i]->process();
+    }
+    mutex.unlock();
+}
+
+void GuiFrame::update(GuiController *c) {
+    if (isStateSet(STATE_DISABLED) && parentElement) {
+        return;
+    }
+
+    mutex.lock();
+    //! update appended items next frame
+    uint32_t size = elements.size();
+
+    for (uint32_t i = 0; i < size && i < elements.size(); ++i) {
+        elements[i]->update(c);
+    }
+    mutex.unlock();
+}

src/gui/GuiFrame.h

@@ -0,0 +1,127 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef GUI_FRAME_H_
+#define GUI_FRAME_H_
+
+#include <gui/GuiElement.h>
+#include <gui/sigslot.h>
+#include <mutex>
+#include <vector>
+
+//!Allows GuiElements to be grouped together into a "window"
+class GuiFrame : public GuiElement {
+public:
+    //!Constructor
+    GuiFrame(GuiFrame *parent = 0);
+
+    //!\overload
+    //!\param w Width of window
+    //!\param h Height of window
+    GuiFrame(float w, float h, GuiFrame *parent = 0);
+
+    //!Destructor
+    virtual ~GuiFrame();
+
+    //!Appends a GuiElement to the GuiFrame
+    //!\param e The GuiElement to append. If it is already in the GuiFrame, it is removed first
+    void append(GuiElement *e);
+
+    //!Inserts a GuiElement into the GuiFrame at the specified index
+    //!\param e The GuiElement to insert. If it is already in the GuiFrame, it is removed first
+    //!\param i Index in which to insert the element
+    void insert(GuiElement *e, uint32_t i);
+
+    //!Removes the specified GuiElement from the GuiFrame
+    //!\param e GuiElement to be removed
+    void remove(GuiElement *e);
+
+    //!Removes all GuiElements
+    void removeAll();
+
+    //!Bring element to front of the window
+    void bringToFront(GuiElement *e) {
+        remove(e);
+        append(e);
+    }
+
+    //!Returns the GuiElement at the specified index
+    //!\param index The index of the element
+    //!\return A pointer to the element at the index, NULL on error (eg: out of bounds)
+    GuiElement *getGuiElementAt(uint32_t index) const;
+
+    //!Returns the size of the list of elements
+    //!\return The size of the current element list
+    uint32_t getSize();
+
+    //!Sets the visibility of the window
+    //!\param v visibility (true = visible)
+    void setVisible(bool v);
+
+    //!Resets the window's state to STATE_DEFAULT
+    void resetState();
+
+    //!Sets the window's state
+    //!\param s State
+    void setState(int32_t s, int32_t c = -1);
+
+    void clearState(int32_t s, int32_t c = -1);
+
+    //!Gets the index of the GuiElement inside the window that is currently selected
+    //!\return index of selected GuiElement
+    int32_t getSelected();
+
+    //!Dim the Window's background
+    void dimBackground(bool d);
+
+    //!Draws all the elements in this GuiFrame
+    void draw(CVideo *v) override;
+
+    //!Updates the window and all elements contains within
+    //!Allows the GuiFrame and all elements to respond to the input data specified
+    //!\param t Pointer to a GuiTrigger, containing the current input data from PAD/WPAD
+    void update(GuiController *t);
+
+    //!virtual Close Window - this will put the object on the delete queue in MainWindow
+    virtual void close();
+
+    //!virtual show window function
+    virtual void show() {}
+
+    //!virtual hide window function
+    virtual void hide() {}
+
+    //!virtual enter main loop function (blocking)
+    virtual void exec() {}
+
+    //!virtual updateEffects which is called by the main loop
+    virtual void updateEffects();
+
+    //!virtual process which is called by the main loop
+    virtual void process();
+
+    //! Signals
+    //! On Closing
+    sigslot::signal1<GuiFrame *> closing;
+
+protected:
+    bool dim;                           //! Enable/disable dim of a window only
+    GuiFrame *parent;                   //!< Parent Window
+    std::vector<GuiElement *> elements; //!< Contains all elements within the GuiFrame
+    std::recursive_mutex mutex;
+};
+
+#endif

src/gui/GuiIconGrid.cpp

@@ -21,7 +21,7 @@
 #include <coreinit/cache.h>
 #include "common/common.h"
 #include "Application.h"
-#include <gui/video/CVideo.h>
+#include <video/CVideo.h>
 #include "utils/logger.h"
 #include "gui/GameIcon.h"
 

src/gui/GuiIconGrid.h

@@ -36,7 +36,7 @@ public:
 
     void update(GuiController *t);
 
-    void draw(CVideo *pVideo);
+    void draw(CVideo *pVideo) override;
 
     void process();
 

src/gui/GuiImage.cpp

@@ -0,0 +1,270 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include "utils/utils.h"
+#include <gui/GuiImage.h>
+#include <video/CVideo.h>
+#include <video/shaders/ColorShader.h>
+#include <video/shaders/Texture2DShader.h>
+
+static const float fPiDiv180 = ((float) M_PI / 180.0f);
+
+GuiImage::GuiImage(GuiImageData *img) {
+    if (img && img->getTexture()) {
+        width  = img->getWidth();
+        height = img->getHeight();
+    }
+
+    internalInit(width, height);
+    imageData = img;
+}
+
+GuiImage::GuiImage(int32_t w, int32_t h, const GX2Color &c, int32_t type) {
+    internalInit(w, h);
+    imgType    = type;
+    colorCount = ColorShader::cuColorVtxsSize / ColorShader::cuColorAttrSize;
+
+    colorVtxs = (uint8_t *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, colorCount * ColorShader::cuColorAttrSize);
+    if (colorVtxs) {
+        for (uint32_t i = 0; i < colorCount; i++) {
+            setImageColor(c, i);
+        }
+    }
+}
+
+GuiImage::GuiImage(int32_t w, int32_t h, const GX2Color *c, uint32_t color_count, int32_t type) {
+    internalInit(w, h);
+    imgType    = type;
+    colorCount = ColorShader::cuColorVtxsSize / ColorShader::cuColorAttrSize;
+    if (colorCount < color_count) {
+        colorCount = color_count;
+    }
+
+    colorVtxs = (uint8_t *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, colorCount * ColorShader::cuColorAttrSize);
+    if (colorVtxs) {
+        for (uint32_t i = 0; i < colorCount; i++) {
+            // take the last as reference if not enough colors defined
+            int32_t idx = (i < color_count) ? i : (color_count - 1);
+            setImageColor(c[idx], i);
+        }
+    }
+}
+
+/**
+ * Destructor for the GuiImage class.
+ */
+GuiImage::~GuiImage() {
+    if (colorVtxs) {
+        free(colorVtxs);
+        colorVtxs = NULL;
+    }
+}
+
+void GuiImage::internalInit(int32_t w, int32_t h) {
+    imageData      = NULL;
+    width          = w;
+    height         = h;
+    tileHorizontal = -1;
+    tileVertical   = -1;
+    imgType        = IMAGE_TEXTURE;
+    colorVtxsDirty = false;
+    colorVtxs      = NULL;
+    colorCount     = 0;
+    posVtxs        = NULL;
+    texCoords      = NULL;
+    vtxCount       = 4;
+    primitive      = GX2_PRIMITIVE_MODE_QUADS;
+
+    imageAngle      = 0.0f;
+    blurDirection   = glm::vec3(0.0f);
+    positionOffsets = glm::vec3(0.0f);
+    scaleFactor     = glm::vec3(1.0f);
+    colorIntensity  = glm::vec4(1.0f);
+}
+
+void GuiImage::setImageData(GuiImageData *img) {
+    imageData = img;
+    width     = 0;
+    height    = 0;
+    if (img && img->getTexture()) {
+        width  = img->getWidth();
+        height = img->getHeight();
+    }
+    imgType = IMAGE_TEXTURE;
+}
+
+GX2Color GuiImage::getPixel(int32_t x, int32_t y) {
+    if (!imageData || this->getWidth() <= 0 || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight()) {
+        return (GX2Color){
+                0, 0, 0, 0};
+    }
+
+    uint32_t pitch     = imageData->getTexture()->surface.pitch;
+    uint32_t *imagePtr = (uint32_t *) imageData->getTexture()->surface.image;
+
+    uint32_t color_u32 = imagePtr[y * pitch + x];
+    GX2Color color;
+    color.r = (color_u32 >> 24) & 0xFF;
+    color.g = (color_u32 >> 16) & 0xFF;
+    color.b = (color_u32 >> 8) & 0xFF;
+    color.a = (color_u32 >> 0) & 0xFF;
+    return color;
+}
+
+void GuiImage::setPixel(int32_t x, int32_t y, const GX2Color &color) {
+    if (!imageData || this->getWidth() <= 0 || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight()) {
+        return;
+    }
+
+
+    uint32_t pitch          = imageData->getTexture()->surface.pitch;
+    uint32_t *imagePtr      = (uint32_t *) imageData->getTexture()->surface.image;
+    imagePtr[y * pitch + x] = (color.r << 24) | (color.g << 16) | (color.b << 8) | (color.a << 0);
+}
+
+void GuiImage::setImageColor(const GX2Color &c, int32_t idx) {
+    if (!colorVtxs) {
+        return;
+    }
+
+    if (idx >= 0 && idx < (int32_t) colorCount) {
+        colorVtxs[(idx << 2) + 0] = c.r;
+        colorVtxs[(idx << 2) + 1] = c.g;
+        colorVtxs[(idx << 2) + 2] = c.b;
+        colorVtxs[(idx << 2) + 3] = c.a;
+        colorVtxsDirty            = true;
+    } else if (colorVtxs) {
+        for (uint32_t i = 0; i < (ColorShader::cuColorVtxsSize / sizeof(uint8_t)); i += 4) {
+            colorVtxs[i + 0] = c.r;
+            colorVtxs[i + 1] = c.g;
+            colorVtxs[i + 2] = c.b;
+            colorVtxs[i + 3] = c.a;
+        }
+        colorVtxsDirty = true;
+    }
+}
+
+void GuiImage::setSize(int32_t w, int32_t h) {
+    width  = w;
+    height = h;
+}
+
+void GuiImage::setPrimitiveVertex(int32_t prim, const float *posVtx, const float *texCoord, uint32_t vtxcount) {
+    primitive = prim;
+    vtxCount  = vtxcount;
+    posVtxs   = posVtx;
+    texCoords = texCoord;
+
+    if (imgType == IMAGE_COLOR) {
+        uint8_t *newColorVtxs = (uint8_t *) memalign(0x40, ColorShader::cuColorAttrSize * vtxCount);
+
+        for (uint32_t i = 0; i < vtxCount; i++) {
+            int32_t newColorIdx = (i << 2);
+            int32_t colorIdx    = (i < colorCount) ? (newColorIdx) : ((colorCount - 1) << 2);
+
+            newColorVtxs[newColorIdx + 0] = colorVtxs[colorIdx + 0];
+            newColorVtxs[newColorIdx + 1] = colorVtxs[colorIdx + 1];
+            newColorVtxs[newColorIdx + 2] = colorVtxs[colorIdx + 2];
+            newColorVtxs[newColorIdx + 3] = colorVtxs[colorIdx + 3];
+        }
+
+        free(colorVtxs);
+        colorVtxs      = newColorVtxs;
+        colorCount     = vtxCount;
+        colorVtxsDirty = true;
+    }
+}
+
+void GuiImage::draw(CVideo *pVideo) {
+    if (!this->isVisible() || tileVertical == 0 || tileHorizontal == 0) {
+        return;
+    }
+
+    float currScaleX = getScaleX();
+    float currScaleY = getScaleY();
+
+    positionOffsets[0] = getCenterX() * pVideo->getWidthScaleFactor() * 2.0f;
+    positionOffsets[1] = getCenterY() * pVideo->getHeightScaleFactor() * 2.0f;
+    positionOffsets[2] = getDepth() * pVideo->getDepthScaleFactor() * 2.0f;
+
+    scaleFactor[0] = currScaleX * getWidth() * pVideo->getWidthScaleFactor();
+    scaleFactor[1] = currScaleY * getHeight() * pVideo->getHeightScaleFactor();
+    scaleFactor[2] = getScaleZ();
+
+    //! add other colors intensities parameters
+    colorIntensity[3] = getAlpha();
+
+    //! angle of the object
+    imageAngle = DegToRad(getAngle());
+
+    //	if(image && tileHorizontal > 0 && tileVertical > 0)
+    //	{
+    //		for(int32_t n=0; n<tileVertical; n++)
+    //			for(int32_t i=0; i<tileHorizontal; i++)
+    //			{
+    //				if(bUnCut)
+    //					Menu_DrawImg(image, width, height, format, currLeft+width*i, currTop+width*n, currZ, imageangle, currScaleX, currScaleY, currAlpha);
+    //				else
+    //					Menu_DrawImgCut(image, width, height, format, currLeft+width*i, currTop+width*n, currZ, imageangle, currScaleX, currScaleY, currAlpha, cutBoundsRect.x1(), cutBoundsRect.x2(), cutBoundsRect.y1(), cutBoundsRect.y2());
+    //			}
+    //	}
+    //	else if(image && tileHorizontal > 0)
+    //	{
+    //		for(int32_t i=0; i<tileHorizontal; i++)
+    //		{
+    //			int32_t widthTile = (imageangle == 90 || imageangle == 270) ? height : width;
+    //			if(bUnCut)
+    //				Menu_DrawImg(image, width, height, format, currLeft+widthTile*i, currTop, currZ, imageangle, currScaleX, currScaleY, currAlpha);
+    //			else
+    //				Menu_DrawImgCut(image, width, height, format, currLeft+widthTile*i, currTop, currZ, imageangle, currScaleX, currScaleY, currAlpha, cutBoundsRect.x1(), cutBoundsRect.x2(), cutBoundsRect.y1(), cutBoundsRect.y2());
+    //		}
+    //	}
+    //	else if(image && tileVertical > 0)
+    //	{
+    //		for(int32_t i=0; i<tileVertical; i++)
+    //		{
+    //			if(bUnCut)
+    //				Menu_DrawImg(image, width, height, format, currLeft, currTop+height*i, currZ, imageangle, currScaleX, currScaleY, currAlpha);
+    //			else
+    //				Menu_DrawImgCut(image, width, height, format, currLeft, currTop+height*i, currZ, imageangle, currScaleX, currScaleY, currAlpha, cutBoundsRect.x1(), cutBoundsRect.x2(), cutBoundsRect.y1(), cutBoundsRect.y2());
+    //		}
+    //	}
+    if (colorVtxsDirty && colorVtxs) {
+        //! flush color vertex only on main GX2 thread
+        GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, colorVtxs, colorCount * ColorShader::cuColorAttrSize);
+        colorVtxsDirty = false;
+    }
+
+    if (imgType == IMAGE_COLOR && colorVtxs) {
+        ColorShader::instance()->setShaders();
+        ColorShader::instance()->setAttributeBuffer(colorVtxs, posVtxs, vtxCount);
+        ColorShader::instance()->setAngle(imageAngle);
+        ColorShader::instance()->setOffset(positionOffsets);
+        ColorShader::instance()->setScale(scaleFactor);
+        ColorShader::instance()->setColorIntensity(colorIntensity);
+        ColorShader::instance()->draw(primitive, vtxCount);
+    } else if (imageData) {
+        Texture2DShader::instance()->setShaders();
+        Texture2DShader::instance()->setAttributeBuffer(texCoords, posVtxs, vtxCount);
+        Texture2DShader::instance()->setAngle(imageAngle);
+        Texture2DShader::instance()->setOffset(positionOffsets);
+        Texture2DShader::instance()->setScale(scaleFactor);
+        Texture2DShader::instance()->setColorIntensity(colorIntensity);
+        Texture2DShader::instance()->setBlurring(blurDirection);
+        Texture2DShader::instance()->setTextureAndSampler(imageData->getTexture(), imageData->getSampler());
+        Texture2DShader::instance()->draw(primitive, vtxCount);
+    }
+}

src/gui/GuiImage.h

@@ -0,0 +1,127 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef GUI_IMAGE_H_
+#define GUI_IMAGE_H_
+
+#include <gui/GuiElement.h>
+#include <gui/GuiImageData.h>
+#include <gui/gx2_ext.h>
+#include <video/shaders/Shader.h>
+
+//!Display, manage, and manipulate images in the GUI
+class GuiImage : public GuiElement {
+public:
+    enum ImageTypes {
+        IMAGE_TEXTURE,
+        IMAGE_COLOR
+    };
+
+    //!\overload
+    //!\param img Pointer to GuiImageData element
+    explicit GuiImage(GuiImageData *img);
+
+    //!\overload
+    //!Creates an image filled with the specified color
+    //!\param w Image width
+    //!\param h Image height
+    //!\param c Array with 4 x image color (BL, BR, TL, TR)
+    GuiImage(int32_t w, int32_t h, const GX2Color &c, int32_t imgType = IMAGE_COLOR);
+
+    GuiImage(int32_t w, int32_t h, const GX2Color *c, uint32_t colorCount = 1, int32_t imgType = IMAGE_COLOR);
+
+    //!Destructor
+    ~GuiImage() override;
+
+    //!Sets the number of times to draw the image horizontally
+    //!\param t Number of times to draw the image
+    void setTileHorizontal(int32_t t) {
+        tileHorizontal = t;
+    }
+
+    //!Sets the number of times to draw the image vertically
+    //!\param t Number of times to draw the image
+    void setTileVertical(int32_t t) {
+        tileVertical = t;
+    }
+
+    //!Constantly called to draw the image
+    void draw(CVideo *pVideo) override;
+
+    //!Gets the image data
+    //!\return pointer to image data
+    [[nodiscard]] GuiImageData *getImageData() const {
+        return imageData;
+    }
+
+    //!Sets up a new image using the GuiImageData object specified
+    //!\param img Pointer to GuiImageData object
+    void setImageData(GuiImageData *img);
+
+    //!Gets the pixel color at the specified coordinates of the image
+    //!\param x X coordinate
+    //!\param y Y coordinate
+    GX2Color getPixel(int32_t x, int32_t y);
+
+    //!Sets the pixel color at the specified coordinates of the image
+    //!\param x X coordinate
+    //!\param y Y coordinate
+    //!\param color Pixel color
+    void setPixel(int32_t x, int32_t y, const GX2Color &color);
+
+    //!Change ImageColor
+    void setImageColor(const GX2Color &c, int32_t idx = -1);
+
+    //!Change ImageColor
+    void setSize(int32_t w, int32_t h);
+
+    void setPrimitiveVertex(int32_t prim, const float *pos, const float *tex, uint32_t count);
+
+    void setBlurDirection(uint8_t dir, float value) {
+        if (dir < 2) {
+            blurDirection[dir] = value;
+        }
+    }
+
+    void setColorIntensity(const glm::vec4 &col) {
+        colorIntensity = col;
+    }
+
+protected:
+    void internalInit(int32_t w, int32_t h);
+
+    int32_t imgType;         //!< Type of image data (IMAGE_TEXTURE, IMAGE_COLOR, IMAGE_DATA)
+    GuiImageData *imageData; //!< Poiner to image data. May be shared with GuiImageData data
+    int32_t tileHorizontal;  //!< Number of times to draw (tile) the image horizontally
+    int32_t tileVertical;    //!< Number of times to draw (tile) the image vertically
+
+    //! Internally used variables for rendering
+    uint8_t *colorVtxs;
+    uint32_t colorCount;
+    bool colorVtxsDirty;
+    glm::vec3 positionOffsets;
+    glm::vec3 scaleFactor;
+    glm::vec4 colorIntensity;
+    float imageAngle;
+    glm::vec3 blurDirection;
+
+    const float *posVtxs;
+    const float *texCoords;
+    uint32_t vtxCount;
+    int32_t primitive;
+};
+
+#endif

src/gui/GuiImageAsync.cpp

@@ -0,0 +1,173 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include "../fs/CFile.hpp"
+#include <gui/GuiImageAsync.h>
+#include <unistd.h>
+
+std::vector<GuiImageAsync *> GuiImageAsync::imageQueue;
+CThread *GuiImageAsync::pThread             = NULL;
+std::recursive_mutex *GuiImageAsync::pMutex = NULL;
+uint32_t GuiImageAsync::threadRefCounter    = 0;
+bool GuiImageAsync::bExitRequested          = false;
+GuiImageAsync *GuiImageAsync::pInUse        = NULL;
+
+GuiImageAsync::GuiImageAsync(const uint8_t *imageBuffer, const uint32_t &imageBufferSize, GuiImageData *preloadImg)
+    : GuiImage(preloadImg), imgData(NULL), imgBuffer(imageBuffer), imgBufferSize(imageBufferSize) {
+    threadInit();
+    threadAddImage(this);
+}
+
+GuiImageAsync::GuiImageAsync(const std::string &file, GuiImageData *preloadImg)
+    : GuiImage(preloadImg), imgData(NULL), filename(file), imgBuffer(NULL), imgBufferSize(0) {
+    threadInit();
+    threadAddImage(this);
+}
+
+GuiImageAsync::~GuiImageAsync() {
+    threadRemoveImage(this);
+    while (pInUse == this)
+        OSSleepTicks(OSMicrosecondsToTicks(1000));
+
+    if (imgData) {
+        delete imgData;
+    }
+
+    //threadExit();
+}
+
+void GuiImageAsync::threadAddImage(GuiImageAsync *Image) {
+    pMutex->lock();
+    imageQueue.push_back(Image);
+    pMutex->unlock();
+    pThread->resumeThread();
+}
+
+void GuiImageAsync::threadRemoveImage(GuiImageAsync *image) {
+    pMutex->lock();
+    for (uint32_t i = 0; i < imageQueue.size(); ++i) {
+        if (imageQueue[i] == image) {
+            imageQueue.erase(imageQueue.begin() + i);
+            break;
+        }
+    }
+    pMutex->unlock();
+}
+
+void GuiImageAsync::clearQueue() {
+    pMutex->lock();
+    imageQueue.clear();
+    pMutex->unlock();
+}
+
+void GuiImageAsync::guiImageAsyncThread(CThread *thread, void *arg) {
+    while (!bExitRequested) {
+        if (imageQueue.empty() && !bExitRequested) {
+            pThread->suspendThread();
+        }
+
+        if (!imageQueue.empty() && !bExitRequested) {
+            pMutex->lock();
+            pInUse = imageQueue.front();
+            imageQueue.erase(imageQueue.begin());
+            pMutex->unlock();
+
+            if (!pInUse) {
+                continue;
+            }
+
+
+            if (pInUse->imgBuffer && pInUse->imgBufferSize) {
+                pInUse->imgData = new GuiImageData(pInUse->imgBuffer, pInUse->imgBufferSize);
+            } else {
+                uint8_t *buffer     = NULL;
+                uint64_t bufferSize = 0;
+
+                CFile file(pInUse->filename, CFile::ReadOnly);
+                if (file.isOpen()) {
+                    uint64_t filesize = file.size();
+                    buffer            = (uint8_t *) malloc(filesize);
+                    if (buffer != NULL) {
+                        uint32_t blocksize = 0x4000;
+                        uint32_t done      = 0;
+                        int32_t readBytes  = 0;
+                        while (done < filesize) {
+                            if (done + blocksize > filesize) {
+                                blocksize = filesize - done;
+                            }
+                            readBytes = file.read(buffer + done, blocksize);
+                            if (readBytes <= 0) {
+                                break;
+                            }
+                            done += readBytes;
+                        }
+                        if (done == filesize) {
+                            bufferSize = filesize;
+                        } else {
+                            free(buffer);
+                        }
+                    }
+                    file.close();
+                }
+
+                if (buffer != NULL && bufferSize > 0) {
+                    pInUse->imgData = new GuiImageData(buffer, bufferSize, GX2_TEX_CLAMP_MODE_MIRROR);
+
+                    //! free original image buffer which is converted to texture now and not needed anymore
+                    free(buffer);
+                }
+            }
+
+            if (pInUse->imgData) {
+                if (pInUse->imgData->getTexture()) {
+                    pInUse->width     = pInUse->imgData->getWidth();
+                    pInUse->height    = pInUse->imgData->getHeight();
+                    pInUse->imageData = pInUse->imgData;
+                } else {
+                    delete pInUse->imgData;
+                    pInUse->imgData = NULL;
+                }
+            }
+            pInUse->imageLoaded(pInUse);
+            pInUse = NULL;
+        }
+    }
+}
+
+void GuiImageAsync::threadInit() {
+    if (pThread == NULL) {
+        bExitRequested = false;
+        pMutex         = new std::recursive_mutex();
+        pThread        = CThread::create(GuiImageAsync::guiImageAsyncThread, NULL, CThread::eAttributeAffCore1 | CThread::eAttributePinnedAff, 10);
+        pThread->resumeThread();
+    }
+
+    ++threadRefCounter;
+}
+
+void GuiImageAsync::threadExit() {
+    if (threadRefCounter) {
+        --threadRefCounter;
+    }
+
+    if (/*(threadRefCounter == 0) &&*/ (pThread != NULL)) {
+        bExitRequested = true;
+        delete pThread;
+        delete pMutex;
+        pThread = NULL;
+        pMutex  = NULL;
+    }
+}

src/gui/GuiImageAsync.h

@@ -0,0 +1,66 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef _GUIIMAGEASYNC_H_
+#define _GUIIMAGEASYNC_H_
+
+#include <gui/GuiImage.h>
+#include <system/CThread.h>
+#include <mutex>
+#include <vector>
+
+class GuiImageAsync : public GuiImage {
+public:
+    GuiImageAsync(const uint8_t *imageBuffer, const uint32_t &imageBufferSize, GuiImageData *preloadImg);
+
+    GuiImageAsync(const std::string &filename, GuiImageData *preloadImg);
+
+    virtual ~GuiImageAsync();
+
+    static void clearQueue();
+
+    static void removeFromQueue(GuiImageAsync *image) {
+        threadRemoveImage(image);
+    }
+
+    //! don't forget to LOCK GUI if using this asynchron call
+    sigslot::signal1<GuiImageAsync *> imageLoaded;
+
+    static void threadExit();
+
+private:
+    static void threadInit();
+
+    GuiImageData *imgData;
+    std::string filename;
+    const uint8_t *imgBuffer;
+    const uint32_t imgBufferSize;
+
+    static void guiImageAsyncThread(CThread *thread, void *arg);
+
+    static void threadAddImage(GuiImageAsync *Image);
+
+    static void threadRemoveImage(GuiImageAsync *Image);
+
+    static std::vector<GuiImageAsync *> imageQueue;
+    static CThread *pThread;
+    static std::recursive_mutex *pMutex;
+    static uint32_t threadRefCounter;
+    static GuiImageAsync *pInUse;
+    static bool bExitRequested;
+};
+
+#endif /*_GUIIMAGEASYNC_H_*/

src/gui/GuiImageData.cpp

@@ -0,0 +1,191 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <gui/GuiImageData.h>
+#include "system/memory.h"
+#include <malloc.h>
+#include <stdint.h>
+#include <string.h>
+
+/**
+ * Constructor for the GuiImageData class.
+ */
+GuiImageData::GuiImageData() {
+    texture    = NULL;
+    sampler    = NULL;
+    memoryType = eMemTypeMEM2;
+}
+
+/**
+ * Constructor for the GuiImageData class.
+ */
+GuiImageData::GuiImageData(const uint8_t *img, int32_t imgSize, GX2TexClampMode textureClamp, GX2SurfaceFormat textureFormat) {
+    texture = NULL;
+    sampler = NULL;
+    loadImage(img, imgSize, textureClamp, textureFormat);
+}
+
+/**
+ * Destructor for the GuiImageData class.
+ */
+GuiImageData::~GuiImageData() {
+    releaseData();
+}
+
+void GuiImageData::releaseData(void) {
+    if (texture) {
+        if (texture->surface.image) {
+            switch (memoryType) {
+                default:
+                case eMemTypeMEM2:
+                    free(texture->surface.image);
+                    break;
+                case eMemTypeMEM1:
+                    MEM1_free(texture->surface.image);
+                    break;
+                case eMemTypeMEMBucket:
+                    MEMBucket_free(texture->surface.image);
+                    break;
+            }
+        }
+        delete texture;
+        texture = NULL;
+    }
+    if (sampler) {
+        delete sampler;
+        sampler = NULL;
+    }
+}
+
+void GuiImageData::loadImage(const uint8_t *img, int32_t imgSize, GX2TexClampMode textureClamp, GX2SurfaceFormat textureFormat) {
+    if (!img || (imgSize < 8)) {
+        return;
+    }
+
+    releaseData();
+    gdImagePtr gdImg = 0;
+
+    if (img[0] == 0xFF && img[1] == 0xD8) {
+        //! not needed for now therefore comment out to safe ELF size
+        //! if needed uncomment, adds 200 kb to the ELF size
+        // IMAGE_JPEG
+        gdImg = gdImageCreateFromJpegPtr(imgSize, (uint8_t *) img);
+    } else if (img[0] == 'B' && img[1] == 'M') {
+        // IMAGE_BMP
+        gdImg = gdImageCreateFromBmpPtr(imgSize, (uint8_t *) img);
+    } else if (img[0] == 0x89 && img[1] == 'P' && img[2] == 'N' && img[3] == 'G') {
+        // IMAGE_PNG
+        gdImg = gdImageCreateFromPngPtr(imgSize, (uint8_t *) img);
+    }
+    //!This must be last since it can also intefere with outher formats
+    else if (img[0] == 0x00) {
+        // Try loading TGA image
+        gdImg = gdImageCreateFromTgaPtr(imgSize, (uint8_t *) img);
+    }
+
+    if (gdImg == 0) {
+        return;
+    }
+
+    uint32_t width  = (gdImageSX(gdImg));
+    uint32_t height = (gdImageSY(gdImg));
+
+    //! Initialize texture
+    texture = new GX2Texture;
+    GX2InitTexture(texture, width, height, 1, 0, textureFormat, GX2_SURFACE_DIM_TEXTURE_2D, GX2_TILE_MODE_LINEAR_ALIGNED);
+
+    //! if this fails something went horribly wrong
+    if (texture->surface.imageSize == 0) {
+        delete texture;
+        texture = NULL;
+        gdImageDestroy(gdImg);
+        return;
+    }
+
+    //! allocate memory for the surface
+    memoryType             = eMemTypeMEM2;
+    texture->surface.image = memalign(texture->surface.alignment, texture->surface.imageSize);
+    //! try MEM1 on failure
+    if (!texture->surface.image) {
+        memoryType             = eMemTypeMEM1;
+        texture->surface.image = MEM1_alloc(texture->surface.imageSize, texture->surface.alignment);
+    }
+    //! try MEM bucket on failure
+    if (!texture->surface.image) {
+        memoryType             = eMemTypeMEMBucket;
+        texture->surface.image = MEMBucket_alloc(texture->surface.imageSize, texture->surface.alignment);
+    }
+    //! check if memory is available for image
+    if (!texture->surface.image) {
+        gdImageDestroy(gdImg);
+        delete texture;
+        texture = NULL;
+        return;
+    }
+    //! set mip map data pointer
+    texture->surface.mipmaps = NULL;
+    //! convert image to texture
+    switch (textureFormat) {
+        default:
+        case GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8:
+            gdImageToUnormR8G8B8A8(gdImg, (uint32_t *) texture->surface.image, texture->surface.width, texture->surface.height, texture->surface.pitch);
+            break;
+        case GX2_SURFACE_FORMAT_UNORM_R5_G6_B5:
+            gdImageToUnormR5G6B5(gdImg, (uint16_t *) texture->surface.image, texture->surface.width, texture->surface.height, texture->surface.pitch);
+            break;
+    }
+
+    //! free memory of image as its not needed anymore
+    gdImageDestroy(gdImg);
+
+    //! invalidate the memory
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU_TEXTURE, texture->surface.image, texture->surface.imageSize);
+    //! initialize the sampler
+    sampler = new GX2Sampler;
+    GX2InitSampler(sampler, textureClamp, GX2_TEX_XY_FILTER_MODE_LINEAR);
+}
+
+void GuiImageData::gdImageToUnormR8G8B8A8(gdImagePtr gdImg, uint32_t *imgBuffer, uint32_t width, uint32_t height, uint32_t pitch) {
+    for (uint32_t y = 0; y < height; ++y) {
+        for (uint32_t x = 0; x < width; ++x) {
+            uint32_t pixel = gdImageGetPixel(gdImg, x, y);
+
+            uint8_t a = 254 - 2 * ((uint8_t) gdImageAlpha(gdImg, pixel));
+            if (a == 254) { a++; }
+
+            uint8_t r = gdImageRed(gdImg, pixel);
+            uint8_t g = gdImageGreen(gdImg, pixel);
+            uint8_t b = gdImageBlue(gdImg, pixel);
+
+            imgBuffer[y * pitch + x] = (r << 24) | (g << 16) | (b << 8) | (a);
+        }
+    }
+}
+
+//! TODO: figure out why this seems to not work correct yet
+void GuiImageData::gdImageToUnormR5G6B5(gdImagePtr gdImg, uint16_t *imgBuffer, uint32_t width, uint32_t height, uint32_t pitch) {
+    for (uint32_t y = 0; y < height; ++y) {
+        for (uint32_t x = 0; x < width; ++x) {
+            uint32_t pixel = gdImageGetPixel(gdImg, x, y);
+
+            uint8_t r = gdImageRed(gdImg, pixel);
+            uint8_t g = gdImageGreen(gdImg, pixel);
+            uint8_t b = gdImageBlue(gdImg, pixel);
+
+            imgBuffer[y * pitch + x] = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);
+        }
+    }
+}

src/gui/GuiImageData.h

@@ -0,0 +1,91 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef GUI_IMAGEDATA_H_
+#define GUI_IMAGEDATA_H_
+
+#include <gd.h>
+#include <gui/GuiElement.h>
+#include <gui/gx2_ext.h>
+#include <gx2/texture.h>
+
+class GuiImageData : public GuiElement {
+public:
+    //!Constructor
+    GuiImageData();
+
+    //!\param img Image data
+    //!\param imgSize The image size
+    GuiImageData(const uint8_t *img, int32_t imgSize, GX2TexClampMode textureClamp = GX2_TEX_CLAMP_MODE_CLAMP, GX2SurfaceFormat textureFormat = GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8);
+
+    //!Destructor
+    virtual ~GuiImageData();
+
+    //!Load image from buffer
+    //!\param img Image data
+    //!\param imgSize The image size
+    void loadImage(const uint8_t *img, int32_t imgSize, GX2TexClampMode textureClamp = GX2_TEX_CLAMP_MODE_CLAMP, GX2SurfaceFormat textureFormat = GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8);
+
+    //! getter functions
+    virtual const GX2Texture *getTexture() const {
+        return texture;
+    };
+
+    virtual const GX2Sampler *getSampler() const {
+        return sampler;
+    };
+
+    //!Gets the image width
+    //!\return image width
+    float getWidth() override {
+        if (texture) {
+            return texture->surface.width;
+        } else {
+            return 0;
+        }
+    };
+
+    //!Gets the image height
+    //!\return image height
+    float getHeight() override {
+        if (texture) {
+            return texture->surface.height;
+        } else {
+            return 0;
+        }
+    };
+
+    //! release memory of the image data
+    void releaseData();
+
+private:
+    void gdImageToUnormR8G8B8A8(gdImagePtr gdImg, uint32_t *imgBuffer, uint32_t width, uint32_t height, uint32_t pitch);
+
+    void gdImageToUnormR5G6B5(gdImagePtr gdImg, uint16_t *imgBuffer, uint32_t width, uint32_t height, uint32_t pitch);
+
+    GX2Texture *texture;
+    GX2Sampler *sampler;
+
+    enum eMemoryTypes {
+        eMemTypeMEM2,
+        eMemTypeMEM1,
+        eMemTypeMEMBucket
+    };
+
+    uint8_t memoryType;
+};
+
+#endif

src/gui/GuiParticleImage.cpp

@@ -0,0 +1,124 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include "utils/utils.h"
+#include <gui/GuiParticleImage.h>
+#include <video/CVideo.h>
+#include <video/shaders/ColorShader.h>
+
+#define CIRCLE_VERTEX_COUNT 36
+
+static inline float getRandZeroToOneF32() {
+    return (rand() % 10000) * 0.0001f;
+}
+
+static inline float getRandMinusOneToOneF32() {
+    return getRandZeroToOneF32() * 2.0f - 1.0f;
+}
+
+GuiParticleImage::GuiParticleImage(int32_t w, int32_t h, uint32_t particleCount, float minRadius, float maxRadius, float minSpeed, float maxSpeed)
+    : GuiImage(NULL) {
+    width           = w;
+    height          = h;
+    imgType         = IMAGE_COLOR;
+    this->minRadius = minRadius;
+    this->maxRadius = maxRadius;
+    this->minSpeed  = minSpeed;
+    this->maxSpeed  = maxSpeed;
+
+    posVertexs   = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ColorShader::cuVertexAttrSize * CIRCLE_VERTEX_COUNT);
+    colorVertexs = (uint8_t *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ColorShader::cuColorAttrSize * CIRCLE_VERTEX_COUNT);
+
+    for (uint32_t i = 0; i < CIRCLE_VERTEX_COUNT; i++) {
+        posVertexs[i * 3 + 0] = cosf(DegToRad(i * 360.0f / CIRCLE_VERTEX_COUNT));
+        posVertexs[i * 3 + 1] = sinf(DegToRad(i * 360.0f / CIRCLE_VERTEX_COUNT));
+        posVertexs[i * 3 + 2] = 0.0f;
+
+        colorVertexs[i * 4 + 0] = 0xff;
+        colorVertexs[i * 4 + 1] = 0xff;
+        colorVertexs[i * 4 + 2] = 0xff;
+        colorVertexs[i * 4 + 3] = 0xff;
+    }
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, posVertexs, ColorShader::cuVertexAttrSize * CIRCLE_VERTEX_COUNT);
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, colorVertexs, ColorShader::cuColorAttrSize * CIRCLE_VERTEX_COUNT);
+
+    particles.resize(particleCount);
+
+    for (uint32_t i = 0; i < particleCount; i++) {
+        particles[i].position.x = getRandMinusOneToOneF32() * getWidth() * 0.5f;
+        particles[i].position.y = getRandMinusOneToOneF32() * getHeight() * 0.5f;
+        particles[i].position.z = 0.0f;
+        particles[i].colors     = glm::vec4(1.0f, 1.0f, 1.0f, (getRandZeroToOneF32() * 0.6f) + 0.05f);
+        particles[i].radius     = getRandZeroToOneF32() * (maxRadius - minRadius) + minRadius;
+        particles[i].speed      = (getRandZeroToOneF32() * (maxSpeed - minSpeed)) + minSpeed;
+        particles[i].direction  = getRandMinusOneToOneF32();
+    }
+}
+
+GuiParticleImage::~GuiParticleImage() {
+    free(posVertexs);
+    free(colorVertexs);
+}
+
+void GuiParticleImage::draw(CVideo *pVideo) {
+    if (!this->isVisible()) {
+        return;
+    }
+
+
+    float currScaleX = getScaleX();
+    float currScaleY = getScaleY();
+
+    positionOffsets[2] = getDepth() * pVideo->getDepthScaleFactor() * 2.0f;
+
+    scaleFactor[2] = getScaleZ();
+
+    //! add other colors intensities parameters
+    colorIntensity[3] = getAlpha();
+
+    for (uint32_t i = 0; i < particles.size(); ++i) {
+        if (particles[i].position.y > (getHeight() * 0.5f + 30.0f)) {
+            particles[i].position.x = getRandMinusOneToOneF32() * getWidth() * 0.5f;
+            particles[i].position.y = -getHeight() * 0.5f - 30.0f;
+            particles[i].colors     = glm::vec4(1.0f, 1.0f, 1.0f, (getRandZeroToOneF32() * 0.6f) + 0.05f);
+            particles[i].radius     = getRandZeroToOneF32() * (maxRadius - minRadius) + minRadius;
+            particles[i].speed      = (getRandZeroToOneF32() * (maxSpeed - minSpeed)) + minSpeed;
+            particles[i].direction  = getRandMinusOneToOneF32();
+        }
+        if (particles[i].position.x < (-getWidth() * 0.5f - 50.0f)) {
+            particles[i].position.x = -particles[i].position.x;
+        }
+
+
+        particles[i].direction += getRandMinusOneToOneF32() * 0.03f;
+        particles[i].position.x += particles[i].speed * particles[i].direction;
+        particles[i].position.y += particles[i].speed;
+
+        positionOffsets[0] = (getCenterX() + particles[i].position.x) * pVideo->getWidthScaleFactor() * 2.0f;
+        positionOffsets[1] = (getCenterY() + particles[i].position.y) * pVideo->getHeightScaleFactor() * 2.0f;
+
+        scaleFactor[0] = currScaleX * particles[i].radius * pVideo->getWidthScaleFactor();
+        scaleFactor[1] = currScaleY * particles[i].radius * pVideo->getHeightScaleFactor();
+
+        ColorShader::instance()->setShaders();
+        ColorShader::instance()->setAttributeBuffer(colorVertexs, posVertexs, CIRCLE_VERTEX_COUNT);
+        ColorShader::instance()->setAngle(0.0f);
+        ColorShader::instance()->setOffset(positionOffsets);
+        ColorShader::instance()->setScale(scaleFactor);
+        ColorShader::instance()->setColorIntensity(colorIntensity * particles[i].colors);
+        ColorShader::instance()->draw(GX2_PRIMITIVE_MODE_TRIANGLE_FAN, CIRCLE_VERTEX_COUNT);
+    }
+}

src/gui/GuiParticleImage.h

@@ -0,0 +1,50 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef _GUI_PARTICLE_IMAGE_H_
+#define _GUI_PARTICLE_IMAGE_H_
+
+#include <gui/GuiImage.h>
+
+class GuiParticleImage : public GuiImage, public sigslot::has_slots<> {
+public:
+    GuiParticleImage(int32_t w, int32_t h, uint32_t particleCount, float minRadius, float maxRadius, float minSpeed, float maxSpeed);
+
+    virtual ~GuiParticleImage();
+
+    void draw(CVideo *pVideo) override;
+
+private:
+    float *posVertexs;
+    uint8_t *colorVertexs;
+
+    float minRadius;
+    float maxRadius;
+    float minSpeed;
+    float maxSpeed;
+
+    typedef struct {
+        glm::vec3 position;
+        glm::vec4 colors;
+        float radius;
+        float speed;
+        float direction;
+    } Particle;
+
+    std::vector<Particle> particles;
+};
+
+#endif // _GUI_ICON_GRID_H_

src/gui/GuiScrollbar.cpp

@@ -0,0 +1,221 @@
+/***************************************************************************
+ * Copyright (C) 2011
+ * by Dimok
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any
+ * damages arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any
+ * purpose, including commercial applications, and to alter it and
+ * redistribute it freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you
+ * must not claim that you wrote the original software. If you use
+ * this software in a product, an acknowledgment in the product
+ * documentation would be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and
+ * must not be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+ ***************************************************************************/
+#include "utils/utils.h"
+#include <gui/GuiScrollbar.h>
+
+GuiScrollbar::GuiScrollbar(int32_t h)
+    : touchTrigger(GuiTrigger::CHANNEL_1, GuiTrigger::VPAD_TOUCH), wpadTouchTrigger(GuiTrigger::CHANNEL_2 | GuiTrigger::CHANNEL_3 | GuiTrigger::CHANNEL_4 | GuiTrigger::CHANNEL_5, GuiTrigger::BUTTON_A) {
+    SelItem     = 0;
+    SelInd      = 0;
+    PageSize    = 0;
+    EntrieCount = 0;
+    SetScrollSpeed(15);
+    ScrollState = 0;
+
+    listChanged.connect(this, &GuiScrollbar::setScrollboxPosition);
+
+    height = h;
+
+    arrowUpBtn = new GuiButton(50, 50);
+    arrowUpBtn->setParent(this);
+    arrowUpBtn->setAlignment(ALIGN_CENTER | ALIGN_TOP);
+    arrowUpBtn->setPosition(0, 0);
+    arrowUpBtn->setTrigger(&touchTrigger, 0);
+    arrowUpBtn->setTrigger(&wpadTouchTrigger, 1);
+    arrowUpBtn->setEffectGrow();
+    arrowUpBtn->clicked.connect(this, &GuiScrollbar::OnUpButtonClick);
+
+    arrowDownBtn = new GuiButton(50, 50);
+    arrowDownBtn->setParent(this);
+    arrowDownBtn->setAlignment(ALIGN_CENTER | ALIGN_BOTTOM);
+    arrowDownBtn->setPosition(0, 0);
+    arrowDownBtn->setTrigger(&touchTrigger, 0);
+    arrowDownBtn->setTrigger(&wpadTouchTrigger, 1);
+    arrowDownBtn->setEffectGrow();
+    arrowDownBtn->clicked.connect(this, &GuiScrollbar::OnDownButtonClick);
+
+    scrollbarBoxBtn = new GuiButton(50, height);
+    scrollbarBoxBtn->setParent(this);
+    scrollbarBoxBtn->setAlignment(ALIGN_CENTER | ALIGN_TOP);
+    scrollbarBoxBtn->setPosition(0, MaxHeight);
+    scrollbarBoxBtn->setHoldable(true);
+    scrollbarBoxBtn->setTrigger(&touchTrigger, 0);
+    scrollbarBoxBtn->setTrigger(&wpadTouchTrigger, 1);
+    scrollbarBoxBtn->setEffectGrow();
+    scrollbarBoxBtn->held.connect(this, &GuiScrollbar::OnBoxButtonHold);
+}
+
+GuiScrollbar::~GuiScrollbar() {
+    delete arrowUpBtn;
+    delete arrowDownBtn;
+    delete scrollbarBoxBtn;
+}
+
+void GuiScrollbar::ScrollOneUp() {
+    if (SelItem == 0 && SelInd > 0) {
+        // move list up by 1
+        --SelInd;
+    } else if (SelInd + SelItem > 0) {
+        --SelItem;
+    }
+}
+
+void GuiScrollbar::ScrollOneDown() {
+    if (SelInd + SelItem + 1 < EntrieCount) {
+        if (SelItem == PageSize - 1) {
+            // move list down by 1
+            SelInd++;
+        } else {
+            SelItem++;
+        }
+    }
+}
+
+void GuiScrollbar::OnUpButtonClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger) {
+    if (ScrollState < ScrollSpeed) {
+        return;
+    }
+
+    ScrollOneUp();
+
+    ScrollState = 0;
+    listChanged(SelItem, SelInd);
+}
+
+void GuiScrollbar::OnDownButtonClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger) {
+    if (ScrollState < ScrollSpeed) {
+        return;
+    }
+
+    ScrollOneDown();
+
+    ScrollState = 0;
+    listChanged(SelItem, SelInd);
+}
+
+void GuiScrollbar::OnBoxButtonHold(GuiButton *button, const GuiController *controller, GuiTrigger *trigger) {
+    if (EntrieCount == 0) {
+        return;
+    }
+
+    if (!controller->data.validPointer) {
+        return;
+    }
+
+    int32_t y = controller->data.y - this->getCenterY();
+
+    int32_t positionWiimote = LIMIT(y - MinHeight, 0, MaxHeight - MinHeight);
+
+    int32_t newSelected = (EntrieCount - 1) - (int32_t) ((float) positionWiimote / (float) (MaxHeight - MinHeight) * (float) (EntrieCount - 1));
+
+    int32_t diff = newSelected - SelInd - SelItem;
+
+    if (newSelected <= 0) {
+        SelItem = 0;
+        SelInd  = 0;
+    } else if (newSelected >= EntrieCount - 1) {
+        SelItem = (PageSize - 1 < EntrieCount - 1) ? PageSize - 1 : EntrieCount - 1;
+        SelInd  = EntrieCount - PageSize;
+    } else if (newSelected < PageSize && SelInd == 0 && diff < 0) {
+        SelItem = std::max(SelItem + diff, (int32_t) 0);
+    } else if (EntrieCount - newSelected < PageSize && SelInd == EntrieCount - PageSize && diff > 0) {
+        SelItem = std::min(SelItem + diff, PageSize - 1);
+    } else {
+        SelInd = LIMIT(SelInd + diff, 0, ((EntrieCount - PageSize < 0) ? 0 : EntrieCount - PageSize));
+    }
+
+    ScrollState = 0;
+    listChanged(SelItem, SelInd);
+}
+
+void GuiScrollbar::SetPageSize(int32_t size) {
+    if (PageSize == size) {
+        return;
+    }
+
+    PageSize = size;
+    listChanged(SelItem, SelInd);
+}
+
+void GuiScrollbar::SetSelectedItem(int32_t pos) {
+    if (SelItem == pos) {
+        return;
+    }
+
+    SelItem = LIMIT(pos, 0, EntrieCount - 1);
+    listChanged(SelItem, SelInd);
+}
+
+void GuiScrollbar::SetSelectedIndex(int32_t pos) {
+    if (SelInd == pos) {
+        return;
+    }
+
+    SelInd = pos;
+    listChanged(SelItem, SelInd);
+}
+
+void GuiScrollbar::SetEntrieCount(int32_t cnt) {
+    if (EntrieCount == cnt) {
+        return;
+    }
+
+    EntrieCount = cnt;
+    listChanged(SelItem, SelInd);
+}
+
+void GuiScrollbar::setScrollboxPosition(int32_t SelItem, int32_t SelInd) {
+    int32_t position = MaxHeight - (MaxHeight - MinHeight) * (SelInd + SelItem) / (EntrieCount - 1);
+
+    if (position < MinHeight || (SelInd + SelItem >= EntrieCount - 1)) {
+        position = MinHeight;
+    } else if (position > MaxHeight || (SelInd + SelItem) == 0) {
+        position = MaxHeight;
+    }
+
+    scrollbarBoxBtn->setPosition(0, position);
+}
+
+void GuiScrollbar::draw(CVideo *video) {
+    if (scrollbarLineImage) {
+        scrollbarLineImage->draw(video);
+    }
+    arrowUpBtn->draw(video);
+    arrowDownBtn->draw(video);
+    scrollbarBoxBtn->draw(video);
+
+    updateEffects();
+}
+
+void GuiScrollbar::update(GuiController *t) {
+    if (this->isStateSet(STATE_DISABLED)) {
+        return;
+    }
+
+    arrowUpBtn->update(t);
+    arrowDownBtn->update(t);
+    scrollbarBoxBtn->update(t);
+
+    ++ScrollState;
+}

src/gui/GuiScrollbar.h

@@ -0,0 +1,150 @@
+/***************************************************************************
+ * Copyright (C) 2011
+ * by Dimok
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any
+ * damages arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any
+ * purpose, including commercial applications, and to alter it and
+ * redistribute it freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you
+ * must not claim that you wrote the original software. If you use
+ * this software in a product, an acknowledgment in the product
+ * documentation would be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and
+ * must not be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+ ***************************************************************************/
+#ifndef GUI_SCROLLBAR_HPP_
+#define GUI_SCROLLBAR_HPP_
+
+#include <gui/GuiButton.h>
+#include <gui/GuiElement.h>
+
+class GuiScrollbar : public GuiElement, public sigslot::has_slots<> {
+public:
+    GuiScrollbar(int32_t height);
+
+    virtual ~GuiScrollbar();
+
+    void ScrollOneUp();
+
+    void ScrollOneDown();
+
+    int32_t GetSelectedItem() {
+        return SelItem;
+    }
+
+    int32_t GetSelectedIndex() {
+        return SelInd;
+    }
+
+    void draw(CVideo *video) override;
+
+    void update(GuiController *t);
+
+    //! Signals
+    sigslot::signal2<int32_t, int32_t> listChanged;
+
+    //! Slots
+    void SetScrollSpeed(int32_t speed) {
+        ScrollSpeed = speed;
+    };
+
+    void SetPageSize(int32_t size);
+
+    void SetRowSize(int32_t size);
+
+    void SetSelectedItem(int32_t pos);
+
+    void SetSelectedIndex(int32_t pos);
+
+    void SetEntrieCount(int32_t cnt);
+
+    void setSoundClick(GuiSound *snd) {
+        clickSound = snd;
+        arrowUpBtn->setSoundClick(snd);
+        arrowDownBtn->setSoundClick(snd);
+    }
+
+    void setImageScrollbarLine(GuiImage *img) {
+        if (img) {
+            scrollbarLineImage = img;
+            scrollbarLineImage->setParent(this);
+            scrollbarLineImage->setParent(this);
+            scrollbarLineImage->setAlignment(ALIGN_CENTER | ALIGN_MIDDLE);
+            scrollbarLineImage->setPosition(0, 0);
+        }
+    }
+
+    void setImageArrowDown(GuiImage *img) {
+        if (img) {
+            arrowDownImage = img;
+            arrowDownBtn->setSize(img->getWidth(), img->getHeight());
+            arrowDownBtn->setImage(img);
+        }
+    }
+
+    void setImageArrowUp(GuiImage *img) {
+        if (img) {
+            arrowUpImage = img;
+            arrowUpBtn->setSize(img->getWidth(), img->getHeight());
+            arrowUpBtn->setImage(img);
+        }
+    }
+
+    void setImageScrollbarBox(GuiImage *img) {
+        if (img) {
+            scrollbarBoxImage = img;
+            scrollbarBoxBtn->setSize(img->getWidth(), height);
+            scrollbarBoxBtn->setImage(img);
+
+            width = img->getWidth();
+
+            MaxHeight = height * 0.5f - (img ? (img->getHeight() * 0.5f) : 0) - (arrowUpImage ? arrowUpImage->getHeight() : 0);
+            MinHeight = -height * 0.5f + (img ? (img->getHeight() * 0.5f) : 0) + (arrowDownImage ? arrowDownImage->getHeight() : 0);
+        }
+    }
+
+protected:
+    void setScrollboxPosition(int32_t SelItem, int32_t SelInd);
+
+    void OnUpButtonClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger);
+
+    void OnDownButtonClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger);
+
+    void OnBoxButtonHold(GuiButton *button, const GuiController *controller, GuiTrigger *trigger);
+
+    uint32_t ScrollState;
+    uint16_t ScrollSpeed;
+
+    int32_t MinHeight;
+    int32_t MaxHeight;
+    int32_t SelItem;
+    int32_t SelInd;
+    int32_t PageSize;
+    int32_t EntrieCount;
+    int32_t pressedChan;
+
+    GuiButton *arrowUpBtn;
+    GuiButton *arrowDownBtn;
+    GuiButton *scrollbarBoxBtn;
+
+    GuiSound *clickSound = NULL;
+
+    GuiImage *scrollbarLineImage = NULL;
+    GuiImage *arrowDownImage     = NULL;
+    GuiImage *arrowUpImage       = NULL;
+    GuiImage *scrollbarBoxImage  = NULL;
+
+    GuiTrigger touchTrigger;
+    GuiTrigger wpadTouchTrigger;
+};
+
+#endif

src/gui/GuiSelectBox.cpp

@@ -0,0 +1,289 @@
+/****************************************************************************
+ * Copyright (C) 2016 Maschell
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <string>
+#include <vector>
+
+#include <gui/GuiImage.h>
+#include <gui/GuiImageData.h>
+#include <gui/GuiSelectBox.h>
+#include <gui/GuiTrigger.h>
+
+/**
+ * Constructor for the GuiCheckBox class.
+ */
+
+GuiSelectBox::GuiSelectBox(GuiImage *background, std::string caption, float width, float height, GuiFrame *parent)
+    : GuiFrame(width, height, parent), selected(0), captionText(caption), topValueButton(0, 0), touchTrigger(GuiTrigger::CHANNEL_1, GuiTrigger::VPAD_TOUCH),
+      wpadTouchTrigger(GuiTrigger::CHANNEL_2 | GuiTrigger::CHANNEL_3 | GuiTrigger::CHANNEL_4 | GuiTrigger::CHANNEL_5, GuiTrigger::BUTTON_A), buttonATrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_A, true),
+      buttonBTrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_B, true), buttonUpTrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_UP | GuiTrigger::STICK_L_UP, true),
+      buttonDownTrigger(GuiTrigger::CHANNEL_ALL, GuiTrigger::BUTTON_DOWN | GuiTrigger::STICK_L_DOWN, true), DPADButtons(0, 0) {
+    setImageTopBackground(background);
+    showValues       = false;
+    bChanged         = false;
+    bSelectedChanged = false;
+    opened           = false;
+    topValueText.setFontSize(32);
+    topValueText.setAlignment(ALIGN_LEFT);
+    topValueText.setPosition(10, -7);
+    topValueButton.setLabel(&topValueText);
+    topValueButton.setTrigger(&touchTrigger);
+    topValueButton.setTrigger(&wpadTouchTrigger);
+    topValueButton.clicked.connect(this, &GuiSelectBox::OnTopValueClicked);
+
+    valuesFrame.setState(STATE_HIDDEN);
+
+    DPADButtons.setTrigger(&buttonBTrigger);
+    DPADButtons.setTrigger(&buttonATrigger);
+    DPADButtons.setTrigger(&buttonDownTrigger);
+    DPADButtons.setTrigger(&buttonUpTrigger);
+    DPADButtons.clicked.connect(this, &GuiSelectBox::OnDPADClick);
+    DPADButtons.setState(STATE_DISABLE_INPUT);
+
+    append(&DPADButtons);
+    append(&valuesFrame);
+    append(&topValueButton);
+
+    showValues = false;
+    bChanged   = true;
+}
+
+void GuiSelectBox::setSize(float width, float height) {
+    GuiFrame::setSize(width, height);
+    topValueButton.setSize(width, height);
+}
+
+void GuiSelectBox::OnValueClicked(GuiButton *button, const GuiController *controller, GuiTrigger *trigger) {
+    for (uint32_t i = 0; i < valueButtons.size(); ++i) {
+        if (valueButtons[i].valueButton == button) {
+            selected = i;
+            SelectValue(i);
+            break;
+        }
+    }
+}
+
+void GuiSelectBox::SelectValue(uint32_t value) {
+    if (value < valueButtons.size()) {
+        const wchar_t *w_text = valueButtons[value].valueButtonText->getText();
+        std::wstring ws(w_text);
+        std::string text(ws.begin(), ws.end());
+        topValueText.setText(text.c_str());
+
+        std::string real_value = buttonToValue[valueButtons[value].valueButton];
+        if (real_value.compare(std::string()) == 0) { real_value = "<error>"; }
+
+        valueChanged(this, real_value);
+        ShowHideValues(false);
+    }
+}
+
+void GuiSelectBox::OnTopValueClicked(GuiButton *button, const GuiController *controller, GuiTrigger *trigger) {
+    ShowHideValues(!showValues);
+}
+
+void GuiSelectBox::ShowHideValues(bool showhide) {
+    showValues = showhide;
+    bChanged   = true;
+}
+
+void GuiSelectBox::OnDPADClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger) {
+    if (opened == true) {
+        if (trigger == &buttonATrigger) {
+            //! do not auto launch when wiimote is pointing to screen and presses A
+            if ((controller->chan & (GuiTrigger::CHANNEL_2 | GuiTrigger::CHANNEL_3 | GuiTrigger::CHANNEL_4 | GuiTrigger::CHANNEL_5)) && controller->data.validPointer) {
+                return;
+            }
+            SelectValue(selected);
+        } else if (trigger == &buttonBTrigger) {
+            if (button == &DPADButtons) {
+                ShowHideValues(false);
+            } else {
+            }
+        } else if (trigger == &buttonUpTrigger) {
+            if (selected > 0) { selected--; }
+            bSelectedChanged = true;
+        } else if (trigger == &buttonDownTrigger) {
+            selected++;
+            if (selected >= valueButtons.size()) { selected = valueButtons.size() - 1; }
+            bSelectedChanged = true;
+        }
+    }
+}
+
+void GuiSelectBox::Init(std::map<std::string, std::string> values, int32_t valueID) {
+    if ((uint32_t) valueID >= values.size()) {
+        valueID = 0;
+    }
+
+    selected         = valueID;
+    bSelectedChanged = true;
+
+    DeleteValueData();
+
+    if (valueImageData == NULL || valueSelectedImageData == NULL || valueHighlightedImageData == NULL) {
+        return;
+    }
+
+    valueButtons.resize(values.size());
+
+    int32_t i      = 0;
+    float imgScale = 1.0f;
+    std::map<std::string, std::string>::iterator itr;
+    for (itr = values.begin(); itr != values.end(); itr++) {
+        if (i == valueID) {
+            topValueText.setText(itr->first.c_str());
+        }
+
+        valueButtons[i].valueButtonImg            = new GuiImage(valueImageData);
+        valueButtons[i].valueButtonCheckedImg     = new GuiImage(valueSelectedImageData);
+        valueButtons[i].valueButtonHighlightedImg = new GuiImage(valueHighlightedImageData);
+
+        valueButtons[i].valueButton     = new GuiButton(valueButtons[i].valueButtonImg->getWidth() * imgScale, valueButtons[i].valueButtonImg->getHeight() * imgScale);
+        valueButtons[i].valueButtonText = new GuiText(itr->first.c_str(), 32, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
+
+        valueButtons[i].valueButtonText->setMaxWidth(valueButtons[i].valueButtonImg->getWidth() * imgScale - 20.0f, GuiText::WRAP);
+        valueButtons[i].valueButtonText->setPosition(0, 0);
+
+        valueButtons[i].valueButtonImg->setScale(imgScale);
+        valueButtons[i].valueButtonCheckedImg->setScale(imgScale);
+
+        valueButtons[i].valueButton->setImage(valueButtons[i].valueButtonImg);
+        valueButtons[i].valueButton->setIconOver(valueButtons[i].valueButtonHighlightedImg);
+        valueButtons[i].valueButton->setTrigger(&touchTrigger);
+        valueButtons[i].valueButton->setTrigger(&wpadTouchTrigger);
+        valueButtons[i].valueButton->clicked.connect(this, &GuiSelectBox::OnValueClicked);
+        valueButtons[i].valueButton->setSoundClick(buttonClickSound);
+        valueButtons[i].valueButton->setLabel(valueButtons[i].valueButtonText);
+
+        //valueButtons[i].valueButton->setState(STATE_HIDDEN); //Wont get disabled soon enough
+
+        buttonToValue[valueButtons[i].valueButton] = itr->second;
+
+        float topHeight = 0;
+        if (topBackgroundImg != NULL) {
+            topHeight = topBackgroundImg->getHeight();
+        }
+
+        int32_t ypos = (((valueButtons[i].valueButtonImg->getHeight() * getScale()) * (i)) + (topHeight - 5) * getScale()) * -1.0f;
+        valueButtons[i].valueButton->setPosition(0, ypos);
+        valuesFrame.append(valueButtons[i].valueButton);
+
+        i++;
+    }
+
+    //Collapse the thing!
+    showValues = false;
+    bChanged   = true;
+}
+
+void GuiSelectBox::DeleteValueData() {
+    for (uint32_t i = 0; i < valueButtons.size(); ++i) {
+        valuesFrame.remove(valueButtons[i].valueButton);
+        delete valueButtons[i].valueButtonImg;
+        delete valueButtons[i].valueButtonCheckedImg;
+        delete valueButtons[i].valueButtonHighlightedImg;
+        delete valueButtons[i].valueButton;
+        delete valueButtons[i].valueButtonText;
+    }
+    buttonToValue.clear();
+    valueButtons.clear();
+}
+
+/**
+ * Destructor for the GuiButton class.
+ */
+GuiSelectBox::~GuiSelectBox() {
+    DeleteValueData();
+    bChanged   = false;
+    selected   = 0;
+    showValues = false;
+}
+
+
+void GuiSelectBox::setState(int32_t s, int32_t c) {
+    GuiElement::setState(s, c);
+}
+
+void GuiSelectBox::OnValueCloseEffectFinish(GuiElement *element) {
+    valuesFrame.effectFinished.disconnect(this);
+}
+
+float GuiSelectBox::getTopValueHeight() {
+    if (topBackgroundImg == NULL) {
+        return 0.0f;
+    }
+    return topBackgroundImg->getHeight();
+}
+
+float GuiSelectBox::getTopValueWidth() {
+    if (topBackgroundImg == NULL) {
+        return 0.0f;
+    }
+    return topBackgroundImg->getWidth();
+}
+
+float GuiSelectBox::getHeight() {
+    return getTopValueHeight();
+}
+
+float GuiSelectBox::getWidth() {
+    return getTopValueWidth();
+}
+
+
+void GuiSelectBox::OnValueOpenEffectFinish(GuiElement *element) {
+    valuesFrame.effectFinished.disconnect(this);
+    opened = true;
+}
+
+void GuiSelectBox::update(GuiController *c) {
+    if (bChanged) {
+        showhide(this, showValues);
+        if (showValues) {
+            for (uint32_t i = 0; i < valueButtons.size(); ++i) { //TODO: only set when it really changed
+                if (i == selected) {
+                    valueButtons[i].valueButton->setImage(valueButtons[i].valueButtonCheckedImg);
+                } else {
+                    valueButtons[i].valueButton->setImage(valueButtons[i].valueButtonImg);
+                }
+            }
+            valuesFrame.clearState(STATE_HIDDEN);
+            DPADButtons.clearState(STATE_DISABLE_INPUT);
+            valuesFrame.setEffect(EFFECT_FADE, 10, 255);
+            valuesFrame.effectFinished.connect(this, &GuiSelectBox::OnValueCloseEffectFinish);
+        } else {
+            opened = false;
+            valuesFrame.setState(STATE_HIDDEN);
+            DPADButtons.setState(STATE_DISABLE_INPUT);
+            valuesFrame.setEffect(EFFECT_FADE, -10, 0);
+            valuesFrame.effectFinished.connect(this, &GuiSelectBox::OnValueOpenEffectFinish);
+        }
+
+        bChanged = false;
+    }
+    if (bSelectedChanged) {
+        for (uint32_t i = 0; i < valueButtons.size(); ++i) {
+            if (i == selected) {
+                valueButtons[i].valueButton->setState(STATE_SELECTED);
+            } else {
+                valueButtons[i].valueButton->clearState(STATE_SELECTED);
+            }
+        }
+    }
+    topValueButton.setState(getState());
+    GuiFrame::update(c);
+}

src/gui/GuiSelectBox.h

@@ -0,0 +1,139 @@
+/****************************************************************************
+ * Copyright (C) 2016 Maschell
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef GUI_SELECTBOX_H_
+#define GUI_SELECTBOX_H_
+
+#include <gui/Gui.h>
+#include <gui/GuiImage.h>
+#include <gui/GuiImageData.h>
+
+//!A simple CheckBox
+class GuiSelectBox : public GuiFrame, public sigslot::has_slots<> {
+public:
+    //!Constructor
+    //!\param checked Checked
+    GuiSelectBox(GuiImage *background, std::string caption, float width = 0.0f, float height = 0.0f, GuiFrame *parent = 0);
+
+    //!Destructor
+    virtual ~GuiSelectBox();
+
+    sigslot::signal2<GuiSelectBox *, std::string> valueChanged;
+    sigslot::signal2<GuiSelectBox *, bool> showhide;
+
+    void setImageTopBackground(GuiImage *img) {
+        topBackgroundImg = img;
+        topValueButton.setImage(img);
+    }
+
+    void setImageTopHighlighted(GuiImage *img) {
+        topHighlightedImg = img;
+        topValueButton.setIconOver(img);
+    }
+
+    void setImageValueBackground(GuiImageData *img) {
+        valueImageData = img;
+    }
+
+    void setImageValueHighlighted(GuiImageData *img) {
+        valueHighlightedImageData = img;
+    }
+
+    void setImageValueSelected(GuiImageData *img) {
+        valueSelectedImageData = img;
+    }
+
+    void setSoundClick(GuiSound *snd) {
+        buttonClickSound = snd;
+        topValueButton.setSoundClick(snd);
+    }
+
+    void OnTopValueClicked(GuiButton *button, const GuiController *controller, GuiTrigger *trigger);
+
+    void Init(std::map<std::string, std::string> values, int32_t valueID);
+
+    void setState(int32_t s, int32_t c = -1);
+
+    virtual void setSize(float width, float height);
+
+    virtual float getTopValueHeight();
+
+    virtual float getTopValueWidth();
+
+    virtual float getHeight();
+
+    virtual float getWidth();
+
+protected:
+    void DeleteValueData();
+
+    void update(GuiController *c);
+
+    void OnValueClicked(GuiButton *button, const GuiController *controller, GuiTrigger *trigger);
+
+    void OnDPADClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger);
+
+    void OnValueOpenEffectFinish(GuiElement *element);
+
+    void OnValueCloseEffectFinish(GuiElement *element);
+
+    void ShowHideValues(bool showhide);
+
+    void SelectValue(uint32_t value);
+
+    uint32_t selected;
+    bool bChanged;
+    bool bSelectedChanged;
+    bool showValues;
+    bool opened;
+    std::string captionText;
+    GuiFrame valuesFrame;
+    GuiImage *topBackgroundImg  = NULL;
+    GuiImage *topHighlightedImg = NULL;
+
+    GuiButton topValueButton;
+    GuiImageData *valueImageData            = NULL;
+    GuiImageData *valueSelectedImageData    = NULL;
+    GuiImageData *valueHighlightedImageData = NULL;
+    GuiText topValueText;
+
+    GuiTrigger touchTrigger;
+    GuiTrigger wpadTouchTrigger;
+
+    GuiTrigger buttonATrigger;
+    GuiTrigger buttonBTrigger;
+    GuiTrigger buttonLeftTrigger;
+    GuiTrigger buttonRightTrigger;
+    GuiTrigger buttonUpTrigger;
+    GuiTrigger buttonDownTrigger;
+
+    GuiButton DPADButtons;
+
+    GuiSound *buttonClickSound;
+
+    typedef struct {
+        GuiImage *valueButtonImg;
+        GuiImage *valueButtonCheckedImg;
+        GuiImage *valueButtonHighlightedImg;
+        GuiButton *valueButton;
+        GuiText *valueButtonText;
+    } SelectBoxValueButton;
+
+    std::map<GuiButton *, std::string> buttonToValue;
+    std::vector<SelectBoxValueButton> valueButtons;
+};
+
+#endif

src/gui/GuiSound.cpp

@@ -0,0 +1,180 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <gui/GuiSound.h>
+#include <sounds/SoundHandler.hpp>
+#include <stdio.h>
+#include <string.h>
+#include <string>
+
+GuiSound::GuiSound(const char *filepath) {
+    voice = -1;
+    Load(filepath);
+}
+
+GuiSound::GuiSound(const uint8_t *snd, int32_t length) {
+    voice = -1;
+    Load(snd, length);
+}
+
+GuiSound::~GuiSound() {
+    if (voice >= 0) {
+        SoundHandler::instance()->RemoveDecoder(voice);
+    }
+}
+
+
+bool GuiSound::Load(const char *filepath) {
+    if (voice >= 0) {
+        SoundHandler::instance()->RemoveDecoder(voice);
+        voice = -1;
+    }
+
+    //! find next free decoder
+    for (int32_t i = 0; i < MAX_DECODERS; i++) {
+        SoundDecoder *decoder = SoundHandler::instance()->getDecoder(i);
+        if (decoder == NULL) {
+            SoundHandler::instance()->AddDecoder(i, filepath);
+            decoder = SoundHandler::instance()->getDecoder(i);
+            if (decoder) {
+                voice = i;
+                SoundHandler::instance()->ThreadSignal();
+            }
+            break;
+        }
+    }
+
+    if (voice < 0) {
+        return false;
+    }
+
+    return true;
+}
+
+bool GuiSound::Load(const uint8_t *snd, int32_t len) {
+    if (voice >= 0) {
+        SoundHandler::instance()->RemoveDecoder(voice);
+        voice = -1;
+    }
+
+    if (!snd) {
+        return false;
+    }
+
+    //! find next free decoder
+    for (int32_t i = 0; i < MAX_DECODERS; i++) {
+        SoundDecoder *decoder = SoundHandler::instance()->getDecoder(i);
+        if (decoder == NULL) {
+            SoundHandler::instance()->AddDecoder(i, snd, len);
+            decoder = SoundHandler::instance()->getDecoder(i);
+            if (decoder) {
+                voice = i;
+                SoundHandler::instance()->ThreadSignal();
+            }
+            break;
+        }
+    }
+
+    if (voice < 0) {
+        return false;
+    }
+
+    return true;
+}
+
+void GuiSound::Play() {
+    Stop();
+
+    Voice *v = SoundHandler::instance()->getVoice(voice);
+    if (v) {
+        v->setState(Voice::STATE_START);
+    }
+}
+
+void GuiSound::Stop() {
+    Voice *v = SoundHandler::instance()->getVoice(voice);
+    if (v) {
+        if ((v->getState() != Voice::STATE_STOP) && (v->getState() != Voice::STATE_STOPPED)) {
+            v->setState(Voice::STATE_STOP);
+        }
+
+        while (v->getState() != Voice::STATE_STOPPED)
+            OSSleepTicks(OSMicrosecondsToTicks(1000));
+    }
+
+    SoundDecoder *decoder = SoundHandler::instance()->getDecoder(voice);
+    if (decoder) {
+        decoder->Lock();
+        decoder->Rewind();
+        decoder->ClearBuffer();
+        SoundHandler::instance()->ThreadSignal();
+        decoder->Unlock();
+    }
+}
+
+void GuiSound::Pause() {
+    if (!IsPlaying()) {
+        return;
+    }
+
+    Voice *v = SoundHandler::instance()->getVoice(voice);
+    if (v) {
+        v->setState(Voice::STATE_STOP);
+    }
+}
+
+void GuiSound::Resume() {
+    if (IsPlaying()) {
+        return;
+    }
+
+    Voice *v = SoundHandler::instance()->getVoice(voice);
+    if (v) {
+        v->setState(Voice::STATE_START);
+    }
+}
+
+bool GuiSound::IsPlaying() {
+    Voice *v = SoundHandler::instance()->getVoice(voice);
+    if (v) {
+        return v->getState() == Voice::STATE_PLAYING;
+    }
+    return false;
+}
+
+void GuiSound::SetVolume(uint32_t vol) {
+    if (vol > 100) {
+        vol = 100;
+    }
+
+    uint32_t volumeConv = ((0x8000 * vol) / 100) << 16;
+
+    Voice *v = SoundHandler::instance()->getVoice(voice);
+    if (v) {
+        v->setVolume(volumeConv);
+    }
+}
+
+void GuiSound::SetLoop(bool l) {
+    SoundDecoder *decoder = SoundHandler::instance()->getDecoder(voice);
+    if (decoder) {
+        decoder->SetLoop(l);
+    }
+}
+
+void GuiSound::Rewind() {
+    Stop();
+}

src/gui/GuiSound.h

@@ -0,0 +1,71 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef GUI_SOUND_H_
+#define GUI_SOUND_H_
+
+#include <gui/GuiElement.h>
+
+//!Sound conversion and playback. A wrapper for other sound libraries - ASND, libmad, ltremor, etc
+class GuiSound : public GuiElement {
+public:
+    //!Constructor
+    //!\param sound Pointer to the sound data
+    //!\param filesize Length of sound data
+    GuiSound(const char *filepath);
+
+    GuiSound(const uint8_t *sound, int32_t length);
+
+    //!Destructor
+    virtual ~GuiSound();
+
+    //!Load a file and replace the old one
+    bool Load(const char *filepath);
+
+    //!Load a file and replace the old one
+    bool Load(const uint8_t *snd, int32_t len);
+
+    //!Start sound playback
+    void Play();
+
+    //!Stop sound playback
+    void Stop();
+
+    //!Pause sound playback
+    void Pause();
+
+    //!Resume sound playback
+    void Resume();
+
+    //!Checks if the sound is currently playing
+    //!\return true if sound is playing, false otherwise
+    bool IsPlaying();
+
+    //!Rewind the music
+    void Rewind();
+
+    //!Set sound volume
+    //!\param v Sound volume (0-100)
+    void SetVolume(uint32_t v);
+
+    //!\param l Loop (true to loop)
+    void SetLoop(bool l);
+
+protected:
+    int32_t voice; //!< Currently assigned ASND voice channel
+};
+
+#endif

src/gui/GuiSwitch.cpp

@@ -0,0 +1,80 @@
+/****************************************************************************
+ * Copyright (C) 2016,2017 Maschell
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <gui/GuiImage.h>
+#include <gui/GuiImageData.h>
+#include <gui/GuiSwitch.h>
+
+/**
+ * Constructor for the GuiSwitch class.
+ */
+
+GuiSwitch::GuiSwitch(GuiImage *background, bool checked, float w, float h)
+    : GuiToggle(checked, w, h) {
+    setImageBackground(background);
+}
+
+/**
+ * Destructor for the GuiSwitch class.
+ */
+GuiSwitch::~GuiSwitch() {
+}
+
+void GuiSwitch::setImageBackground(GuiImage *img) {
+    backgroundImg = img;
+    if (img) {
+        img->setParent(this);
+    }
+    setImage(img);
+}
+
+void GuiSwitch::setImageOn(GuiImage *img) {
+    onImg = img;
+    if (img) {
+        img->setParent(this);
+        img->setAlignment(ALIGN_RIGHT);
+    }
+}
+
+void GuiSwitch::setImageOff(GuiImage *img) {
+    offImg = img;
+    if (img) {
+        img->setParent(this);
+        img->setAlignment(ALIGN_LEFT);
+    }
+}
+
+void GuiSwitch::setImageHighlighted(GuiImage *img) {
+    highlightedImg = img;
+    setIconOver(img);
+}
+
+void GuiSwitch::draw(CVideo *v) {
+    if (!this->isVisible()) {
+        return;
+    }
+
+    GuiToggle::draw(v);
+    if (getValue()) {
+        if (onImg != NULL) {
+            onImg->draw(v);
+        }
+    } else {
+        if (offImg != NULL) {
+            offImg->draw(v);
+        }
+    }
+}

src/gui/GuiSwitch.h

@@ -0,0 +1,51 @@
+/****************************************************************************
+ * Copyright (C) 2016,2017 Maschell
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef GUI_SWTICH_H_
+#define GUI_SWTICH_H_
+
+#include <gui/GuiImage.h>
+#include <gui/GuiImageData.h>
+#include <gui/GuiToggle.h>
+
+//!A simple switch
+class GuiSwitch : public GuiToggle {
+public:
+    //!Constructor
+    //!\param checked Checked
+    GuiSwitch(GuiImage *background, bool checked, float w = 0.0f, float h = 0.0f);
+
+    //!Destructor
+    virtual ~GuiSwitch();
+
+    void setImageBackground(GuiImage *img);
+
+    void setImageOn(GuiImage *img);
+
+    void setImageOff(GuiImage *img);
+
+    void setImageHighlighted(GuiImage *img);
+
+protected:
+    GuiImage *backgroundImg  = NULL;
+    GuiImage *onImg          = NULL;
+    GuiImage *offImg         = NULL;
+    GuiImage *highlightedImg = NULL;
+
+    void draw(CVideo *v) override;
+};
+
+#endif

src/gui/GuiText.cpp

@@ -0,0 +1,704 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <gui/FreeTypeGX.h>
+#include <gui/GuiText.h>
+#include <video/CVideo.h>
+
+FreeTypeGX *GuiText::presentFont = NULL;
+int32_t GuiText::presetSSAA      = 2;
+int32_t GuiText::presetSize      = 28;
+int32_t GuiText::presetMaxWidth  = 0xFFFF;
+int32_t GuiText::presetAlignment = ALIGN_CENTER | ALIGN_MIDDLE;
+GX2ColorF32 GuiText::presetColor = (GX2ColorF32){
+        1.0f, 1.0f, 1.0f, 1.0f};
+
+#define TEXT_SCROLL_DELAY         6
+#define TEXT_SCROLL_INITIAL_DELAY 10
+#define MAX_LINES_TO_DRAW         10
+
+/**
+ * Constructor for the GuiText class.
+ */
+
+GuiText::GuiText() {
+    text                   = NULL;
+    currentSize            = presetSize;
+    color                  = glm::vec4(presetColor.r, presetColor.g, presetColor.b, presetColor.a);
+    alpha                  = presetColor.a;
+    alignment              = presetAlignment;
+    maxWidth               = presetMaxWidth;
+    internalSSAA           = presetSSAA;
+    wrapMode               = 0;
+    font                   = presentFont;
+    linestodraw            = MAX_LINES_TO_DRAW;
+    textScrollPos          = 0;
+    textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
+    textScrollDelay        = TEXT_SCROLL_DELAY;
+    defaultBlur            = 4.0f;
+    blurGlowIntensity      = 0.0f;
+    blurAlpha              = 0.0f;
+    blurGlowColor          = glm::vec4(0.0f);
+    width                  = 0;
+    height                 = 0;
+}
+
+GuiText::GuiText(const char *t, int32_t s, const glm::vec4 &c) {
+    text                   = NULL;
+    currentSize            = s;
+    color                  = c;
+    alpha                  = c[3];
+    alignment              = ALIGN_CENTER | ALIGN_MIDDLE;
+    maxWidth               = presetMaxWidth;
+    internalSSAA           = presetSSAA;
+    wrapMode               = 0;
+    font                   = presentFont;
+    linestodraw            = MAX_LINES_TO_DRAW;
+    textScrollPos          = 0;
+    textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
+    textScrollDelay        = TEXT_SCROLL_DELAY;
+    defaultBlur            = 4.0f;
+    blurGlowIntensity      = 0.0f;
+    blurAlpha              = 0.0f;
+    blurGlowColor          = glm::vec4(0.0f);
+    width                  = 0;
+    height                 = 0;
+
+    if (t) {
+        textMutex.lock();
+        text = FreeTypeGX::charToWideChar(t);
+        textMutex.unlock();
+    }
+}
+
+GuiText::GuiText(const wchar_t *t, int32_t s, const glm::vec4 &c) {
+    text                   = NULL;
+    currentSize            = s;
+    color                  = c;
+    alpha                  = c[3];
+    alignment              = ALIGN_CENTER | ALIGN_MIDDLE;
+    maxWidth               = presetMaxWidth;
+    internalSSAA           = presetSSAA;
+    wrapMode               = 0;
+    font                   = presentFont;
+    linestodraw            = MAX_LINES_TO_DRAW;
+    textScrollPos          = 0;
+    textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
+    textScrollDelay        = TEXT_SCROLL_DELAY;
+    defaultBlur            = 4.0f;
+    blurGlowIntensity      = 0.0f;
+    blurAlpha              = 0.0f;
+    blurGlowColor          = glm::vec4(0.0f);
+    width                  = 0;
+    height                 = 0;
+
+    if (t) {
+        textMutex.lock();
+        text = new (std::nothrow) wchar_t[wcslen(t) + 1];
+        if (!text) {
+            textMutex.unlock();
+            return;
+        }
+
+        wcscpy(text, t);
+        textMutex.unlock();
+    }
+}
+
+/**
+ * Constructor for the GuiText class, uses presets
+ */
+GuiText::GuiText(const char *t) {
+    text                   = NULL;
+    currentSize            = presetSize;
+    color                  = glm::vec4(presetColor.r, presetColor.g, presetColor.b, presetColor.a);
+    alpha                  = presetColor.a;
+    alignment              = presetAlignment;
+    maxWidth               = presetMaxWidth;
+    internalSSAA           = presetSSAA;
+    wrapMode               = 0;
+    font                   = presentFont;
+    linestodraw            = MAX_LINES_TO_DRAW;
+    textScrollPos          = 0;
+    textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
+    textScrollDelay        = TEXT_SCROLL_DELAY;
+    defaultBlur            = 4.0f;
+    blurGlowIntensity      = 0.0f;
+    blurAlpha              = 0.0f;
+    blurGlowColor          = glm::vec4(0.0f);
+    width                  = 0;
+    height                 = 0;
+
+    if (t) {
+        textMutex.lock();
+        text = FreeTypeGX::charToWideChar(t);
+        textMutex.unlock();
+    }
+}
+
+
+/**
+ * Destructor for the GuiText class.
+ */
+GuiText::~GuiText() {
+    textMutex.lock();
+    if (text) {
+        delete[] text;
+    }
+    text = NULL;
+    textMutex.unlock();
+
+    clearDynamicText();
+}
+
+void GuiText::setText(const char *t) {
+    textMutex.lock();
+    if (text) {
+        delete[] text;
+    }
+    text = NULL;
+
+    clearDynamicText();
+
+    textScrollPos          = 0;
+    textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
+
+    if (t) {
+        text = FreeTypeGX::charToWideChar(t);
+    }
+    textMutex.unlock();
+}
+
+void GuiText::setTextf(const char *format, ...) {
+    if (!format) {
+        setText((char *) NULL);
+        return;
+    }
+
+    int32_t max_len = strlen(format) + 8192;
+    char *tmp       = new (std::nothrow) char[max_len];
+    va_list va;
+    va_start(va, format);
+    if ((vsnprintf(tmp, max_len, format, va) >= 0) && tmp) {
+        setText(tmp);
+    }
+    va_end(va);
+
+    if (tmp) {
+        delete[] tmp;
+    }
+}
+
+
+void GuiText::setText(const wchar_t *t) {
+    textMutex.lock();
+    if (text) {
+        delete[] text;
+    }
+    text = NULL;
+
+    clearDynamicText();
+
+    textScrollPos          = 0;
+    textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
+
+    if (t) {
+        text = new (std::nothrow) wchar_t[wcslen(t) + 1];
+        if (!text) {
+            textMutex.unlock();
+            return;
+        }
+
+        wcscpy(text, t);
+    }
+    textMutex.unlock();
+}
+
+void GuiText::clearDynamicText() {
+    textMutex.lock();
+    for (uint32_t i = 0; i < textDyn.size(); i++) {
+        if (textDyn[i]) {
+            delete[] textDyn[i];
+        }
+    }
+    textDyn.clear();
+    textDynWidth.clear();
+    textMutex.unlock();
+}
+
+void GuiText::setPresets(int32_t sz, const glm::vec4 &c, int32_t w, int32_t a) {
+    presetSize  = sz;
+    presetColor = (GX2ColorF32){
+            (float) c.r / 255.0f, (float) c.g / 255.0f, (float) c.b / 255.0f, (float) c.a / 255.0f};
+    presetMaxWidth  = w;
+    presetAlignment = a;
+}
+
+void GuiText::setPresetFont(FreeTypeGX *f) {
+    presentFont = f;
+}
+
+void GuiText::setFontSize(int32_t s) {
+    currentSize = s;
+}
+
+void GuiText::setMaxWidth(int32_t width, int32_t w) {
+    maxWidth = width;
+    wrapMode = w;
+
+    if (w == SCROLL_HORIZONTAL) {
+        textScrollPos          = 0;
+        textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
+        textScrollDelay        = TEXT_SCROLL_DELAY;
+    }
+
+    clearDynamicText();
+}
+
+void GuiText::setColor(const glm::vec4 &c) {
+    color = c;
+    alpha = c[3];
+}
+
+void GuiText::setBlurGlowColor(float blur, const glm::vec4 &c) {
+    blurGlowColor     = c;
+    blurGlowIntensity = blur;
+    blurAlpha         = c[3];
+}
+
+int32_t GuiText::getTextWidth(int32_t ind) {
+    textMutex.lock();
+    int32_t res;
+    if (ind < 0 || ind >= (int32_t) textDyn.size()) {
+        res = this->getTextWidth();
+    } else {
+        res = font->getWidth(textDyn[ind], currentSize);
+    }
+    textMutex.unlock();
+    return res;
+}
+
+//!Get the Horizontal Size of Text
+int32_t GuiText::getTextWidth() {
+    textMutex.lock();
+    auto res = font->getWidth(text, currentSize);
+    res      = res > maxWidth && maxWidth > 0 ? maxWidth : res;
+    textMutex.unlock();
+    return res;
+}
+
+float GuiText::getTextHeight() {
+    textMutex.lock();
+    if (wrapMode == GuiText::WRAP && textDyn.empty()) {
+        if (maxWidth > 0 && font->getWidth(text, currentSize)) {
+            wrapText();
+        }
+    }
+
+    auto res = textDyn.empty() ? getLineHeight() : getLineHeight() * textDyn.size();
+    textMutex.unlock();
+    return res;
+}
+
+const wchar_t *GuiText::getDynText(int32_t ind) {
+    textMutex.lock();
+    const wchar_t *result;
+    if (ind < 0 || ind >= (int32_t) textDyn.size()) {
+        result = text;
+    } else {
+        result = textDyn[ind];
+    }
+    textMutex.unlock();
+    return result;
+}
+
+/**
+ * Change font
+ */
+bool GuiText::setFont(FreeTypeGX *f) {
+    if (!f) {
+        return false;
+    }
+
+    font = f;
+    return true;
+}
+
+std::string GuiText::toUTF8(void) const {
+    textMutex.lock();
+    if (!text) {
+        textMutex.unlock();
+        return std::string();
+    }
+
+    char *pUtf8 = FreeTypeGX::wideCharToUTF8(text);
+    textMutex.unlock();
+    if (!pUtf8) {
+        return std::string();
+    }
+
+    std::string strOutput(pUtf8);
+
+    delete[] pUtf8;
+
+    return strOutput;
+}
+
+void GuiText::makeDottedText() {
+    textMutex.lock();
+    int32_t pos = textDyn.size();
+    textDyn.resize(pos + 1);
+
+    int32_t i = 0, currentWidth = 0;
+    textDyn[pos] = new (std::nothrow) wchar_t[maxWidth];
+    if (!textDyn[pos]) {
+        textDyn.resize(pos);
+        textMutex.unlock();
+        return;
+    }
+
+    while (text[i]) {
+        currentWidth += font->getCharWidth(text[i], currentSize, i > 0 ? text[i - 1] : 0);
+        if (currentWidth >= maxWidth && i > 2) {
+            textDyn[pos][i - 2] = '.';
+            textDyn[pos][i - 1] = '.';
+            textDyn[pos][i]     = '.';
+            i++;
+            break;
+        }
+
+        textDyn[pos][i] = text[i];
+
+        i++;
+    }
+    textDyn[pos][i] = 0;
+    textMutex.unlock();
+}
+
+void GuiText::scrollText(uint32_t frameCount) {
+    textMutex.lock();
+    if (textDyn.size() == 0) {
+        int32_t pos = textDyn.size();
+        int32_t i = 0, currentWidth = 0;
+        textDyn.resize(pos + 1);
+
+        textDyn[pos] = new (std::nothrow) wchar_t[maxWidth];
+        if (!textDyn[pos]) {
+            textDyn.resize(pos);
+            textMutex.unlock();
+            return;
+        }
+
+        while (text[i] && currentWidth < maxWidth) {
+            textDyn[pos][i] = text[i];
+
+            currentWidth += font->getCharWidth(text[i], currentSize, i > 0 ? text[i - 1] : 0);
+
+            ++i;
+        }
+        textDyn[pos][i] = 0;
+        textMutex.unlock();
+        return;
+    }
+
+    if (frameCount % textScrollDelay != 0) {
+        textMutex.unlock();
+        return;
+    }
+
+    if (textScrollInitialDelay) {
+        --textScrollInitialDelay;
+        textMutex.unlock();
+        return;
+    }
+
+    int32_t stringlen = wcslen(text);
+
+    ++textScrollPos;
+    if (textScrollPos > stringlen) {
+        textScrollPos          = 0;
+        textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
+    }
+
+    int32_t ch  = textScrollPos;
+    int32_t pos = textDyn.size() - 1;
+
+    if (!textDyn[pos]) {
+        textDyn[pos] = new (std::nothrow) wchar_t[maxWidth];
+    }
+
+    if (!textDyn[pos]) {
+        textDyn.resize(pos);
+        textMutex.unlock();
+        return;
+    }
+
+    int32_t i = 0, currentWidth = 0;
+
+    while (currentWidth < maxWidth) {
+        if (ch > stringlen - 1) {
+            textDyn[pos][i++] = ' ';
+            currentWidth += font->getCharWidth(L' ', currentSize, ch > 0 ? text[ch - 1] : 0);
+            textDyn[pos][i++] = ' ';
+            currentWidth += font->getCharWidth(L' ', currentSize, L' ');
+            textDyn[pos][i++] = ' ';
+            currentWidth += font->getCharWidth(L' ', currentSize, L' ');
+            ch = 0;
+
+            if (currentWidth >= maxWidth) {
+                break;
+            }
+        }
+
+        textDyn[pos][i] = text[ch];
+        currentWidth += font->getCharWidth(text[ch], currentSize, ch > 0 ? text[ch - 1] : 0);
+        ++ch;
+        ++i;
+    }
+    textDyn[pos][i] = 0;
+    textMutex.unlock();
+}
+
+void GuiText::wrapText() {
+    textMutex.lock();
+    if (!text || textDyn.size() > 0) {
+        textMutex.unlock();
+        return;
+    }
+
+    int32_t i              = 0;
+    int32_t ch             = 0;
+    int32_t linenum        = 0;
+    int32_t lastSpace      = -1;
+    int32_t lastSpaceIndex = -1;
+    int32_t currentWidth   = 0;
+
+    while (text[ch] && linenum < linestodraw) {
+        if (linenum >= (int32_t) textDyn.size()) {
+            textDyn.resize(linenum + 1);
+            textDyn[linenum] = new (std::nothrow) wchar_t[maxWidth];
+            if (!textDyn[linenum]) {
+                textDyn.resize(linenum);
+                break;
+            }
+        }
+
+        textDyn[linenum][i]     = text[ch];
+        textDyn[linenum][i + 1] = 0;
+
+        currentWidth += font->getCharWidth(text[ch], currentSize, ch > 0 ? text[ch - 1] : 0x0000);
+
+        if (currentWidth >= maxWidth || (text[ch] == '\n')) {
+            if (text[ch] == '\n') {
+                lastSpace      = -1;
+                lastSpaceIndex = -1;
+            } else if (lastSpace >= 0) {
+                textDyn[linenum][lastSpaceIndex] = 0;         // discard space, and everything after
+                ch                               = lastSpace; // go backwards to the last space
+                lastSpace                        = -1;        // we have used this space
+                lastSpaceIndex                   = -1;
+            }
+
+            if (linenum + 1 == linestodraw && text[ch + 1] != 0x0000) {
+                if (i < 2) {
+                    i = 2;
+                }
+
+                textDyn[linenum][i - 2] = '.';
+                textDyn[linenum][i - 1] = '.';
+                textDyn[linenum][i]     = '.';
+                textDyn[linenum][i + 1] = 0;
+            }
+
+            currentWidth = 0;
+            ++linenum;
+            i = -1;
+        }
+        if (text[ch] == ' ' && i >= 0) {
+            lastSpace      = ch;
+            lastSpaceIndex = i;
+        }
+        ++ch;
+        ++i;
+    }
+    textMutex.unlock();
+}
+
+/**
+ * We need to redefine this, because we don't want to use our width.
+ */
+float GuiText::getCenterX(void) {
+    float pCenterX = 0.0f;
+
+    if (parentElement) {
+        pCenterX = parentElement->getCenterX();
+    }
+
+    pCenterX += xoffset + xoffsetDyn;
+
+    if (alignment & ALIGN_LEFT) {
+        float pWidth = 0.0f;
+        float pScale = 0.0f;
+
+        if (parentElement) {
+            pWidth = parentElement->getWidth();
+            pScale = parentElement->getScaleX();
+        }
+
+        pCenterX -= pWidth * 0.5f * pScale;
+    } else if (alignment & ALIGN_RIGHT) {
+        float pWidth = 0.0f;
+        float pScale = 0.0f;
+
+        if (parentElement) {
+            pWidth = parentElement->getWidth();
+            pScale = parentElement->getScaleX();
+        }
+
+        pCenterX += pWidth * 0.5f * pScale;
+    }
+    return pCenterX;
+}
+
+/**
+ * We need to redefine this, because we don't want to use our height.
+ */
+float GuiText::getCenterY(void) {
+    float pCenterY = 0.0f;
+
+    if (parentElement) {
+        pCenterY = parentElement->getCenterY();
+    }
+
+    pCenterY += yoffset + yoffsetDyn;
+
+    if (alignment & ALIGN_TOP) {
+        float pHeight = 0.0f;
+        float pScale  = 0.0f;
+
+        if (parentElement) {
+            pHeight = parentElement->getHeight();
+            pScale  = parentElement->getScaleY();
+        }
+
+        pCenterY += pHeight * 0.5f * pScale;
+    } else if (alignment & ALIGN_BOTTOM) {
+        float pHeight = 0.0f;
+        float pScale  = 0.0f;
+
+        if (parentElement) {
+            pHeight = parentElement->getHeight();
+            pScale  = parentElement->getScaleY();
+        }
+
+        pCenterY -= pHeight * 0.5f * pScale;
+    }
+    return pCenterY;
+}
+
+/**
+ * Draw the text on screen
+ */
+void GuiText::draw(CVideo *pVideo) {
+    textMutex.lock();
+    if (!text) {
+        textMutex.unlock();
+        return;
+    }
+
+    if (!isVisible()) {
+        textMutex.unlock();
+        return;
+    }
+
+    color[3]         = getAlpha();
+    blurGlowColor[3] = blurAlpha * getAlpha();
+
+    auto internalRenderingScale = internalSSAA == 0 ? 1 : internalSSAA << 1;
+
+    int32_t normal_size           = currentSize * getScale();
+    int32_t internalRenderingSize = normal_size * internalRenderingScale;
+
+    auto textWidth = font->getWidth(text, normal_size);
+
+    float x_pos = getCenterX() * internalRenderingScale;
+    float y_pos = getCenterY() * internalRenderingScale;
+
+    if (alignment & ALIGN_TOP) {
+        y_pos -= getLineHeight() * getScale() * internalRenderingScale;
+    } else if (alignment & ALIGN_BOTTOM) {
+        y_pos += getLineHeight() * getScale() * internalRenderingScale;
+    }
+
+    if (maxWidth > 0 && maxWidth <= textWidth) {
+        if (wrapMode == DOTTED) { // text dotted
+            if (textDyn.size() == 0) {
+                makeDottedText();
+            }
+
+            if (textDynWidth.size() != textDyn.size()) {
+                textDynWidth.resize(textDyn.size());
+
+                for (uint32_t i = 0; i < textDynWidth.size(); i++) {
+                    textDynWidth[i] = font->getWidth(textDyn[i], internalRenderingSize);
+                }
+            }
+
+
+            if (textDyn.size() > 0) {
+                font->drawText(pVideo, x_pos, y_pos, getDepth(), textDyn[textDyn.size() - 1], internalRenderingSize, color, alignment, textDynWidth[textDyn.size() - 1], defaultBlur, blurGlowIntensity, blurGlowColor, internalRenderingScale);
+            }
+            textMutex.unlock();
+            return;
+        } else if (wrapMode == SCROLL_HORIZONTAL) {
+            scrollText(pVideo->getFrameCount());
+
+            if (textDyn.size() > 0) {
+                font->drawText(pVideo, x_pos, y_pos, getDepth(), textDyn[textDyn.size() - 1], internalRenderingSize, color, alignment, maxWidth * internalRenderingScale * getScale(), defaultBlur, blurGlowIntensity, blurGlowColor,
+                               internalRenderingScale);
+            }
+            textMutex.unlock();
+            return;
+        } else if (wrapMode == WRAP) {
+            if (textDyn.size() == 0) {
+                wrapText();
+            }
+
+            if (textDynWidth.size() != textDyn.size()) {
+                textDynWidth.resize(textDyn.size());
+
+                for (uint32_t i = 0; i < textDynWidth.size(); i++) {
+                    textDynWidth[i] = font->getWidth(textDyn[i], internalRenderingSize);
+                }
+            }
+
+            float voffset = 0.0f;
+            if (alignment & ALIGN_MIDDLE) {
+                voffset = (float) (((int32_t) getLineHeight() * (textDyn.size() - 1)) >> 1) * internalRenderingScale;
+            }
+            float y_offset = 0.0f;
+            for (uint32_t i = 0; i < textDyn.size(); i++) {
+                font->drawText(pVideo, x_pos, y_pos + y_offset + voffset, getDepth(), textDyn[i], internalRenderingSize, color, alignment, textDynWidth[i], defaultBlur, blurGlowIntensity, blurGlowColor, internalRenderingScale);
+                y_offset -= getLineHeight() * getScale() * internalRenderingScale;
+            }
+            textMutex.unlock();
+            return;
+        }
+    }
+    auto newTextWidth = font->getWidth(text, internalRenderingSize);
+    font->drawText(pVideo, x_pos, y_pos, getDepth(), text, internalRenderingSize, color, alignment, newTextWidth, defaultBlur, blurGlowIntensity, blurGlowColor, internalRenderingScale);
+    textMutex.unlock();
+}

src/gui/GuiText.h

@@ -0,0 +1,213 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef GUI_TEXT_H_
+#define GUI_TEXT_H_
+
+#include <gui/GuiElement.h>
+#include <mutex>
+
+//!Forward declaration
+class FreeTypeGX;
+
+//!Display, manage, and manipulate text in the GUI
+class GuiText : public GuiElement {
+public:
+    //!Constructor
+    GuiText();
+
+    //!\param t Text
+    //!\param s Font size
+    //!\param c Font color
+    GuiText(const char *t, int32_t s, const glm::vec4 &c);
+
+    //!\overload
+    //!\param t Text
+    //!\param s Font size
+    //!\param c Font color
+    GuiText(const wchar_t *t, int32_t s, const glm::vec4 &c);
+
+    //!\overload
+    //!\Assumes SetPresets() has been called to setup preferred text attributes
+    //!\param t Text
+    GuiText(const char *t);
+
+    //!Destructor
+    virtual ~GuiText();
+
+    //!Sets the text of the GuiText element
+    //!\param t Text
+    virtual void setText(const char *t);
+
+    virtual void setText(const wchar_t *t);
+
+    virtual void setTextf(const char *format, ...) __attribute__((format(printf, 2, 3)));
+
+    //!Sets up preset values to be used by GuiText(t)
+    //!Useful when printing multiple text elements, all with the same attributes set
+    //!\param sz Font size
+    //!\param c Font color
+    //!\param w Maximum width of texture image (for text wrapping)
+    //!\param wrap Wrapmode when w>0
+    //!\param a Text alignment
+    static void setPresets(int32_t sz, const glm::vec4 &c, int32_t w, int32_t a);
+
+    static void setPresetFont(FreeTypeGX *font);
+
+    //!Sets the font size
+    //!\param s Font size
+    void setFontSize(int32_t s);
+
+    //!Sets the maximum width of the drawn texture image
+    //!If the text exceeds this, it is wrapped to the next line
+    //!\param w Maximum width
+    //!\param m WrapMode
+    void setMaxWidth(int32_t w = 0, int32_t m = WRAP);
+
+    //!Sets the font color
+    //!\param c Font color
+    void setColor(const glm::vec4 &c);
+
+    void setBlurGlowColor(float blurIntensity, const glm::vec4 &c);
+
+    void setTextBlur(float blur) {
+        defaultBlur = blur;
+    }
+
+    //!Get the original text as char
+    virtual const wchar_t *getText() const {
+        return text;
+    }
+
+    virtual std::string toUTF8(void) const;
+
+    //!Get the Horizontal Size of Text
+    int32_t getTextWidth();
+
+    int32_t getTextWidth(int32_t ind);
+
+    //!Get the max textwidth
+    int32_t getTextMaxWidth() {
+        return maxWidth;
+    }
+
+    float getLineHeight() {
+        return (float) currentSize;
+    }
+
+    float getTextHeight();
+
+    void setSSAA(int32_t ssaa) {
+        this->internalSSAA = ssaa;
+    };
+
+    //!Get fontsize
+    int32_t getFontSize() {
+        return currentSize;
+    };
+
+    //!Set max lines to draw
+    void setLinesToDraw(int32_t l) {
+        linestodraw = l;
+    }
+
+    //!Get current Textline (for position calculation)
+    const wchar_t *getDynText(int32_t ind = 0);
+
+    virtual const wchar_t *getTextLine(int32_t ind) {
+        return getDynText(ind);
+    };
+
+    //!Change the font
+    bool setFont(FreeTypeGX *font);
+
+    //! virtual function used in child classes
+    virtual int32_t getStartWidth() {
+        return 0;
+    };
+
+    //!Constantly called to draw the text
+    void draw(CVideo *pVideo) override;
+
+    virtual float getWidth() {
+        return getTextWidth();
+    }
+
+    virtual float getHeight() {
+        return getTextHeight();
+    }
+
+    virtual void setSize(float w, float h) {
+        //! We calculate the size based on the text.
+        this->width  = 0;
+        this->height = 0;
+    }
+
+    virtual float getCenterY(void);
+
+    virtual float getCenterX(void);
+
+    //! text enums
+    enum {
+        WRAP,
+        DOTTED,
+        SCROLL_HORIZONTAL,
+        SCROLL_NONE
+    };
+
+protected:
+    static FreeTypeGX *presentFont;
+    static int32_t presetSSAA;
+    static int32_t presetSize;
+    static int32_t presetMaxWidth;
+    static float presetInternalRenderingScale;
+    static int32_t presetAlignment;
+    static GX2ColorF32 presetColor;
+
+    //!Clear the dynamic text
+    void clearDynamicText();
+
+    //!Create a dynamic dotted text if the text is too long
+    void makeDottedText();
+
+    //!Scroll the text once
+    void scrollText(uint32_t frameCount);
+
+    //!Wrap the text to several lines
+    void wrapText();
+
+    mutable std::recursive_mutex textMutex;
+
+    wchar_t *text;
+    std::vector<wchar_t *> textDyn;
+    std::vector<uint16_t> textDynWidth;
+    int32_t wrapMode;               //!< Wrapping toggle
+    int32_t textScrollPos;          //!< Current starting index of text string for scrolling
+    int32_t textScrollInitialDelay; //!< Delay to wait before starting to scroll
+    int32_t textScrollDelay;        //!< Scrolling speed
+    int32_t maxWidth;               //!< Maximum width of the generated text object (for text wrapping)
+    FreeTypeGX *font;
+    int32_t currentSize;
+    int32_t linestodraw;
+    glm::vec4 color;
+    float defaultBlur;
+    float blurGlowIntensity;
+    float blurAlpha;
+    glm::vec4 blurGlowColor;
+    int32_t internalSSAA;
+};
+
+#endif

src/gui/GuiToggle.cpp

@@ -0,0 +1,50 @@
+/****************************************************************************
+ * Copyright (C) 2016 Maschell
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <gui/GuiToggle.h>
+
+/**
+ * Constructor for the GuiToggle class.
+ */
+
+GuiToggle::GuiToggle(bool checked, float width, float height)
+    : GuiButton(width, height) {
+    bChanged = false;
+    selected = checked;
+    clicked.connect(this, &GuiToggle::OnToggleClick);
+}
+
+/**
+ * Destructor for the GuiButton class.
+ */
+GuiToggle::~GuiToggle() {
+    bChanged = false;
+    selected = false;
+}
+
+void GuiToggle::OnToggleClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger) {
+    if (!isStateSet(STATE_DISABLED | STATE_HIDDEN | STATE_DISABLE_INPUT)) {
+        if (selected) {
+            setUnchecked();
+        } else {
+            setChecked();
+        }
+    }
+}
+
+void GuiToggle::update(GuiController *c) {
+    GuiButton::update(c);
+}

src/gui/GuiToggle.h

@@ -0,0 +1,64 @@
+/****************************************************************************
+ * Copyright (C) 2016 Maschell
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef GUI_TOGGLE_H_
+#define GUI_TOGGLE_H_
+
+#include <gui/GuiButton.h>
+#include <gui/GuiFrame.h>
+
+//!A simple CheckBox
+class GuiToggle : public GuiButton, public sigslot::has_slots<> {
+public:
+    //!Constructor
+    //!\param checked Checked
+    GuiToggle(bool checked, float width, float height);
+
+    //!Destructor
+    virtual ~GuiToggle();
+
+    void setValue(bool checked) {
+        if (selected != checked) {
+            selected = checked;
+            bChanged = true;
+            valueChanged(this, selected);
+        }
+    }
+
+    void setChecked() {
+        setValue(true);
+    }
+
+    void setUnchecked() {
+        setValue(false);
+    }
+
+    bool getValue() {
+        return selected;
+    }
+
+    sigslot::signal2<GuiToggle *, bool> valueChanged;
+
+    void OnToggleClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger);
+
+protected:
+    bool selected;
+    bool bChanged;
+
+    void update(GuiController *c);
+};
+
+#endif

src/gui/GuiTrigger.cpp

@@ -0,0 +1,143 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <gui/GuiController.h>
+#include <gui/GuiElement.h>
+#include <gui/GuiTrigger.h>
+
+/**
+ * Constructor for the GuiTrigger class.
+ */
+GuiTrigger::GuiTrigger()
+    : chan(CHANNEL_ALL), btns(BUTTON_NONE), bClickEverywhere(false), bHoldEverywhere(false), bSelectionClickEverywhere(false), bLastTouched(false) {
+}
+
+GuiTrigger::GuiTrigger(uint32_t ch, uint32_t btn, bool clickEverywhere, bool holdEverywhere, bool selectionClickEverywhere)
+    : chan(ch), btns(btn), bClickEverywhere(clickEverywhere), bHoldEverywhere(holdEverywhere), bSelectionClickEverywhere(selectionClickEverywhere), bLastTouched(false) {
+}
+
+/**
+ * Destructor for the GuiTrigger class.
+ */
+GuiTrigger::~GuiTrigger() {
+}
+
+/**
+ * Sets a simple trigger. Requires:
+ * - Element is selected
+ * - Trigger button is pressed
+ */
+void GuiTrigger::setTrigger(uint32_t ch, uint32_t btn) {
+    chan = ch;
+    btns = btn;
+}
+
+bool GuiTrigger::left(const GuiController *controller) const {
+    if ((controller->chan & chan) == 0) {
+        return false;
+    }
+    if ((controller->data.buttons_h | controller->data.buttons_d) & (BUTTON_LEFT | STICK_L_LEFT)) {
+        return true;
+    }
+    return false;
+}
+
+bool GuiTrigger::right(const GuiController *controller) const {
+    if ((controller->chan & chan) == 0) {
+        return false;
+    }
+    if ((controller->data.buttons_h | controller->data.buttons_d) & (BUTTON_RIGHT | STICK_L_RIGHT)) {
+        return true;
+    }
+    return false;
+}
+
+bool GuiTrigger::up(const GuiController *controller) const {
+    if ((controller->chan & chan) == 0) {
+        return false;
+    }
+    if ((controller->data.buttons_h | controller->data.buttons_d) & (BUTTON_UP | STICK_L_UP)) {
+        return true;
+    }
+    return false;
+}
+
+bool GuiTrigger::down(const GuiController *controller) const {
+    if ((controller->chan & chan) == 0) {
+        return false;
+    }
+    if ((controller->data.buttons_h | controller->data.buttons_d) & (BUTTON_DOWN | STICK_L_DOWN)) {
+        return true;
+    }
+    return false;
+}
+
+int32_t GuiTrigger::clicked(const GuiController *controller) const {
+    if ((controller->chan & chan) == 0) {
+        return CLICKED_NONE;
+    }
+
+    int32_t bResult = CLICKED_NONE;
+
+    if (controller->data.touched && controller->data.validPointer && (btns & VPAD_TOUCH) && !controller->lastData.touched) {
+        bResult = CLICKED_TOUCH;
+    }
+
+    if (controller->data.buttons_d & btns) {
+        bResult = CLICKED_BUTTON;
+    }
+    return bResult;
+}
+
+bool GuiTrigger::held(const GuiController *controller) const {
+    if ((controller->chan & chan) == 0) {
+        return false;
+    }
+
+    bool bResult = false;
+
+    if (controller->data.touched && (btns & VPAD_TOUCH) && controller->data.validPointer && controller->lastData.touched && controller->lastData.validPointer) {
+        bResult = true;
+    }
+
+    if (controller->data.buttons_h & btns) {
+        bResult = true;
+    }
+
+    return bResult;
+}
+
+bool GuiTrigger::released(const GuiController *controller) const {
+    if ((controller->chan & chan) == 0) {
+        return false;
+    }
+
+    if (clicked(controller) || held(controller)) {
+        return false;
+    }
+
+    bool bResult = false;
+
+    if (!controller->data.touched && (btns & VPAD_TOUCH) && controller->lastData.touched && controller->lastData.validPointer) {
+        bResult = true;
+    }
+
+    if (controller->data.buttons_r & btns) {
+        bResult = true;
+    }
+
+    return bResult;
+}

src/gui/GuiTrigger.h

@@ -0,0 +1,132 @@
+/***************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef GUI_TRIGGER_H_
+#define GUI_TRIGGER_H_
+
+#include <stdint.h>
+
+class GuiController;
+
+//!Menu input trigger management. Determine if action is neccessary based on input data by comparing controller input data to a specific trigger element.
+class GuiTrigger {
+public:
+    enum eClicked {
+        CLICKED_NONE   = 0x00,
+        CLICKED_TOUCH  = 0x01,
+        CLICKED_BUTTON = 0x02,
+    };
+    enum eChannels {
+        CHANNEL_1   = 0x01,
+        CHANNEL_2   = 0x02,
+        CHANNEL_3   = 0x04,
+        CHANNEL_4   = 0x08,
+        CHANNEL_5   = 0x10,
+        CHANNEL_ALL = 0xFF
+    };
+    enum eButtons {
+        BUTTON_NONE   = 0x0000,
+        VPAD_TOUCH    = 0x80000000,
+        BUTTON_Z      = 0x20000,
+        BUTTON_C      = 0x10000,
+        BUTTON_A      = 0x8000,
+        BUTTON_B      = 0x4000,
+        BUTTON_X      = 0x2000,
+        BUTTON_Y      = 0x1000,
+        BUTTON_1      = BUTTON_Y,
+        BUTTON_2      = BUTTON_X,
+        BUTTON_LEFT   = 0x0800,
+        BUTTON_RIGHT  = 0x0400,
+        BUTTON_UP     = 0x0200,
+        BUTTON_DOWN   = 0x0100,
+        BUTTON_ZL     = 0x0080,
+        BUTTON_ZR     = 0x0040,
+        BUTTON_L      = 0x0020,
+        BUTTON_R      = 0x0010,
+        BUTTON_PLUS   = 0x0008,
+        BUTTON_MINUS  = 0x0004,
+        BUTTON_HOME   = 0x0002,
+        BUTTON_SYNC   = 0x0001,
+        STICK_R_LEFT  = 0x04000000,
+        STICK_R_RIGHT = 0x02000000,
+        STICK_R_UP    = 0x01000000,
+        STICK_R_DOWN  = 0x00800000,
+        STICK_L_LEFT  = 0x40000000,
+        STICK_L_RIGHT = 0x20000000,
+        STICK_L_UP    = 0x10000000,
+        STICK_L_DOWN  = 0x08000000
+    };
+
+    //!Constructor
+    GuiTrigger();
+
+    //!Constructor
+    GuiTrigger(uint32_t ch, uint32_t btns, bool clickEverywhere = false, bool holdEverywhere = false, bool selectionClickEverywhere = false);
+
+    //!Destructor
+    virtual ~GuiTrigger();
+
+    //!Sets a simple trigger. Requires: element is selected, and trigger button is pressed
+    void setTrigger(uint32_t ch, uint32_t btns);
+
+    void setClickEverywhere(bool b) {
+        bClickEverywhere = b;
+    }
+
+    void setHoldOnly(bool b) {
+        bHoldEverywhere = b;
+    }
+
+    void setSelectionClickEverywhere(bool b) {
+        bSelectionClickEverywhere = b;
+    }
+
+    bool isClickEverywhere() const {
+        return bClickEverywhere;
+    }
+
+    bool isHoldEverywhere() const {
+        return bHoldEverywhere;
+    }
+
+    bool isSelectionClickEverywhere() const {
+        return bSelectionClickEverywhere;
+    }
+
+    bool left(const GuiController *controller) const;
+
+    bool right(const GuiController *controller) const;
+
+    bool up(const GuiController *controller) const;
+
+    bool down(const GuiController *controller) const;
+
+    int32_t clicked(const GuiController *controller) const;
+
+    bool held(const GuiController *controller) const;
+
+    bool released(const GuiController *controller) const;
+
+private:
+    uint32_t chan;
+    uint32_t btns;
+    bool bClickEverywhere;
+    bool bHoldEverywhere;
+    bool bSelectionClickEverywhere;
+    bool bLastTouched;
+};
+
+#endif

src/gui/VPadController.h

@@ -0,0 +1,63 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef VPAD_CONTROLLER_H_
+#define VPAD_CONTROLLER_H_
+
+#include <gui/GuiController.h>
+#include <vpad/input.h>
+
+class VPadController : public GuiController {
+public:
+    //!Constructor
+    VPadController(int32_t channel)
+        : GuiController(channel) {
+        memset(&vpad, 0, sizeof(vpad));
+    }
+
+    //!Destructor
+    virtual ~VPadController() {}
+
+    bool update(int32_t width, int32_t height) {
+        lastData = data;
+
+        VPADReadError vpadError = VPAD_READ_NO_SAMPLES;
+        VPADRead(VPAD_CHAN_0, &vpad, 1, &vpadError);
+
+        if (vpadError == VPAD_READ_SUCCESS) {
+            data.buttons_r    = vpad.release;
+            data.buttons_h    = vpad.hold;
+            data.buttons_d    = vpad.trigger;
+            data.validPointer = !vpad.tpNormal.validity;
+            data.touched      = vpad.tpNormal.touched;
+
+            VPADGetTPCalibratedPoint(VPAD_CHAN_0, &tpCalib, &vpad.tpFiltered1);
+
+            //! calculate the screen offsets
+            data.x = -(width >> 1) + (int32_t) (((float) tpCalib.x / 1280.0f) * (float) width);
+            data.y = -(height >> 1) + (int32_t) (float) height - (((float) tpCalib.y / 720.0f) * (float) height);
+
+            return true;
+        }
+        return false;
+    }
+
+private:
+    VPADStatus vpad;
+    VPADTouchData tpCalib;
+};
+
+#endif

src/gui/WPadController.h

@@ -0,0 +1,217 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef WPAD_CONTROLLER_H_
+#define WPAD_CONTROLLER_H_
+
+#include <gui/GuiController.h>
+#include <padscore/kpad.h>
+#include <padscore/wpad.h>
+
+class WPadController : public GuiController {
+public:
+    //!Constructor
+    WPadController(int32_t channel)
+        : GuiController(channel) {
+        memset(&kpadData, 0, sizeof(kpadData));
+    }
+
+    //!Destructor
+    virtual ~WPadController() {}
+
+    uint32_t remapWiiMoteButtons(uint32_t buttons) {
+        uint32_t conv_buttons = 0;
+
+        if (buttons & WPAD_BUTTON_LEFT) {
+            conv_buttons |= GuiTrigger::BUTTON_LEFT;
+        }
+
+        if (buttons & WPAD_BUTTON_RIGHT) {
+            conv_buttons |= GuiTrigger::BUTTON_RIGHT;
+        }
+
+        if (buttons & WPAD_BUTTON_DOWN) {
+            conv_buttons |= GuiTrigger::BUTTON_DOWN;
+        }
+
+        if (buttons & WPAD_BUTTON_UP) {
+            conv_buttons |= GuiTrigger::BUTTON_UP;
+        }
+
+        if (buttons & WPAD_BUTTON_PLUS) {
+            conv_buttons |= GuiTrigger::BUTTON_PLUS;
+        }
+
+        if (buttons & WPAD_BUTTON_2) {
+            conv_buttons |= GuiTrigger::BUTTON_2;
+        }
+
+        if (buttons & WPAD_BUTTON_1) {
+            conv_buttons |= GuiTrigger::BUTTON_1;
+        }
+
+        if (buttons & WPAD_BUTTON_B) {
+            conv_buttons |= GuiTrigger::BUTTON_B;
+        }
+
+        if (buttons & WPAD_BUTTON_A) {
+            conv_buttons |= GuiTrigger::BUTTON_A;
+        }
+
+        if (buttons & WPAD_BUTTON_MINUS) {
+            conv_buttons |= GuiTrigger::BUTTON_MINUS;
+        }
+
+        if (buttons & WPAD_BUTTON_Z) {
+            conv_buttons |= GuiTrigger::BUTTON_Z;
+        }
+
+        if (buttons & WPAD_BUTTON_C) {
+            conv_buttons |= GuiTrigger::BUTTON_C;
+        }
+
+        if (buttons & WPAD_BUTTON_HOME) {
+            conv_buttons |= GuiTrigger::BUTTON_HOME;
+        }
+
+        return conv_buttons;
+    }
+
+    uint32_t remapClassicButtons(uint32_t buttons) {
+        uint32_t conv_buttons = 0;
+
+        if (buttons & WPAD_CLASSIC_BUTTON_LEFT) {
+            conv_buttons |= GuiTrigger::BUTTON_LEFT;
+        }
+
+        if (buttons & WPAD_CLASSIC_BUTTON_RIGHT) {
+            conv_buttons |= GuiTrigger::BUTTON_RIGHT;
+        }
+
+        if (buttons & WPAD_CLASSIC_BUTTON_DOWN) {
+            conv_buttons |= GuiTrigger::BUTTON_DOWN;
+        }
+
+        if (buttons & WPAD_CLASSIC_BUTTON_UP) {
+            conv_buttons |= GuiTrigger::BUTTON_UP;
+        }
+
+        if (buttons & WPAD_CLASSIC_BUTTON_PLUS) {
+            conv_buttons |= GuiTrigger::BUTTON_PLUS;
+        }
+
+        if (buttons & WPAD_CLASSIC_BUTTON_X) {
+            conv_buttons |= GuiTrigger::BUTTON_X;
+        }
+
+        if (buttons & WPAD_CLASSIC_BUTTON_Y) {
+            conv_buttons |= GuiTrigger::BUTTON_Y;
+        }
+
+        if (buttons & WPAD_CLASSIC_BUTTON_B) {
+            conv_buttons |= GuiTrigger::BUTTON_B;
+        }
+
+        if (buttons & WPAD_CLASSIC_BUTTON_A) {
+            conv_buttons |= GuiTrigger::BUTTON_A;
+        }
+
+        if (buttons & WPAD_CLASSIC_BUTTON_MINUS) {
+            conv_buttons |= GuiTrigger::BUTTON_MINUS;
+        }
+
+        if (buttons & WPAD_CLASSIC_BUTTON_HOME) {
+            conv_buttons |= GuiTrigger::BUTTON_HOME;
+        }
+
+        if (buttons & WPAD_CLASSIC_BUTTON_ZR) {
+            conv_buttons |= GuiTrigger::BUTTON_ZR;
+        }
+
+        if (buttons & WPAD_CLASSIC_BUTTON_ZL) {
+            conv_buttons |= GuiTrigger::BUTTON_ZL;
+        }
+
+        if (buttons & WPAD_CLASSIC_BUTTON_R) {
+            conv_buttons |= GuiTrigger::BUTTON_R;
+        }
+
+        if (buttons & WPAD_CLASSIC_BUTTON_L) {
+            conv_buttons |= GuiTrigger::BUTTON_L;
+        }
+
+        return conv_buttons;
+    }
+
+    WPADChan getChanByInt(int32_t chan) {
+        if (chan == 0) {
+            return WPAD_CHAN_0;
+        }
+        if (chan == 1) {
+            return WPAD_CHAN_1;
+        }
+        if (chan == 2) {
+            return WPAD_CHAN_3;
+        }
+        if (chan == 3) {
+            return WPAD_CHAN_3;
+        }
+        return WPAD_CHAN_0;
+    }
+
+    bool update(int32_t width, int32_t height) {
+        lastData = data;
+        WPADExtensionType controller_type;
+
+        //! check if the controller is connected
+        if (WPADProbe(getChanByInt(chanIdx - 1), &controller_type) != 0) {
+            return false;
+        }
+
+        KPADRead(getChanByInt(chanIdx - 1), &kpadData, 1);
+
+        if (kpadData.extensionType <= 1) {
+            data.buttons_r = remapWiiMoteButtons(kpadData.release);
+            data.buttons_h = remapWiiMoteButtons(kpadData.hold);
+            data.buttons_d = remapWiiMoteButtons(kpadData.trigger);
+        } else {
+            data.buttons_r = remapClassicButtons(kpadData.classic.release);
+            data.buttons_h = remapClassicButtons(kpadData.classic.hold);
+            data.buttons_d = remapClassicButtons(kpadData.classic.trigger);
+        }
+
+        data.validPointer = (kpadData.posValid == 1 || kpadData.posValid == 2) && (kpadData.pos.x >= -1.0f && kpadData.pos.x <= 1.0f) && (kpadData.pos.y >= -1.0f && kpadData.pos.y <= 1.0f);
+        //! calculate the screen offsets if pointer is valid else leave old value
+        if (data.validPointer) {
+            data.x = (width >> 1) * kpadData.pos.x;
+            data.y = (height >> 1) * (-kpadData.pos.y);
+
+            if (kpadData.angle.y > 0.0f) {
+                data.pointerAngle = (-kpadData.angle.x + 1.0f) * 0.5f * 180.0f;
+            } else {
+                data.pointerAngle = (kpadData.angle.x + 1.0f) * 0.5f * 180.0f - 180.0f;
+            }
+        }
+
+        return true;
+    }
+
+private:
+    KPADStatus kpadData;
+    uint32_t lastButtons;
+};
+
+#endif

src/gui/gx2_ext.h

@@ -0,0 +1,161 @@
+#ifndef __GX2_EXTENSION_H
+#define __GX2_EXTENSION_H
+
+#include <gx2/draw.h>
+#include <gx2/enum.h>
+#include <gx2/mem.h>
+#include <gx2/registers.h>
+#include <gx2/sampler.h>
+#include <gx2/shaders.h>
+#include <gx2/surface.h>
+#include <gx2/texture.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define GX2_AA_BUFFER_CLEAR_VALUE 0xCC
+
+#define GX2_COMP_SEL_NONE         0x04040405
+#define GX2_COMP_SEL_X001         0x00040405
+#define GX2_COMP_SEL_XY01         0x00010405
+#define GX2_COMP_SEL_XYZ1         0x00010205
+#define GX2_COMP_SEL_XYZW         0x00010203
+#define GX2_COMP_SEL_XXXX         0x00000000
+#define GX2_COMP_SEL_YYYY         0x01010101
+#define GX2_COMP_SEL_ZZZZ         0x02020202
+#define GX2_COMP_SEL_WWWW         0x03030303
+#define GX2_COMP_SEL_WZYX         0x03020100
+#define GX2_COMP_SEL_WXYZ         0x03000102
+
+typedef struct _GX2Color {
+    uint8_t r, g, b, a;
+} GX2Color;
+
+typedef struct _GX2ColorF32 {
+    float r, g, b, a;
+} GX2ColorF32;
+
+static const uint32_t attribute_dest_comp_selector[20] = {
+        GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01, GX2_COMP_SEL_X001, GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01, GX2_COMP_SEL_X001,
+        GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01, GX2_COMP_SEL_XY01, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW,
+        GX2_COMP_SEL_XY01, GX2_COMP_SEL_XY01, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_XYZ1,
+        GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW};
+
+static const uint32_t texture_comp_selector[54] = {
+        GX2_COMP_SEL_NONE, GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01, GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_X001,
+        GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW,
+        GX2_COMP_SEL_WZYX, GX2_COMP_SEL_X001, GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01, GX2_COMP_SEL_XY01, GX2_COMP_SEL_NONE,
+        GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_NONE,
+        GX2_COMP_SEL_NONE, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_WZYX, GX2_COMP_SEL_XY01, GX2_COMP_SEL_XY01,
+        GX2_COMP_SEL_XY01, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_NONE, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW,
+        GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_X001,
+        GX2_COMP_SEL_XY01, GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_NONE, GX2_COMP_SEL_XYZ1,
+        GX2_COMP_SEL_XYZ1, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_XYZW, GX2_COMP_SEL_X001, GX2_COMP_SEL_XY01};
+
+static inline void GX2InitDepthBuffer(GX2DepthBuffer *depthBuffer, GX2SurfaceDim dim, uint32_t width, uint32_t height, uint32_t depth, GX2SurfaceFormat format, GX2AAMode aa) {
+    depthBuffer->surface.dim       = dim;
+    depthBuffer->surface.width     = width;
+    depthBuffer->surface.height    = height;
+    depthBuffer->surface.depth     = depth;
+    depthBuffer->surface.mipLevels = 1;
+    depthBuffer->surface.format    = format;
+    depthBuffer->surface.aa        = aa;
+    depthBuffer->surface.use       = (GX2SurfaceUse) (((format == GX2_SURFACE_FORMAT_UNORM_R24_X8) || (format == GX2_SURFACE_FORMAT_FLOAT_D24_S8)) ? GX2_SURFACE_USE_DEPTH_BUFFER : (GX2_SURFACE_USE_DEPTH_BUFFER | GX2_SURFACE_USE_TEXTURE));
+    depthBuffer->surface.tileMode  = GX2_TILE_MODE_DEFAULT;
+    depthBuffer->surface.swizzle   = 0;
+    depthBuffer->viewMip           = 0;
+    depthBuffer->viewFirstSlice    = 0;
+    depthBuffer->viewNumSlices     = depth;
+    depthBuffer->depthClear        = 1.0f;
+    depthBuffer->stencilClear      = 0;
+    depthBuffer->hiZPtr            = NULL;
+    depthBuffer->hiZSize           = 0;
+    GX2CalcSurfaceSizeAndAlignment(&depthBuffer->surface);
+    GX2InitDepthBufferRegs(depthBuffer);
+}
+
+static inline void GX2InitColorBuffer(GX2ColorBuffer *colorBuffer, GX2SurfaceDim dim, uint32_t width, uint32_t height, uint32_t depth, GX2SurfaceFormat format, GX2AAMode aa) {
+    colorBuffer->surface.dim        = dim;
+    colorBuffer->surface.width      = width;
+    colorBuffer->surface.height     = height;
+    colorBuffer->surface.depth      = depth;
+    colorBuffer->surface.mipLevels  = 1;
+    colorBuffer->surface.format     = format;
+    colorBuffer->surface.aa         = aa;
+    colorBuffer->surface.use        = GX2_SURFACE_USE_TEXTURE_COLOR_BUFFER_TV;
+    colorBuffer->surface.imageSize  = 0;
+    colorBuffer->surface.image      = NULL;
+    colorBuffer->surface.mipmapSize = 0;
+    colorBuffer->surface.mipmaps    = NULL;
+    colorBuffer->surface.tileMode   = GX2_TILE_MODE_DEFAULT;
+    colorBuffer->surface.swizzle    = 0;
+    colorBuffer->surface.alignment  = 0;
+    colorBuffer->surface.pitch      = 0;
+    uint32_t i;
+    for (i = 0; i < 13; i++) {
+        colorBuffer->surface.mipLevelOffset[i] = 0;
+    }
+    colorBuffer->viewMip        = 0;
+    colorBuffer->viewFirstSlice = 0;
+    colorBuffer->viewNumSlices  = depth;
+    colorBuffer->aaBuffer       = NULL;
+    colorBuffer->aaSize         = 0;
+    for (i = 0; i < 5; i++) {
+        colorBuffer->regs[i] = 0;
+    }
+
+    GX2CalcSurfaceSizeAndAlignment(&colorBuffer->surface);
+    GX2InitColorBufferRegs(colorBuffer);
+}
+
+static inline void GX2InitAttribStream(GX2AttribStream *attr, uint32_t location, uint32_t buffer, uint32_t offset, GX2AttribFormat format) {
+    attr->location   = location;
+    attr->buffer     = buffer;
+    attr->offset     = offset;
+    attr->format     = format;
+    attr->type       = GX2_ATTRIB_INDEX_PER_VERTEX;
+    attr->aluDivisor = 0;
+    attr->mask       = attribute_dest_comp_selector[format & 0xff];
+    attr->endianSwap = GX2_ENDIAN_SWAP_DEFAULT;
+}
+
+static inline void GX2InitTexture(GX2Texture *tex, uint32_t width, uint32_t height, uint32_t depth, uint32_t mipLevels, GX2SurfaceFormat format, GX2SurfaceDim dim, GX2TileMode tile) {
+    tex->surface.dim        = dim;
+    tex->surface.width      = width;
+    tex->surface.height     = height;
+    tex->surface.depth      = depth;
+    tex->surface.mipLevels  = mipLevels;
+    tex->surface.format     = format;
+    tex->surface.aa         = GX2_AA_MODE1X;
+    tex->surface.use        = GX2_SURFACE_USE_TEXTURE;
+    tex->surface.imageSize  = 0;
+    tex->surface.image      = NULL;
+    tex->surface.mipmapSize = 0;
+    tex->surface.mipmaps    = NULL;
+    tex->surface.tileMode   = tile;
+    tex->surface.swizzle    = 0;
+    tex->surface.alignment  = 0;
+    tex->surface.pitch      = 0;
+    uint32_t i;
+    for (i = 0; i < 13; i++) {
+        tex->surface.mipLevelOffset[i] = 0;
+    }
+    tex->viewFirstMip   = 0;
+    tex->viewNumMips    = mipLevels;
+    tex->viewFirstSlice = 0;
+    tex->viewNumSlices  = depth;
+    tex->compMap        = texture_comp_selector[format & 0x3f];
+    for (i = 0; i < 5; i++) {
+        tex->regs[i] = 0;
+    }
+
+    GX2CalcSurfaceSizeAndAlignment(&tex->surface);
+    GX2InitTextureRegs(tex);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/menu/GameSplashScreen.h

@@ -8,11 +8,11 @@ class GameSplashScreen : public GuiFrame, public sigslot::has_slots<> {
 public:
     GameSplashScreen(int32_t w, int32_t h, gameInfo *info, bool onTV);
 
-    virtual ~GameSplashScreen();
+    ~GameSplashScreen() override;
 
     void OnSplashScreenFadeInDone(GuiElement *element);
 
-    virtual void draw(CVideo *v);
+    void draw(CVideo *v) override;
 
     sigslot::signal3<GuiElement *, gameInfo *, bool> gameGameSplashScreenFinished;
 private:

src/menu/MainWindow.cpp

@@ -403,10 +403,6 @@ void MainWindow::OnGameLaunchSplashScreenFinished(GuiElement *element, gameInfo
     }
 }
 
-extern "C" int32_t SYSSwitchToBrowser(void *);
-extern "C" int32_t SYSSwitchToEShop(void *);
-extern "C" int32_t _SYSSwitchTo(uint32_t pfid);
-
 void MainWindow::OnGameLaunch(uint64_t titleId) {
     DEBUG_FUNCTION_LINE("Launch GAME!!");
 
@@ -422,6 +418,7 @@ void MainWindow::OnGameLaunch(uint64_t titleId) {
         titleId == 0x000500301001200AL) {
         DEBUG_FUNCTION_LINE("Launching the browser");
         SYSSwitchToBrowser(nullptr);
+
         return;
     }
     if (titleId == 0x000500301001400AL ||
@@ -436,28 +433,28 @@ void MainWindow::OnGameLaunch(uint64_t titleId) {
         titleId == 0x000500301001810AL ||
         titleId == 0x000500301001820AL) {
         DEBUG_FUNCTION_LINE("Launching the Download Management");
-        _SYSSwitchTo(12);
+        _SYSSwitchTo(SYSAPP_PFID_DOWNLOAD_MANAGEMENT);
         return;
     }
     if (titleId == 0x000500301001600AL ||
         titleId == 0x000500301001610AL ||
         titleId == 0x000500301001620AL) {
         DEBUG_FUNCTION_LINE("Launching Miiverse");
-        _SYSSwitchTo(9);
+        _SYSSwitchTo(SYSAPP_PFID_MIIVERSE);
         return;
     }
     if (titleId == 0x000500301001500AL ||
         titleId == 0x000500301001510AL ||
         titleId == 0x000500301001520AL) {
         DEBUG_FUNCTION_LINE("Launching Friendlist");
-        _SYSSwitchTo(11);
+        _SYSSwitchTo(SYSAPP_PFID_FRIENDLIST);
         return;
     }
     if (titleId == 0x000500301001300AL ||
         titleId == 0x000500301001310AL ||
         titleId == 0x000500301001320AL) {
         DEBUG_FUNCTION_LINE("Launching TVii");
-        _SYSSwitchTo(3);
+        _SYSSwitchTo(SYSAPP_PFID_TVII);
         return;
     }
 
@@ -467,7 +464,7 @@ void MainWindow::OnGameLaunch(uint64_t titleId) {
     MCP_Close(handle);
     if (err == 0) {
         ACPAssignTitlePatch(&titleInfo);
-        _SYSLaunchTitleWithStdArgsInNoSplash(titleId, nullptr);
+        _SYSLaunchTitleByPathFromLauncher(titleInfo.path, strlen(titleInfo.path));
         return;
     }
 

src/sounds/BufferCircle.cpp

@@ -0,0 +1,136 @@
+/***************************************************************************
+ * Copyright (C) 2010
+ * by Dimok
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any
+ * damages arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any
+ * purpose, including commercial applications, and to alter it and
+ * redistribute it freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you
+ * must not claim that you wrote the original software. If you use
+ * this software in a product, an acknowledgment in the product
+ * documentation would be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and
+ * must not be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+ *
+ * for WiiXplorer 2010
+ ***************************************************************************/
+#include <sounds/BufferCircle.hpp>
+#include <malloc.h>
+#include <utils/utils.h>
+
+BufferCircle::BufferCircle() {
+    which           = 0;
+    BufferBlockSize = 0;
+}
+
+BufferCircle::~BufferCircle() {
+    FreeBuffer();
+    SoundBuffer.clear();
+    BufferSize.clear();
+    BufferReady.clear();
+}
+
+void BufferCircle::SetBufferBlockSize(int32_t size) {
+    if (size < 0) {
+        return;
+    }
+
+    BufferBlockSize = size;
+
+    for (int32_t i = 0; i < Size(); i++) {
+        if (SoundBuffer[i] != NULL) {
+            free(SoundBuffer[i]);
+        }
+
+        SoundBuffer[i] = (uint8_t *) memalign(32, ALIGN32(BufferBlockSize));
+        BufferSize[i]  = 0;
+        BufferReady[i] = false;
+    }
+}
+
+void BufferCircle::Resize(int32_t size) {
+    while (size < Size())
+        RemoveBuffer(Size() - 1);
+
+    int32_t oldSize = Size();
+
+    SoundBuffer.resize(size);
+    BufferSize.resize(size);
+    BufferReady.resize(size);
+
+    for (int32_t i = oldSize; i < Size(); i++) {
+        if (BufferBlockSize > 0) {
+            SoundBuffer[i] = (uint8_t *) memalign(32, ALIGN32(BufferBlockSize));
+        } else {
+            SoundBuffer[i] = NULL;
+        }
+        BufferSize[i]  = 0;
+        BufferReady[i] = false;
+    }
+}
+
+void BufferCircle::RemoveBuffer(int32_t pos) {
+    if (!Valid(pos)) {
+        return;
+    }
+
+    if (SoundBuffer[pos] != NULL) {
+        free(SoundBuffer[pos]);
+    }
+
+    SoundBuffer.erase(SoundBuffer.begin() + pos);
+    BufferSize.erase(BufferSize.begin() + pos);
+    BufferReady.erase(BufferReady.begin() + pos);
+}
+
+void BufferCircle::ClearBuffer() {
+    for (int32_t i = 0; i < Size(); i++) {
+        BufferSize[i]  = 0;
+        BufferReady[i] = false;
+    }
+    which = 0;
+}
+
+void BufferCircle::FreeBuffer() {
+    for (int32_t i = 0; i < Size(); i++) {
+        if (SoundBuffer[i] != NULL) {
+            free(SoundBuffer[i]);
+        }
+
+        SoundBuffer[i] = NULL;
+        BufferSize[i]  = 0;
+        BufferReady[i] = false;
+    }
+}
+
+void BufferCircle::LoadNext() {
+    BufferReady[which] = false;
+    BufferSize[which]  = 0;
+
+    which = Next();
+}
+
+void BufferCircle::SetBufferReady(int32_t pos, bool state) {
+    if (!Valid(pos)) {
+        return;
+    }
+
+    BufferReady[pos] = state;
+}
+
+void BufferCircle::SetBufferSize(int32_t pos, int32_t size) {
+    if (!Valid(pos)) {
+        return;
+    }
+
+    BufferSize[pos] = size;
+}

src/sounds/BufferCircle.hpp

@@ -0,0 +1,143 @@
+/***************************************************************************
+ * Copyright (C) 2010
+ * by Dimok
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any
+ * damages arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any
+ * purpose, including commercial applications, and to alter it and
+ * redistribute it freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you
+ * must not claim that you wrote the original software. If you use
+ * this software in a product, an acknowledgment in the product
+ * documentation would be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and
+ * must not be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+ *
+ * for WiiXplorer 2010
+ ***************************************************************************/
+#ifndef BUFFER_CIRCLE_HPP_
+#define BUFFER_CIRCLE_HPP_
+
+#include <cstddef>
+#include <stdint.h>
+#include <vector>
+
+class BufferCircle {
+public:
+    //!> Constructor
+    BufferCircle();
+
+    //!> Destructor
+    ~BufferCircle();
+
+    //!> Set circle size
+    void Resize(int32_t size);
+
+    //!> Get the circle size
+    int32_t Size() {
+        return SoundBuffer.size();
+    };
+
+    //!> Set/resize the buffer size
+    void SetBufferBlockSize(int32_t size);
+
+    //!> Remove a buffer
+    void RemoveBuffer(int32_t pos);
+
+    //!> Set all buffers clear
+    void ClearBuffer();
+
+    //!> Free all buffers
+    void FreeBuffer();
+
+    //!> Switch to next buffer
+    void LoadNext();
+
+    //!> Get the current buffer
+    uint8_t *GetBuffer() {
+        return GetBuffer(which);
+    };
+
+    //!> Get a buffer at a position
+    uint8_t *GetBuffer(int32_t pos) {
+        if (!Valid(pos)) {
+            return NULL;
+        } else {
+            return SoundBuffer[pos];
+        }
+    };
+
+    //!> Get current buffer size
+    uint32_t GetBufferSize() {
+        return GetBufferSize(which);
+    };
+
+    //!> Get buffer size at position
+    uint32_t GetBufferSize(int32_t pos) {
+        if (!Valid(pos)) {
+            return 0;
+        } else {
+            return BufferSize[pos];
+        }
+    };
+
+    //!> Is current buffer ready
+    bool IsBufferReady() {
+        return IsBufferReady(which);
+    };
+
+    //!> Is  a buffer at a position ready
+    bool IsBufferReady(int32_t pos) {
+        if (!Valid(pos)) {
+            return false;
+        } else {
+            return BufferReady[pos];
+        }
+    };
+
+    //!> Set a buffer at a position to a ready state
+    void SetBufferReady(int32_t pos, bool st);
+
+    //!> Set the buffersize at a position
+    void SetBufferSize(int32_t pos, int32_t size);
+
+    //!> Get the current position in the circle
+    uint16_t Which() {
+        return which;
+    };
+
+    //!> Get the next location
+    inline uint16_t Next() {
+        return (which + 1 >= Size()) ? 0 : which + 1;
+    }
+
+    inline uint16_t Prev() {
+        if (Size() == 0) {
+            return 0;
+        } else {
+            return ((int32_t) which - 1 < 0) ? Size() - 1 : which - 1;
+        }
+    }
+
+protected:
+    //!> Check if the position is a valid position in the vector
+    bool Valid(int32_t pos) {
+        return !(pos < 0 || pos >= Size());
+    };
+
+    uint16_t which;
+    uint32_t BufferBlockSize;
+    std::vector<uint8_t *> SoundBuffer;
+    std::vector<uint32_t> BufferSize;
+    std::vector<bool> BufferReady;
+};
+
+#endif

src/sounds/Mp3Decoder.cpp

@@ -0,0 +1,213 @@
+/***************************************************************************
+ * Copyright (C) 2010
+ * by Dimok
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any
+ * damages arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any
+ * purpose, including commercial applications, and to alter it and
+ * redistribute it freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you
+ * must not claim that you wrote the original software. If you use
+ * this software in a product, an acknowledgment in the product
+ * documentation would be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and
+ * must not be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+ *
+ * for WiiXplorer 2010
+ ***************************************************************************/
+#include "fs/CFile.hpp"
+#include <coreinit/thread.h>
+#include <coreinit/time.h>
+#include <sounds/Mp3Decoder.hpp>
+#include <limits.h>
+#include <malloc.h>
+#include <math.h>
+#include <string.h>
+#include <string>
+#include <unistd.h>
+
+Mp3Decoder::Mp3Decoder(const char *filepath)
+    : SoundDecoder(filepath) {
+    SoundType  = SOUND_MP3;
+    ReadBuffer = NULL;
+    mad_timer_reset(&Timer);
+    mad_stream_init(&Stream);
+    mad_frame_init(&Frame);
+    mad_synth_init(&Synth);
+
+    if (!file_fd) {
+        return;
+    }
+
+    OpenFile();
+}
+
+Mp3Decoder::Mp3Decoder(const uint8_t *snd, int32_t len)
+    : SoundDecoder(snd, len) {
+    SoundType  = SOUND_MP3;
+    ReadBuffer = NULL;
+    mad_timer_reset(&Timer);
+    mad_stream_init(&Stream);
+    mad_frame_init(&Frame);
+    mad_synth_init(&Synth);
+
+    if (!file_fd) {
+        return;
+    }
+
+    OpenFile();
+}
+
+Mp3Decoder::~Mp3Decoder() {
+    ExitRequested = true;
+    while (Decoding)
+        OSSleepTicks(OSMicrosecondsToTicks(100));
+
+    mad_synth_finish(&Synth);
+    mad_frame_finish(&Frame);
+    mad_stream_finish(&Stream);
+
+    if (ReadBuffer) {
+        free(ReadBuffer);
+    }
+    ReadBuffer = NULL;
+}
+
+void Mp3Decoder::OpenFile() {
+    GuardPtr   = NULL;
+    ReadBuffer = (uint8_t *) memalign(32, SoundBlockSize * SoundBlocks);
+    if (!ReadBuffer) {
+        if (file_fd) {
+            delete file_fd;
+        }
+        file_fd = NULL;
+        return;
+    }
+
+    uint8_t dummybuff[4096];
+    int32_t ret = Read(dummybuff, 4096, 0);
+    if (ret <= 0) {
+        if (file_fd) {
+            delete file_fd;
+        }
+        file_fd = NULL;
+        return;
+    }
+
+    SampleRate = (uint32_t) Frame.header.samplerate;
+    Format     = ((MAD_NCHANNELS(&Frame.header) == 2) ? (FORMAT_PCM_16_BIT | CHANNELS_STEREO) : (FORMAT_PCM_16_BIT | CHANNELS_MONO));
+    Rewind();
+}
+
+int32_t Mp3Decoder::Rewind() {
+    mad_synth_finish(&Synth);
+    mad_frame_finish(&Frame);
+    mad_stream_finish(&Stream);
+    mad_timer_reset(&Timer);
+    mad_stream_init(&Stream);
+    mad_frame_init(&Frame);
+    mad_synth_init(&Synth);
+    SynthPos = 0;
+    GuardPtr = NULL;
+
+    if (!file_fd) {
+        return -1;
+    }
+
+    return SoundDecoder::Rewind();
+}
+
+static inline int16_t FixedToShort(mad_fixed_t Fixed) {
+    /* Clipping */
+    if (Fixed >= MAD_F_ONE) {
+        return (SHRT_MAX);
+    }
+    if (Fixed <= -MAD_F_ONE) {
+        return (-SHRT_MAX);
+    }
+
+    Fixed = Fixed >> (MAD_F_FRACBITS - 15);
+    return ((int16_t) Fixed);
+}
+
+int32_t Mp3Decoder::Read(uint8_t *buffer, int32_t buffer_size, int32_t pos) {
+    if (!file_fd) {
+        return -1;
+    }
+
+    if (Format == (FORMAT_PCM_16_BIT | CHANNELS_STEREO)) {
+        buffer_size &= ~0x0003;
+    } else {
+        buffer_size &= ~0x0001;
+    }
+
+    uint8_t *write_pos = buffer;
+    uint8_t *write_end = buffer + buffer_size;
+
+    while (1) {
+        while (SynthPos < Synth.pcm.length) {
+            if (write_pos >= write_end) {
+                return write_pos - buffer;
+            }
+
+            *((int16_t *) write_pos) = FixedToShort(Synth.pcm.samples[0][SynthPos]);
+            write_pos += 2;
+
+            if (MAD_NCHANNELS(&Frame.header) == 2) {
+                *((int16_t *) write_pos) = FixedToShort(Synth.pcm.samples[1][SynthPos]);
+                write_pos += 2;
+            }
+            SynthPos++;
+        }
+
+        if (Stream.buffer == NULL || Stream.error == MAD_ERROR_BUFLEN) {
+            uint8_t *ReadStart = ReadBuffer;
+            int32_t ReadSize   = SoundBlockSize * SoundBlocks;
+            int32_t Remaining  = 0;
+
+            if (Stream.next_frame != NULL) {
+                Remaining = Stream.bufend - Stream.next_frame;
+                memmove(ReadBuffer, Stream.next_frame, Remaining);
+                ReadStart += Remaining;
+                ReadSize -= Remaining;
+            }
+
+            ReadSize = file_fd->read(ReadStart, ReadSize);
+            if (ReadSize <= 0) {
+                GuardPtr = ReadStart;
+                memset(GuardPtr, 0, MAD_BUFFER_GUARD);
+                ReadSize = MAD_BUFFER_GUARD;
+            }
+
+            CurPos += ReadSize;
+            mad_stream_buffer(&Stream, ReadBuffer, Remaining + ReadSize);
+        }
+
+        if (mad_frame_decode(&Frame, &Stream)) {
+            if (MAD_RECOVERABLE(Stream.error)) {
+                if (Stream.error != MAD_ERROR_LOSTSYNC || !GuardPtr) {
+                    continue;
+                }
+            } else {
+                if (Stream.error != MAD_ERROR_BUFLEN) {
+                    return -1;
+                } else if (Stream.error == MAD_ERROR_BUFLEN && GuardPtr) {
+                    return -1;
+                }
+            }
+        }
+
+        mad_timer_add(&Timer, Frame.header.duration);
+        mad_synth_frame(&Synth, &Frame);
+        SynthPos = 0;
+    }
+    return 0;
+}

src/sounds/Mp3Decoder.hpp

@@ -0,0 +1,52 @@
+/***************************************************************************
+ * Copyright (C) 2010
+ * by Dimok
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any
+ * damages arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any
+ * purpose, including commercial applications, and to alter it and
+ * redistribute it freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you
+ * must not claim that you wrote the original software. If you use
+ * this software in a product, an acknowledgment in the product
+ * documentation would be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and
+ * must not be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+ *
+ * for WiiXplorer 2010
+ ***************************************************************************/
+#include <mad.h>
+
+#include <sounds/SoundDecoder.hpp>
+
+class Mp3Decoder : public SoundDecoder {
+public:
+    Mp3Decoder(const char *filepath);
+
+    Mp3Decoder(const uint8_t *sound, int32_t len);
+
+    virtual ~Mp3Decoder();
+
+    int32_t Rewind();
+
+    int32_t Read(uint8_t *buffer, int32_t buffer_size, int32_t pos);
+
+protected:
+    void OpenFile();
+
+    struct mad_stream Stream;
+    struct mad_frame Frame;
+    struct mad_synth Synth;
+    mad_timer_t Timer;
+    uint8_t *GuardPtr;
+    uint8_t *ReadBuffer;
+    uint32_t SynthPos;
+};

src/sounds/OggDecoder.cpp

@@ -0,0 +1,133 @@
+/***************************************************************************
+ * Copyright (C) 2010
+ * by Dimok
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any
+ * damages arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any
+ * purpose, including commercial applications, and to alter it and
+ * redistribute it freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you
+ * must not claim that you wrote the original software. If you use
+ * this software in a product, an acknowledgment in the product
+ * documentation would be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and
+ * must not be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+ *
+ * for WiiXplorer 2010
+ ***************************************************************************/
+#include "fs/CFile.hpp"
+#include <coreinit/thread.h>
+#include <coreinit/time.h>
+#include <sounds/OggDecoder.hpp>
+#include <malloc.h>
+#include <unistd.h>
+
+static int ogg_read(void *punt, int bytes, int blocks, int *f) {
+    return ((CFile *) f)->read((uint8_t *) punt, bytes * blocks);
+}
+
+static int ogg_seek(int *f, ogg_int64_t offset, int mode) {
+    return ((CFile *) f)->seek((uint64_t) offset, mode);
+}
+
+static int ogg_close(int *f) {
+    ((CFile *) f)->close();
+    return 0;
+}
+
+static long ogg_tell(int *f) {
+    return (long) ((CFile *) f)->tell();
+}
+
+static ov_callbacks callbacks = {
+        (size_t(*)(void *, size_t, size_t, void *)) ogg_read,
+        (int (*)(void *, ogg_int64_t, int)) ogg_seek,
+        (int (*)(void *)) ogg_close,
+        (long (*)(void *)) ogg_tell};
+
+OggDecoder::OggDecoder(const char *filepath)
+    : SoundDecoder(filepath) {
+    SoundType = SOUND_OGG;
+
+    if (!file_fd) {
+        return;
+    }
+
+    OpenFile();
+}
+
+OggDecoder::OggDecoder(const uint8_t *snd, int32_t len)
+    : SoundDecoder(snd, len) {
+    SoundType = SOUND_OGG;
+
+    if (!file_fd) {
+        return;
+    }
+
+    OpenFile();
+}
+
+OggDecoder::~OggDecoder() {
+    ExitRequested = true;
+    while (Decoding)
+        OSSleepTicks(OSMicrosecondsToTicks(100));
+
+    if (file_fd) {
+        ov_clear(&ogg_file);
+    }
+}
+
+void OggDecoder::OpenFile() {
+    if (ov_open_callbacks(file_fd, &ogg_file, NULL, 0, callbacks) < 0) {
+        delete file_fd;
+        file_fd = NULL;
+        return;
+    }
+
+    ogg_info = ov_info(&ogg_file, -1);
+    if (!ogg_info) {
+        ov_clear(&ogg_file);
+        delete file_fd;
+        file_fd = NULL;
+        return;
+    }
+
+    Format     = ((ogg_info->channels == 2) ? (FORMAT_PCM_16_BIT | CHANNELS_STEREO) : (FORMAT_PCM_16_BIT | CHANNELS_MONO));
+    SampleRate = ogg_info->rate;
+}
+
+int32_t OggDecoder::Rewind() {
+    if (!file_fd) {
+        return -1;
+    }
+
+    int32_t ret = ov_time_seek(&ogg_file, 0);
+    CurPos      = 0;
+    EndOfFile   = false;
+
+    return ret;
+}
+
+int32_t OggDecoder::Read(uint8_t *buffer, int32_t buffer_size, int32_t pos) {
+    if (!file_fd) {
+        return -1;
+    }
+
+    int32_t bitstream = 0;
+
+    int32_t read = (int32_t) ov_read(&ogg_file, (char *) buffer, (int) buffer_size, (int *) &bitstream);
+
+    if (read > 0) {
+        CurPos += read;
+    }
+
+    return read;
+}

src/sounds/OggDecoder.hpp

@@ -0,0 +1,48 @@
+/***************************************************************************
+ * Copyright (C) 2010
+ * by Dimok
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any
+ * damages arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any
+ * purpose, including commercial applications, and to alter it and
+ * redistribute it freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you
+ * must not claim that you wrote the original software. If you use
+ * this software in a product, an acknowledgment in the product
+ * documentation would be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and
+ * must not be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+ *
+ * for WiiXplorer 2010
+ ***************************************************************************/
+#include <tremor/ivorbiscodec.h>
+#include <tremor/ivorbisfile.h>
+
+#include <sounds/SoundDecoder.hpp>
+
+class OggDecoder : public SoundDecoder {
+public:
+    OggDecoder(const char *filepath);
+
+    OggDecoder(const uint8_t *snd, int32_t len);
+
+    virtual ~OggDecoder();
+
+    int32_t Rewind();
+
+    int32_t Read(uint8_t *buffer, int32_t buffer_size, int32_t pos);
+
+protected:
+    void OpenFile();
+
+    OggVorbis_File ogg_file;
+    vorbis_info *ogg_info;
+};

src/sounds/SoundDecoder.cpp

@@ -0,0 +1,211 @@
+/****************************************************************************
+ * Copyright (C) 2009-2013 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+
+#include "fs/CFile.hpp"
+#include <coreinit/cache.h>
+#include <coreinit/thread.h>
+#include <coreinit/time.h>
+#include <sounds/SoundDecoder.hpp>
+#include <malloc.h>
+#include <string.h>
+#include <unistd.h>
+
+static const uint32_t FixedPointShift = 15;
+static const uint32_t FixedPointScale = 1 << FixedPointShift;
+
+SoundDecoder::SoundDecoder() {
+    file_fd = NULL;
+    Init();
+}
+
+SoundDecoder::SoundDecoder(const std::string &filepath) {
+    file_fd = new CFile(filepath, CFile::ReadOnly);
+    Init();
+}
+
+SoundDecoder::SoundDecoder(const uint8_t *buffer, int32_t size) {
+    file_fd = new CFile(buffer, size);
+    Init();
+}
+
+SoundDecoder::~SoundDecoder() {
+    ExitRequested = true;
+    while (Decoding)
+        OSSleepTicks(OSMicrosecondsToTicks(1000));
+
+    //! lock unlock once to make sure it's really not decoding
+    Lock();
+    Unlock();
+
+    if (file_fd) {
+        delete file_fd;
+    }
+    file_fd = NULL;
+
+    if (ResampleBuffer) {
+        free(ResampleBuffer);
+    }
+}
+
+int32_t SoundDecoder::Seek(int32_t pos) {
+    CurPos = pos;
+    return file_fd->seek(CurPos, SEEK_SET);
+}
+
+void SoundDecoder::Init() {
+    SoundType       = SOUND_RAW;
+    SoundBlocks     = 8;
+    SoundBlockSize  = 0x4000;
+    ResampleTo48kHz = false;
+    CurPos          = 0;
+    whichLoad       = 0;
+    Loop            = false;
+    EndOfFile       = false;
+    Decoding        = false;
+    ExitRequested   = false;
+    SoundBuffer.SetBufferBlockSize(SoundBlockSize);
+    SoundBuffer.Resize(SoundBlocks);
+    ResampleBuffer = NULL;
+    ResampleRatio  = 0;
+}
+
+int32_t SoundDecoder::Rewind() {
+    CurPos    = 0;
+    EndOfFile = false;
+    file_fd->rewind();
+
+    return 0;
+}
+
+int32_t SoundDecoder::Read(uint8_t *buffer, int32_t buffer_size, int32_t pos) {
+    int32_t ret = file_fd->read(buffer, buffer_size);
+    CurPos += ret;
+
+    return ret;
+}
+
+void SoundDecoder::EnableUpsample(void) {
+    if ((ResampleBuffer == NULL) && IsStereo() && Is16Bit() && SampleRate != 32000 && SampleRate != 48000) {
+        ResampleBuffer = (uint8_t *) memalign(32, SoundBlockSize);
+        ResampleRatio  = (FixedPointScale * SampleRate) / 48000;
+        SoundBlockSize = (SoundBlockSize * ResampleRatio) / FixedPointScale;
+        SoundBlockSize &= ~0x03;
+        // set new sample rate
+        SampleRate = 48000;
+    }
+}
+
+void SoundDecoder::Upsample(int16_t *src, int16_t *dst, uint32_t nr_src_samples, uint32_t nr_dst_samples) {
+    int32_t timer = 0;
+
+    for (uint32_t i = 0, n = 0; i < nr_dst_samples; i += 2) {
+        if ((n + 3) < nr_src_samples) {
+            // simple fixed point linear interpolation
+            dst[i]     = src[n] + (((src[n + 2] - src[n]) * timer) >> FixedPointShift);
+            dst[i + 1] = src[n + 1] + (((src[n + 3] - src[n + 1]) * timer) >> FixedPointShift);
+        } else {
+            dst[i]     = src[n];
+            dst[i + 1] = src[n + 1];
+        }
+
+        timer += ResampleRatio;
+
+        if (timer >= (int32_t) FixedPointScale) {
+            n += 2;
+            timer -= FixedPointScale;
+        }
+    }
+}
+
+void SoundDecoder::Decode() {
+    if (!file_fd || ExitRequested || EndOfFile) {
+        return;
+    }
+
+    // check if we are not at the pre-last buffer (last buffer is playing)
+    uint16_t whichPlaying = SoundBuffer.Which();
+    if (((whichPlaying == 0) && (whichLoad == SoundBuffer.Size() - 2)) || ((whichPlaying == 1) && (whichLoad == SoundBuffer.Size() - 1)) || (whichLoad == (whichPlaying - 2))) {
+        return;
+    }
+
+    Decoding = true;
+
+    int32_t done       = 0;
+    uint8_t *write_buf = SoundBuffer.GetBuffer(whichLoad);
+    if (!write_buf) {
+        ExitRequested = true;
+        Decoding      = false;
+        return;
+    }
+
+    if (ResampleTo48kHz && !ResampleBuffer) {
+        EnableUpsample();
+    }
+
+    while (done < SoundBlockSize) {
+        int32_t ret = Read(&write_buf[done], SoundBlockSize - done, Tell());
+
+        if (ret <= 0) {
+            if (Loop) {
+                Rewind();
+                continue;
+            } else {
+                EndOfFile = true;
+                break;
+            }
+        }
+
+        done += ret;
+    }
+
+    if (done > 0) {
+        // check if we need to resample
+        if (ResampleBuffer && ResampleRatio) {
+            memcpy(ResampleBuffer, write_buf, done);
+
+            int32_t src_samples  = done >> 1;
+            int32_t dest_samples = (src_samples * FixedPointScale) / ResampleRatio;
+            dest_samples &= ~0x01;
+            Upsample((int16_t *) ResampleBuffer, (int16_t *) write_buf, src_samples, dest_samples);
+            done = dest_samples << 1;
+        }
+
+        //! TODO: remove this later and add STEREO support with two voices, for now we convert to MONO
+        if (IsStereo()) {
+            int16_t *monoBuf = (int16_t *) write_buf;
+            done             = done >> 1;
+
+            for (int32_t i = 0; i < done; i++) {
+                monoBuf[i] = monoBuf[i << 1];
+            }
+        }
+
+        DCFlushRange(write_buf, done);
+        SoundBuffer.SetBufferSize(whichLoad, done);
+        SoundBuffer.SetBufferReady(whichLoad, true);
+        if (++whichLoad >= SoundBuffer.Size()) {
+            whichLoad = 0;
+        }
+    }
+
+    // check if next in queue needs to be filled as well and do so
+    if (!SoundBuffer.IsBufferReady(whichLoad)) {
+        Decode();
+    }
+
+    Decoding = false;
+}

src/sounds/SoundDecoder.hpp

@@ -0,0 +1,162 @@
+/***************************************************************************
+ * Copyright (C) 2010
+ * by Dimok
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any
+ * damages arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any
+ * purpose, including commercial applications, and to alter it and
+ * redistribute it freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you
+ * must not claim that you wrote the original software. If you use
+ * this software in a product, an acknowledgment in the product
+ * documentation would be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and
+ * must not be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+ *
+ * for WiiXplorer 2010
+ ***************************************************************************/
+#ifndef SOUND_DECODER_HPP
+#define SOUND_DECODER_HPP
+
+#include <sounds/BufferCircle.hpp>
+#include <mutex>
+#include <string>
+
+class CFile;
+
+class SoundDecoder {
+public:
+    SoundDecoder();
+
+    SoundDecoder(const std::string &filepath);
+
+    SoundDecoder(const uint8_t *buffer, int32_t size);
+
+    virtual ~SoundDecoder();
+
+    virtual void Lock() {
+        mutex.lock();
+    }
+
+    virtual void Unlock() {
+        mutex.unlock();
+    }
+
+    virtual int32_t Read(uint8_t *buffer, int32_t buffer_size, int32_t pos);
+
+    virtual int32_t Tell() {
+        return CurPos;
+    }
+
+    virtual int32_t Seek(int32_t pos);
+
+    virtual int32_t Rewind();
+
+    virtual uint16_t GetFormat() {
+        return Format;
+    }
+
+    virtual uint16_t GetSampleRate() {
+        return SampleRate;
+    }
+
+    virtual void Decode();
+
+    virtual bool IsBufferReady() {
+        return SoundBuffer.IsBufferReady();
+    }
+
+    virtual uint8_t *GetBuffer() {
+        return SoundBuffer.GetBuffer();
+    }
+
+    virtual uint32_t GetBufferSize() {
+        return SoundBuffer.GetBufferSize();
+    }
+
+    virtual void LoadNext() {
+        SoundBuffer.LoadNext();
+    }
+
+    virtual bool IsEOF() {
+        return EndOfFile;
+    }
+
+    virtual void SetLoop(bool l) {
+        Loop      = l;
+        EndOfFile = false;
+    }
+
+    virtual uint8_t GetSoundType() {
+        return SoundType;
+    }
+
+    virtual void ClearBuffer() {
+        SoundBuffer.ClearBuffer();
+        whichLoad = 0;
+    }
+
+    virtual bool IsStereo() {
+        return (GetFormat() & CHANNELS_STEREO) != 0;
+    }
+
+    virtual bool Is16Bit() {
+        return ((GetFormat() & 0xFF) == FORMAT_PCM_16_BIT);
+    }
+
+    virtual bool IsDecoding() {
+        return Decoding;
+    }
+
+    void EnableUpsample(void);
+
+    enum SoundFormats {
+        FORMAT_PCM_16_BIT = 0x0A,
+        FORMAT_PCM_8_BIT  = 0x19,
+    };
+    enum SoundChannels {
+        CHANNELS_MONO   = 0x100,
+        CHANNELS_STEREO = 0x200
+    };
+
+    enum SoundType {
+        SOUND_RAW = 0,
+        SOUND_MP3,
+        SOUND_OGG,
+        SOUND_WAV
+    };
+
+protected:
+    void Init();
+
+    void Upsample(int16_t *src, int16_t *dst, uint32_t nr_src_samples, uint32_t nr_dst_samples);
+
+    CFile *file_fd;
+    BufferCircle SoundBuffer;
+    uint8_t SoundType;
+    uint16_t whichLoad;
+    uint16_t SoundBlocks;
+    int32_t SoundBlockSize;
+    int32_t CurPos;
+    bool ResampleTo48kHz;
+    bool Loop;
+    bool EndOfFile;
+    bool Decoding;
+    bool ExitRequested;
+    uint16_t Format;
+    uint16_t SampleRate;
+    uint8_t *ResampleBuffer;
+    uint32_t ResampleRatio;
+    std::recursive_mutex mutex;
+};
+
+
+#endif

src/sounds/SoundHandler.cpp

@@ -0,0 +1,330 @@
+/***************************************************************************
+ * Copyright (C) 2010
+ * by Dimok
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any
+ * damages arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any
+ * purpose, including commercial applications, and to alter it and
+ * redistribute it freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you
+ * must not claim that you wrote the original software. If you use
+ * this software in a product, an acknowledgment in the product
+ * documentation would be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and
+ * must not be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+ *
+ * for WiiXplorer 2010
+ ***************************************************************************/
+#include <fs/CFile.hpp>
+#include <sounds/Mp3Decoder.hpp>
+#include <sounds/OggDecoder.hpp>
+#include <sounds/SoundHandler.hpp>
+#include <sounds/WavDecoder.hpp>
+#include <malloc.h>
+#include <sndcore2/core.h>
+#include <unistd.h>
+
+SoundHandler *SoundHandler::handlerInstance = NULL;
+
+SoundHandler::SoundHandler()
+    : CThread(CThread::eAttributeAffCore1 | CThread::eAttributePinnedAff, 0, 0x8000) {
+    Decoding      = false;
+    ExitRequested = false;
+    for (uint32_t i = 0; i < MAX_DECODERS; ++i) {
+        DecoderList[i] = NULL;
+        voiceList[i]   = NULL;
+    }
+
+    resumeThread();
+
+    //! wait for initialization
+    while (!isThreadSuspended())
+        OSSleepTicks(OSMicrosecondsToTicks(1000));
+}
+
+SoundHandler::~SoundHandler() {
+    ExitRequested = true;
+    ThreadSignal();
+
+    ClearDecoderList();
+}
+
+void SoundHandler::AddDecoder(int32_t voice, const char *filepath) {
+    if (voice < 0 || voice >= MAX_DECODERS) {
+        return;
+    }
+
+    if (DecoderList[voice] != NULL) {
+        RemoveDecoder(voice);
+    }
+
+    DecoderList[voice] = GetSoundDecoder(filepath);
+}
+
+void SoundHandler::AddDecoder(int32_t voice, const uint8_t *snd, int32_t len) {
+    if (voice < 0 || voice >= MAX_DECODERS) {
+        return;
+    }
+
+    if (DecoderList[voice] != NULL) {
+        RemoveDecoder(voice);
+    }
+
+    DecoderList[voice] = GetSoundDecoder(snd, len);
+}
+
+void SoundHandler::RemoveDecoder(int32_t voice) {
+    if (voice < 0 || voice >= MAX_DECODERS) {
+        return;
+    }
+
+    if (DecoderList[voice] != NULL) {
+        if (voiceList[voice] && voiceList[voice]->getState() != Voice::STATE_STOPPED) {
+            if (voiceList[voice]->getState() != Voice::STATE_STOP) {
+                voiceList[voice]->setState(Voice::STATE_STOP);
+            }
+
+            // it shouldn't take longer than 3 ms actually but we wait up to 20
+            // on application quit the AX frame callback is not called anymore
+            // therefore this would end in endless loop if no timeout is defined
+            int timeOut = 20;
+            while (--timeOut && (voiceList[voice]->getState() != Voice::STATE_STOPPED))
+                OSSleepTicks(OSMicrosecondsToTicks(1000));
+        }
+        SoundDecoder *decoder = DecoderList[voice];
+        decoder->Lock();
+        DecoderList[voice] = NULL;
+        decoder->Unlock();
+        delete decoder;
+    }
+}
+
+void SoundHandler::ClearDecoderList() {
+    for (uint32_t i = 0; i < MAX_DECODERS; ++i) {
+        RemoveDecoder(i);
+    }
+}
+
+static inline bool CheckMP3Signature(const uint8_t *buffer) {
+    const char MP3_Magic[][3] = {
+            {'I', 'D', '3'}, //'ID3'
+            {0xff, 0xfe},    //'MPEG ADTS, layer III, v1.0 [protected]', 'mp3', 'audio/mpeg'),
+            {0xff, 0xff},    //'MPEG ADTS, layer III, v1.0', 'mp3', 'audio/mpeg'),
+            {0xff, 0xfa},    //'MPEG ADTS, layer III, v1.0 [protected]', 'mp3', 'audio/mpeg'),
+            {0xff, 0xfb},    //'MPEG ADTS, layer III, v1.0', 'mp3', 'audio/mpeg'),
+            {0xff, 0xf2},    //'MPEG ADTS, layer III, v2.0 [protected]', 'mp3', 'audio/mpeg'),
+            {0xff, 0xf3},    //'MPEG ADTS, layer III, v2.0', 'mp3', 'audio/mpeg'),
+            {0xff, 0xf4},    //'MPEG ADTS, layer III, v2.0 [protected]', 'mp3', 'audio/mpeg'),
+            {0xff, 0xf5},    //'MPEG ADTS, layer III, v2.0', 'mp3', 'audio/mpeg'),
+            {0xff, 0xf6},    //'MPEG ADTS, layer III, v2.0 [protected]', 'mp3', 'audio/mpeg'),
+            {0xff, 0xf7},    //'MPEG ADTS, layer III, v2.0', 'mp3', 'audio/mpeg'),
+            {0xff, 0xe2},    //'MPEG ADTS, layer III, v2.5 [protected]', 'mp3', 'audio/mpeg'),
+            {0xff, 0xe3},    //'MPEG ADTS, layer III, v2.5', 'mp3', 'audio/mpeg'),
+    };
+
+    if (buffer[0] == MP3_Magic[0][0] && buffer[1] == MP3_Magic[0][1] &&
+        buffer[2] == MP3_Magic[0][2]) {
+        return true;
+    }
+
+    for (int32_t i = 1; i < 13; i++) {
+        if (buffer[0] == MP3_Magic[i][0] && buffer[1] == MP3_Magic[i][1]) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+SoundDecoder *SoundHandler::GetSoundDecoder(const char *filepath) {
+    uint32_t magic;
+    CFile f(filepath, CFile::ReadOnly);
+    if (f.size() == 0) {
+        return NULL;
+    }
+
+    do {
+        f.read((uint8_t *) &magic, 1);
+    } while (((uint8_t *) &magic)[0] == 0 && f.tell() < f.size());
+
+    if (f.tell() == f.size()) {
+        return NULL;
+    }
+
+    f.seek(f.tell() - 1, SEEK_SET);
+    f.read((uint8_t *) &magic, 4);
+    f.close();
+
+    if (magic == 0x4f676753) { // 'OggS'
+        return new OggDecoder(filepath);
+    } else if (magic == 0x52494646) { // 'RIFF'
+        return new WavDecoder(filepath);
+    } else if (CheckMP3Signature((uint8_t *) &magic) == true) {
+        return new Mp3Decoder(filepath);
+    }
+
+    return new SoundDecoder(filepath);
+}
+
+SoundDecoder *SoundHandler::GetSoundDecoder(const uint8_t *sound, int32_t length) {
+    const uint8_t *check = sound;
+    int32_t counter      = 0;
+
+    while (check[0] == 0 && counter < length) {
+        check++;
+        counter++;
+    }
+
+    if (counter >= length) {
+        return NULL;
+    }
+
+    uint32_t *magic = (uint32_t *) check;
+
+    if (magic[0] == 0x4f676753) { // 'OggS'
+        return new OggDecoder(sound, length);
+    } else if (magic[0] == 0x52494646) { // 'RIFF'
+        return new WavDecoder(sound, length);
+    } else if (CheckMP3Signature(check) == true) {
+        return new Mp3Decoder(sound, length);
+    }
+
+    return new SoundDecoder(sound, length);
+}
+
+void SoundHandler::executeThread() {
+    /*// v2 sound lib can not properly end transition audio on old firmwares
+    if (OS_FIRMWARE >= 400 && OS_FIRMWARE <= 410)
+    {
+        ProperlyEndTransitionAudio();
+    }*/
+
+
+    //! initialize 48 kHz renderer
+    AXInitParams params;
+    memset(&params, 0, sizeof(params));
+    params.renderer = AX_INIT_RENDERER_48KHZ;
+
+    // TODO: handle support for 3.1.0 with dynamic libs instead of static linking it
+    //if(AXInitWithParams != 0)
+    AXInitWithParams(&params);
+    //else
+    //    AXInit();
+
+    // The problem with last voice on 500 was caused by it having priority 0
+    // We would need to change this priority distribution if for some reason
+    // we would need MAX_DECODERS > Voice::PRIO_MAX
+    for (uint32_t i = 0; i < MAX_DECODERS; ++i) {
+        int32_t priority = (MAX_DECODERS - i) * Voice::PRIO_MAX / MAX_DECODERS;
+        voiceList[i]     = new Voice(priority); // allocate voice 0 with highest priority
+    }
+
+    AXRegisterAppFrameCallback(SoundHandler::axFrameCallback);
+
+
+    uint16_t i = 0;
+    while (!ExitRequested) {
+        suspendThread();
+
+        for (i = 0; i < MAX_DECODERS; ++i) {
+            if (DecoderList[i] == NULL) {
+                continue;
+            }
+
+            Decoding = true;
+            if (DecoderList[i]) {
+                DecoderList[i]->Lock();
+            }
+            if (DecoderList[i]) {
+                DecoderList[i]->Decode();
+            }
+            if (DecoderList[i]) {
+                DecoderList[i]->Unlock();
+            }
+        }
+        Decoding = false;
+    }
+
+    for (uint32_t i = 0; i < MAX_DECODERS; ++i) {
+        voiceList[i]->stop();
+    }
+
+    AXRegisterAppFrameCallback(NULL);
+    AXQuit();
+
+    for (uint32_t i = 0; i < MAX_DECODERS; ++i) {
+        delete voiceList[i];
+        voiceList[i] = NULL;
+    }
+}
+
+void SoundHandler::axFrameCallback(void) {
+    for (uint32_t i = 0; i < MAX_DECODERS; i++) {
+        Voice *voice = handlerInstance->getVoice(i);
+
+        switch (voice->getState()) {
+            default:
+            case Voice::STATE_STOPPED:
+                break;
+
+            case Voice::STATE_START: {
+                SoundDecoder *decoder = handlerInstance->getDecoder(i);
+                decoder->Lock();
+                if (decoder->IsBufferReady()) {
+                    const uint8_t *buffer     = decoder->GetBuffer();
+                    const uint32_t bufferSize = decoder->GetBufferSize();
+                    decoder->LoadNext();
+
+                    const uint8_t *nextBuffer = NULL;
+                    uint32_t nextBufferSize   = 0;
+
+                    if (decoder->IsBufferReady()) {
+                        nextBuffer     = decoder->GetBuffer();
+                        nextBufferSize = decoder->GetBufferSize();
+                        decoder->LoadNext();
+                    }
+
+                    voice->play(buffer, bufferSize, nextBuffer, nextBufferSize, decoder->GetFormat() & 0xff, decoder->GetSampleRate());
+
+                    handlerInstance->ThreadSignal();
+
+                    voice->setState(Voice::STATE_PLAYING);
+                }
+                decoder->Unlock();
+                break;
+            }
+            case Voice::STATE_PLAYING:
+                if (voice->getInternState() == 1) {
+                    if (voice->isBufferSwitched()) {
+                        SoundDecoder *decoder = handlerInstance->getDecoder(i);
+                        decoder->Lock();
+                        if (decoder->IsBufferReady()) {
+                            voice->setNextBuffer(decoder->GetBuffer(), decoder->GetBufferSize());
+                            decoder->LoadNext();
+                            handlerInstance->ThreadSignal();
+                        } else if (decoder->IsEOF()) {
+                            voice->setState(Voice::STATE_STOP);
+                        }
+                        decoder->Unlock();
+                    }
+                } else {
+                    voice->setState(Voice::STATE_STOPPED);
+                }
+                break;
+            case Voice::STATE_STOP:
+                if (voice->getInternState() != 0) {
+                    voice->stop();
+                }
+                voice->setState(Voice::STATE_STOPPED);
+                break;
+        }
+    }
+}

src/sounds/SoundHandler.hpp

@@ -0,0 +1,98 @@
+/***************************************************************************
+ * Copyright (C) 2010
+ * by Dimok
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any
+ * damages arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any
+ * purpose, including commercial applications, and to alter it and
+ * redistribute it freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you
+ * must not claim that you wrote the original software. If you use
+ * this software in a product, an acknowledgment in the product
+ * documentation would be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and
+ * must not be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+ *
+ * for WiiXplorer 2010
+ ***************************************************************************/
+#ifndef SOUNDHANDLER_H_
+#define SOUNDHANDLER_H_
+
+#include <vector>
+
+#include <sounds/SoundDecoder.hpp>
+#include <sounds/Voice.h>
+#include <system/CThread.h>
+#include <sndcore2/voice.h>
+
+#define MAX_DECODERS 16 // can be increased up to 96
+
+class SoundHandler : public CThread {
+public:
+    static SoundHandler *instance() {
+        if (!handlerInstance) {
+            handlerInstance = new SoundHandler();
+        }
+        return handlerInstance;
+    }
+
+    static void DestroyInstance() {
+        delete handlerInstance;
+        handlerInstance = NULL;
+    }
+
+    void AddDecoder(int32_t voice, const char *filepath);
+
+    void AddDecoder(int32_t voice, const uint8_t *snd, int32_t len);
+
+    void RemoveDecoder(int32_t voice);
+
+    SoundDecoder *getDecoder(int32_t i) {
+        return ((i < 0 || i >= MAX_DECODERS) ? NULL : DecoderList[i]);
+    };
+
+    Voice *getVoice(int32_t i) {
+        return ((i < 0 || i >= MAX_DECODERS) ? NULL : voiceList[i]);
+    };
+
+    void ThreadSignal() {
+        resumeThread();
+    };
+
+    bool IsDecoding() {
+        return Decoding;
+    };
+
+protected:
+    SoundHandler();
+
+    ~SoundHandler();
+
+    static void axFrameCallback(void);
+
+    void executeThread(void);
+
+    void ClearDecoderList();
+
+    SoundDecoder *GetSoundDecoder(const char *filepath);
+
+    SoundDecoder *GetSoundDecoder(const uint8_t *sound, int32_t length);
+
+    static SoundHandler *handlerInstance;
+
+    bool Decoding;
+    bool ExitRequested;
+
+    Voice *voiceList[MAX_DECODERS];
+    SoundDecoder *DecoderList[MAX_DECODERS];
+};
+
+#endif

src/sounds/Voice.h

@@ -0,0 +1,158 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef _AXSOUND_H_
+#define _AXSOUND_H_
+
+#include <sndcore2/core.h>
+#include <sndcore2/voice.h>
+
+class Voice {
+public:
+    enum VoicePriorities {
+        PRIO_MIN = 1,
+        PRIO_MAX = 31
+    };
+
+    enum VoiceStates {
+        STATE_STOPPED,
+        STATE_START,
+        STATE_PLAYING,
+        STATE_STOP,
+    };
+
+    Voice(int32_t prio)
+        : state(STATE_STOPPED) {
+        lastLoopCounter = 0;
+        nextBufferSize  = 0;
+
+        voice = AXAcquireVoice(prio, 0, 0);
+        if (voice) {
+            AXVoiceBegin(voice);
+            AXSetVoiceType(voice, 0);
+            setVolume(0x80000000);
+
+
+            AXVoiceDeviceMixData mix[6];
+            memset(mix, 0, sizeof(mix));
+            mix[0].bus[0].volume = 0x8000;
+            mix[0].bus[0].delta  = 0;
+            mix[1].bus[0].volume = 0x8000;
+            mix[1].bus[0].delta  = 0;
+
+            AXSetVoiceDeviceMix(voice, 0, 0, mix);
+            AXSetVoiceDeviceMix(voice, 1, 0, mix);
+
+            AXVoiceEnd(voice);
+        }
+    }
+
+    ~Voice() {
+        if (voice) {
+            AXFreeVoice(voice);
+        }
+    }
+
+    void play(const uint8_t *buffer, uint32_t bufferSize, const uint8_t *nextBuffer, uint32_t nextBufSize, uint16_t format, uint32_t sampleRate) {
+        if (!voice) {
+            return;
+        }
+
+        memset(&voiceBuffer, 0, sizeof(voiceBuffer));
+
+        voiceBuffer.data           = buffer;
+        voiceBuffer.dataType       = format;
+        voiceBuffer.loopingEnabled = (nextBuffer == NULL) ? 0 : 1;
+        voiceBuffer.currentOffset  = 0;
+        voiceBuffer.endOffset      = (bufferSize >> 1) - 1;
+        voiceBuffer.loopOffset     = ((nextBuffer - buffer) >> 1);
+        nextBufferSize             = nextBufSize;
+
+        // TODO: handle support for 3.1.0 with dynamic libs instead of static linking it
+        //uint32_t samplesPerSec = (AXGetInputSamplesPerSec != 0) ? AXGetInputSamplesPerSec() : 32000;
+        uint32_t samplesPerSec = AXGetInputSamplesPerSec();
+
+        memset(&ratioBits, 0, sizeof(ratioBits));
+        ratioBits.ratio = (uint32_t) (0x00010000 * ((float) sampleRate / (float) samplesPerSec));
+
+        AXSetVoiceOffsets(voice, &voiceBuffer);
+        AXSetVoiceSrc(voice, &ratioBits);
+        AXSetVoiceSrcType(voice, 1);
+        AXSetVoiceState(voice, 1);
+    }
+
+    void stop() {
+        if (voice) {
+            AXSetVoiceState(voice, 0);
+        }
+    }
+
+    void setVolume(uint32_t vol) {
+        if (voice) {
+            AXVoiceVeData data;
+            data.volume = vol >> 16;
+            data.delta  = vol & 0xFFFF;
+            AXSetVoiceVe(voice, &data);
+        }
+    }
+
+
+    void setNextBuffer(const uint8_t *buffer, uint32_t bufferSize) {
+        voiceBuffer.loopOffset = ((buffer - (const uint8_t *) voiceBuffer.data) >> 1);
+        nextBufferSize         = bufferSize;
+
+        AXSetVoiceLoopOffset(voice, voiceBuffer.loopOffset);
+    }
+
+    bool isBufferSwitched() {
+        uint32_t loopCounter = AXGetVoiceLoopCount(voice);
+        if (lastLoopCounter != loopCounter) {
+            lastLoopCounter = loopCounter;
+            AXSetVoiceEndOffset(voice, voiceBuffer.loopOffset + (nextBufferSize >> 1) - 1);
+            return true;
+        }
+        return false;
+    }
+
+    uint32_t getInternState() const {
+        if (voice) {
+            return ((uint32_t *) voice)[1];
+        }
+        return 0;
+    }
+
+    uint32_t getState() const {
+        return state;
+    }
+
+    void setState(uint32_t s) {
+        state = s;
+    }
+
+    void *getVoice() const {
+        return voice;
+    }
+
+private:
+    AXVoice *voice;
+    AXVoiceSrc ratioBits;
+    AXVoiceOffsets voiceBuffer;
+    uint32_t state;
+    uint32_t nextBufferSize;
+    uint32_t lastLoopCounter;
+};
+
+#endif // _AXSOUND_H_

src/sounds/WavDecoder.cpp

@@ -0,0 +1,148 @@
+/***************************************************************************
+ * Copyright (C) 2010
+ * by Dimok
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any
+ * damages arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any
+ * purpose, including commercial applications, and to alter it and
+ * redistribute it freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you
+ * must not claim that you wrote the original software. If you use
+ * this software in a product, an acknowledgment in the product
+ * documentation would be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and
+ * must not be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+ *
+ * for WiiXplorer 2010
+ ***************************************************************************/
+#include "fs/CFile.hpp"
+#include "utils/utils.h"
+#include <sounds/WavDecoder.hpp>
+#include <string.h>
+
+WavDecoder::WavDecoder(const char *filepath)
+    : SoundDecoder(filepath) {
+    SoundType  = SOUND_WAV;
+    SampleRate = 48000;
+    Format     = CHANNELS_STEREO | FORMAT_PCM_16_BIT;
+
+    if (!file_fd) {
+        return;
+    }
+
+    OpenFile();
+}
+
+WavDecoder::WavDecoder(const uint8_t *snd, int32_t len)
+    : SoundDecoder(snd, len) {
+    SoundType  = SOUND_WAV;
+    SampleRate = 48000;
+    Format     = CHANNELS_STEREO | FORMAT_PCM_16_BIT;
+
+    if (!file_fd) {
+        return;
+    }
+
+    OpenFile();
+}
+
+WavDecoder::~WavDecoder() {
+}
+
+
+void WavDecoder::OpenFile() {
+    SWaveHdr Header;
+    SWaveFmtChunk FmtChunk;
+    memset(&Header, 0, sizeof(SWaveHdr));
+    memset(&FmtChunk, 0, sizeof(SWaveFmtChunk));
+
+    file_fd->read((uint8_t *) &Header, sizeof(SWaveHdr));
+    file_fd->read((uint8_t *) &FmtChunk, sizeof(SWaveFmtChunk));
+
+    if (Header.magicRIFF != 0x52494646) { // 'RIFF'
+        CloseFile();
+        return;
+    } else if (Header.magicWAVE != 0x57415645) { // 'WAVE'
+        CloseFile();
+        return;
+    } else if (FmtChunk.magicFMT != 0x666d7420) { // 'fmt '
+        CloseFile();
+        return;
+    }
+
+    DataOffset = sizeof(SWaveHdr) + le32(FmtChunk.size) + 8;
+    file_fd->seek(DataOffset, SEEK_SET);
+    SWaveChunk DataChunk;
+    file_fd->read((uint8_t *) &DataChunk, sizeof(SWaveChunk));
+
+    while (DataChunk.magicDATA != 0x64617461) { // 'data'
+        DataOffset += 8 + le32(DataChunk.size);
+        file_fd->seek(DataOffset, SEEK_SET);
+        int32_t ret = file_fd->read((uint8_t *) &DataChunk, sizeof(SWaveChunk));
+        if (ret <= 0) {
+            CloseFile();
+            return;
+        }
+    }
+
+    DataOffset += 8;
+    DataSize   = le32(DataChunk.size);
+    Is16Bit    = (le16(FmtChunk.bps) == 16);
+    SampleRate = le32(FmtChunk.freq);
+
+    if (le16(FmtChunk.channels) == 1 && le16(FmtChunk.bps) == 8 && le16(FmtChunk.alignment) <= 1) {
+        Format = CHANNELS_MONO | FORMAT_PCM_8_BIT;
+    } else if (le16(FmtChunk.channels) == 1 && le16(FmtChunk.bps) == 16 && le16(FmtChunk.alignment) <= 2) {
+        Format = CHANNELS_MONO | FORMAT_PCM_16_BIT;
+    } else if (le16(FmtChunk.channels) == 2 && le16(FmtChunk.bps) == 8 && le16(FmtChunk.alignment) <= 2) {
+        Format = CHANNELS_STEREO | FORMAT_PCM_8_BIT;
+    } else if (le16(FmtChunk.channels) == 2 && le16(FmtChunk.bps) == 16 && le16(FmtChunk.alignment) <= 4) {
+        Format = CHANNELS_STEREO | FORMAT_PCM_16_BIT;
+    }
+}
+
+void WavDecoder::CloseFile() {
+    if (file_fd) {
+        delete file_fd;
+    }
+
+    file_fd = NULL;
+}
+
+int32_t WavDecoder::Read(uint8_t *buffer, int32_t buffer_size, int32_t pos) {
+    if (!file_fd) {
+        return -1;
+    }
+
+    if (CurPos >= (int32_t) DataSize) {
+        return 0;
+    }
+
+    file_fd->seek(DataOffset + CurPos, SEEK_SET);
+
+    if (buffer_size > (int32_t) DataSize - CurPos) {
+        buffer_size = DataSize - CurPos;
+    }
+
+    int32_t read = file_fd->read(buffer, buffer_size);
+    if (read > 0) {
+        if (Is16Bit) {
+            read &= ~0x0001;
+
+            for (uint32_t i = 0; i < (uint32_t) (read / sizeof(uint16_t)); ++i) {
+                ((uint16_t *) buffer)[i] = le16(((uint16_t *) buffer)[i]);
+            }
+        }
+        CurPos += read;
+    }
+
+    return read;
+}

src/sounds/WavDecoder.hpp

@@ -0,0 +1,73 @@
+/***************************************************************************
+ * Copyright (C) 2010
+ * by Dimok
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty. In no event will the authors be held liable for any
+ * damages arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any
+ * purpose, including commercial applications, and to alter it and
+ * redistribute it freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you
+ * must not claim that you wrote the original software. If you use
+ * this software in a product, an acknowledgment in the product
+ * documentation would be appreciated but is not required.
+ *
+ * 2. Altered source versions must be plainly marked as such, and
+ * must not be misrepresented as being the original software.
+ *
+ * 3. This notice may not be removed or altered from any source
+ * distribution.
+ *
+ * for WiiXplorer 2010
+ ***************************************************************************/
+#ifndef WAVDECODER_HPP_
+#define WAVDECODER_HPP_
+
+#include <sounds/SoundDecoder.hpp>
+
+typedef struct {
+    uint32_t magicRIFF;
+    uint32_t size;
+    uint32_t magicWAVE;
+} SWaveHdr;
+
+typedef struct {
+    uint32_t magicFMT;
+    uint32_t size;
+    uint16_t format;
+    uint16_t channels;
+    uint32_t freq;
+    uint32_t avgBps;
+    uint16_t alignment;
+    uint16_t bps;
+} SWaveFmtChunk;
+
+typedef struct {
+    uint32_t magicDATA;
+    uint32_t size;
+} SWaveChunk;
+
+class WavDecoder : public SoundDecoder {
+public:
+    WavDecoder(const char *filepath);
+
+    WavDecoder(const uint8_t *snd, int32_t len);
+
+    virtual ~WavDecoder();
+
+    int32_t Read(uint8_t *buffer, int32_t buffer_size, int32_t pos);
+
+protected:
+    void OpenFile();
+
+    void CloseFile();
+
+    uint32_t DataOffset;
+    uint32_t DataSize;
+    bool Is16Bit;
+};
+
+#endif

src/system/CThread.h

@@ -17,20 +17,17 @@
 #ifndef CTHREAD_H_
 #define CTHREAD_H_
 
+#include <coreinit/thread.h>
 #include <malloc.h>
 #include <unistd.h>
-#include <coreinit/thread.h>
 
 class CThread {
 public:
     typedef void (*Callback)(CThread *thread, void *arg);
 
     //! constructor
-    CThread(int32_t iAttr, int32_t iPriority = 16, int32_t iStackSize = 0x8000, CThread::Callback callback = nullptr, void *callbackArg = nullptr)
+    CThread(int32_t iAttr, int32_t iPriority = 16, int32_t iStackSize = 0x8000, CThread::Callback callback = NULL, void *callbackArg = NULL)
-        : pThread(nullptr)
+        : pThread(NULL), pThreadStack(NULL), pCallback(callback), pCallbackArg(callbackArg) {
-        , pThreadStack(nullptr)
-        , pCallback(callback)
-        , pCallbackArg(callbackArg) {
         //! save attribute assignment
         iAttributes = iAttr;
         //! allocate the thread
@@ -38,9 +35,10 @@ public:
         //! allocate the stack
         pThreadStack = (uint8_t *) memalign(0x20, iStackSize);
         //! create the thread
-        if(pThread && pThreadStack)
+        if (pThread && pThreadStack) {
             OSCreateThread(pThread, &CThread::threadCallback, 1, (char *) this, pThreadStack + iStackSize, iStackSize, iPriority, iAttributes);
         }
+    }
 
     //! destructor
     virtual ~CThread() {
@@ -55,64 +53,84 @@ public:
     virtual void *getThread() const {
         return pThread;
     }
+
     //! Thread entry function
     virtual void executeThread(void) {
-        if(pCallback)
+        if (pCallback) {
             pCallback(this, pCallbackArg);
         }
+    }
+
     //! Suspend thread
     virtual void suspendThread(void) {
-        if(isThreadSuspended())
+        if (isThreadSuspended()) {
             return;
-        if(pThread)
+        }
+        if (pThread) {
             OSSuspendThread(pThread);
         }
+    }
+
     //! Resume thread
     virtual void resumeThread(void) {
-        if(!isThreadSuspended())
+        if (!isThreadSuspended()) {
             return;
-        if(pThread)
+        }
+        if (pThread) {
             OSResumeThread(pThread);
         }
+    }
+
     //! Set thread priority
     virtual void setThreadPriority(int32_t prio) {
-        if(pThread)
+        if (pThread) {
             OSSetThreadPriority(pThread, prio);
         }
+    }
+
     //! Check if thread is suspended
     virtual bool isThreadSuspended(void) const {
-        if(pThread)
+        if (pThread) {
             return OSIsThreadSuspended(pThread);
+        }
         return false;
     }
+
     //! Check if thread is terminated
     virtual bool isThreadTerminated(void) const {
-        if(pThread)
+        if (pThread) {
             return OSIsThreadTerminated(pThread);
+        }
         return false;
     }
+
     //! Check if thread is running
     virtual bool isThreadRunning(void) const {
         return !isThreadSuspended() && !isThreadRunning();
     }
+
     //! Shutdown thread
     virtual void shutdownThread(void) {
         //! wait for thread to finish
         if (pThread && !(iAttributes & eAttributeDetach)) {
-            if(isThreadSuspended())
+            if (isThreadSuspended()) {
                 resumeThread();
+            }
 
-            OSJoinThread(pThread, nullptr);
+            OSJoinThread(pThread, NULL);
         }
         //! free the thread stack buffer
-        if(pThreadStack)
+        if (pThreadStack) {
             free(pThreadStack);
-        if(pThread)
-            free(pThread);
-
-        pThread = nullptr;
-        pThreadStack = nullptr;
         }
+        if (pThread) {
+            free(pThread);
+        }
+
+        pThread      = NULL;
+        pThreadStack = NULL;
+    }
+
     //! Thread attributes
     enum eCThreadAttributes {
         eAttributeNone      = 0x07,
@@ -122,12 +140,14 @@ public:
         eAttributeDetach    = 0x08,
         eAttributePinnedAff = 0x10
     };
+
 private:
     static int32_t threadCallback(int32_t argc, const char **argv) {
         //! After call to start() continue with the internal function
         ((CThread *) argv)->executeThread();
         return 0;
     }
+
     int32_t iAttributes;
     OSThread *pThread;
     uint8_t *pThreadStack;

src/system/memory.cpp

@@ -0,0 +1,91 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+
+#include "memory.h"
+#include <coreinit/memexpheap.h>
+#include <coreinit/memfrmheap.h>
+#include <coreinit/memheap.h>
+#include <malloc.h>
+
+//!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+//! Memory functions
+//! This is the only place where those are needed so lets keep them more or less private
+//!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+static MEMHeapHandle mem1_heap   = NULL;
+static MEMHeapHandle bucket_heap = NULL;
+
+void libgui_memoryInitialize(void) {
+    if (!mem1_heap) {
+        MEMHeapHandle mem1_heap_handle = MEMGetBaseHeapHandle(MEM_BASE_HEAP_MEM1);
+        uint32_t mem1_allocatable_size = MEMGetAllocatableSizeForFrmHeapEx(mem1_heap_handle, 4);
+        void *mem1_memory              = MEMAllocFromFrmHeapEx(mem1_heap_handle, mem1_allocatable_size, 4);
+        if (mem1_memory)
+            mem1_heap = MEMCreateExpHeapEx(mem1_memory, mem1_allocatable_size, 0);
+    }
+
+    if (!bucket_heap) {
+        MEMHeapHandle bucket_heap_handle = MEMGetBaseHeapHandle(MEM_BASE_HEAP_FG);
+        uint32_t bucket_allocatable_size = MEMGetAllocatableSizeForFrmHeapEx(bucket_heap_handle, 4);
+        void *bucket_memory              = MEMAllocFromFrmHeapEx(bucket_heap_handle, bucket_allocatable_size, 4);
+        if (bucket_memory)
+            bucket_heap = MEMCreateExpHeapEx(bucket_memory, bucket_allocatable_size, 0);
+    }
+}
+
+void libgui_memoryRelease(void) {
+    if (mem1_heap) {
+        MEMDestroyExpHeap(mem1_heap);
+        MEMFreeToFrmHeap(MEMGetBaseHeapHandle(MEM_BASE_HEAP_MEM1), MEM_FRM_HEAP_FREE_ALL);
+        mem1_heap = NULL;
+    }
+    if (bucket_heap) {
+        MEMDestroyExpHeap(bucket_heap);
+        MEMFreeToFrmHeap(MEMGetBaseHeapHandle(MEM_BASE_HEAP_FG), MEM_FRM_HEAP_FREE_ALL);
+        bucket_heap = NULL;
+    }
+}
+
+//!-------------------------------------------------------------------------------------------
+//! some wrappers
+//!-------------------------------------------------------------------------------------------
+void *MEM2_alloc(uint32_t size, uint32_t align) {
+    return memalign(align, size);
+}
+
+void MEM2_free(void *ptr) {
+    free(ptr);
+}
+
+void *MEM1_alloc(uint32_t size, uint32_t align) {
+    if (align < 4)
+        align = 4;
+    return MEMAllocFromExpHeapEx(mem1_heap, size, align);
+}
+
+void MEM1_free(void *ptr) {
+    MEMFreeToExpHeap(mem1_heap, ptr);
+}
+
+void *MEMBucket_alloc(uint32_t size, uint32_t align) {
+    if (align < 4)
+        align = 4;
+    return MEMAllocFromExpHeapEx(bucket_heap, size, align);
+}
+
+void MEMBucket_free(void *ptr) {
+    MEMFreeToExpHeap(bucket_heap, ptr);
+}

src/system/memory.h

@@ -0,0 +1,47 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef __MEMORY_H_
+#define __MEMORY_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <cstdint>
+#include <malloc.h>
+
+void libgui_memoryInitialize(void);
+
+void libgui_memoryRelease(void);
+
+void *MEM2_alloc(uint32_t size, uint32_t align);
+
+void MEM2_free(void *ptr);
+
+void *MEM1_alloc(uint32_t size, uint32_t align);
+
+void MEM1_free(void *ptr);
+
+void *MEMBucket_alloc(uint32_t size, uint32_t align);
+
+void MEMBucket_free(void *ptr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __MEMORY_H_

src/utils/utils.c

@@ -1,41 +0,0 @@
-#include <string.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <malloc.h>
-#include <utils/logger.h>
-
-// https://gist.github.com/ccbrown/9722406
-void dumpHex(const void *data, size_t size) {
-    char ascii[17];
-    size_t i, j;
-    ascii[16] = '\0';
-    DEBUG_FUNCTION_LINE_WRITE("0x%08X (0x0000): ", data);
-    for (i = 0; i < size; ++i) {
-        WHBLogWritef("%02X ", ((unsigned char *) data)[i]);
-        if (((unsigned char *) data)[i] >= ' ' && ((unsigned char *) data)[i] <= '~') {
-            ascii[i % 16] = ((unsigned char *) data)[i];
-        } else {
-            ascii[i % 16] = '.';
-        }
-        if ((i + 1) % 8 == 0 || i + 1 == size) {
-            WHBLogWritef(" ");
-            if ((i + 1) % 16 == 0) {
-                WHBLogWritef("|  %s \n", ascii);
-                if (i + 1 < size) {
-                    WHBLogWritef("0x%08X (0x%04X); ", data + i + 1, i + 1);
-                }
-            } else if (i + 1 == size) {
-                ascii[(i + 1) % 16] = '\0';
-                if ((i + 1) % 16 <= 8) {
-                    WHBLogWritef(" ");
-                }
-                for (j = (i + 1) % 16; j < 16; ++j) {
-                    WHBLogWritef("   ");
-                }
-                WHBLogWritef("|  %s \n", ascii);
-            }
-        }
-    }
-}

src/utils/utils.cpp

@@ -0,0 +1,41 @@
+#include <string.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <malloc.h>
+#include <utils/logger.h>
+
+// https://gist.github.com/ccbrown/9722406
+void dumpHex(const void *data, size_t size) {
+   char ascii[17];
+   size_t i, j;
+   ascii[16] = '\0';
+   DEBUG_FUNCTION_LINE_WRITE("0x%08X (0x0000): ", data);
+   for (i = 0; i < size; ++i) {
+      WHBLogWritef("%02X ", ((unsigned char *) data)[i]);
+      if (((unsigned char *) data)[i] >= ' ' && ((unsigned char *) data)[i] <= '~') {
+         ascii[i % 16] = ((unsigned char *) data)[i];
+      } else {
+         ascii[i % 16] = '.';
+      }
+      if ((i + 1) % 8 == 0 || i + 1 == size) {
+         WHBLogWritef(" ");
+         if ((i + 1) % 16 == 0) {
+            WHBLogWritef("|  %s \n", ascii);
+            if (i + 1 < size) {
+               WHBLogWritef("0x%08X (0x%04X); ", ((char *) data)[i + 1], i + 1);
+            }
+         } else if (i + 1 == size) {
+            ascii[(i + 1) % 16] = '\0';
+            if ((i + 1) % 16 <= 8) {
+               WHBLogWritef(" ");
+            }
+            for (j = (i + 1) % 16; j < 16; ++j) {
+               WHBLogWritef("   ");
+            }
+            WHBLogWritef("|  %s \n", ascii);
+         }
+      }
+   }
+}

src/video/CVideo.cpp

@@ -0,0 +1,264 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include "utils/utils.h"
+#include <cstdint>
+#include "system/memory.h"
+#include <video/CVideo.h>
+#include <video/shaders/ColorShader.h>
+#include <video/shaders/FXAAShader.h>
+#include <video/shaders/Shader3D.h>
+#include <video/shaders/ShaderFractalColor.h>
+#include <video/shaders/Texture2DShader.h>
+#include <malloc.h>
+#include <string.h>
+
+CVideo::CVideo(int32_t forceTvScanMode, int32_t forceDrcScanMode) {
+    tvEnabled  = false;
+    drcEnabled = false;
+
+    //! allocate MEM2 command buffer memory
+    gx2CommandBuffer = MEM2_alloc(GX2_COMMAND_BUFFER_SIZE, 0x40);
+
+    //! initialize GX2 command buffer
+    uint32_t gx2_init_attributes[9];
+    gx2_init_attributes[0] = GX2_INIT_CMD_BUF_BASE;
+    gx2_init_attributes[1] = (uint32_t) gx2CommandBuffer;
+    gx2_init_attributes[2] = GX2_INIT_CMD_BUF_POOL_SIZE;
+    gx2_init_attributes[3] = GX2_COMMAND_BUFFER_SIZE;
+    gx2_init_attributes[4] = GX2_INIT_ARGC;
+    gx2_init_attributes[5] = 0;
+    gx2_init_attributes[6] = GX2_INIT_ARGV;
+    gx2_init_attributes[7] = 0;
+    gx2_init_attributes[8] = GX2_INIT_END;
+    GX2Init(gx2_init_attributes);
+
+    uint32_t scanBufferSize = 0;
+    uint32_t scaleNeeded    = 0;
+
+    int32_t tvScanMode  = ((forceTvScanMode >= 0) ? forceTvScanMode : (int32_t) GX2GetSystemTVScanMode());
+    int32_t drcScanMode = ((forceDrcScanMode >= 0) ? forceDrcScanMode : (int32_t) GX2GetSystemDRCScanMode());
+
+    int32_t tvRenderMode;
+    uint32_t tvWidth  = 0;
+    uint32_t tvHeight = 0;
+
+    switch (tvScanMode) {
+        case GX2_TV_SCAN_MODE_480I:
+        case GX2_TV_SCAN_MODE_480P:
+            tvWidth      = 854;
+            tvHeight     = 480;
+            tvRenderMode = GX2_TV_RENDER_MODE_WIDE_480P;
+            break;
+        case GX2_TV_SCAN_MODE_1080I:
+        case GX2_TV_SCAN_MODE_1080P:
+            tvWidth      = 1920;
+            tvHeight     = 1080;
+            tvRenderMode = GX2_TV_RENDER_MODE_WIDE_1080P;
+            break;
+        case GX2_TV_SCAN_MODE_720P:
+        default:
+            tvWidth      = 1280;
+            tvHeight     = 720;
+            tvRenderMode = GX2_TV_RENDER_MODE_WIDE_720P;
+            break;
+    }
+
+    int32_t tvAAMode  = GX2_AA_MODE1X;
+    int32_t drcAAMode = GX2_AA_MODE4X;
+
+    //! calculate the scale factor for later texture resize
+    widthScaleFactor  = 1.0f / (float) tvWidth;
+    heightScaleFactor = 1.0f / (float) tvHeight;
+    depthScaleFactor  = widthScaleFactor;
+
+    //! calculate the size needed for the TV scan buffer and allocate the buffer from bucket memory
+    GX2CalcTVSize((GX2TVRenderMode) tvRenderMode, GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8, GX2_BUFFERING_MODE_DOUBLE, &scanBufferSize, &scaleNeeded);
+    tvScanBuffer = MEMBucket_alloc(scanBufferSize, GX2_SCAN_BUFFER_ALIGNMENT);
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU, tvScanBuffer, scanBufferSize);
+    GX2SetTVBuffer(tvScanBuffer, scanBufferSize, (GX2TVRenderMode) tvRenderMode, GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8, GX2_BUFFERING_MODE_DOUBLE);
+
+    //! calculate the size needed for the DRC scan buffer and allocate the buffer from bucket memory
+    GX2CalcDRCSize((GX2DrcRenderMode) drcScanMode, GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8, GX2_BUFFERING_MODE_DOUBLE, &scanBufferSize, &scaleNeeded);
+    drcScanBuffer = MEMBucket_alloc(scanBufferSize, GX2_SCAN_BUFFER_ALIGNMENT);
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU, drcScanBuffer, scanBufferSize);
+    GX2SetDRCBuffer(drcScanBuffer, scanBufferSize, (GX2DrcRenderMode) drcScanMode, GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8, GX2_BUFFERING_MODE_DOUBLE);
+
+    //! Setup color buffer for TV rendering
+    GX2InitColorBuffer(&tvColorBuffer, GX2_SURFACE_DIM_TEXTURE_2D, tvWidth, tvHeight, 1, GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8, (GX2AAMode) tvAAMode);
+    tvColorBuffer.surface.image = MEM1_alloc(tvColorBuffer.surface.imageSize, tvColorBuffer.surface.alignment);
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU, tvColorBuffer.surface.image, tvColorBuffer.surface.imageSize);
+
+    //! due to AA we can only use 16 bit depth buffer in MEM1 otherwise we would have to switch to mem2 for depth buffer
+    //! this should be ok for our purpose i guess
+
+    //! Setup TV depth buffer (can be the same for both if rendered one after another)
+    uint32_t size, align;
+    GX2InitDepthBuffer(&tvDepthBuffer, GX2_SURFACE_DIM_TEXTURE_2D, tvColorBuffer.surface.width, tvColorBuffer.surface.height, 1, GX2_SURFACE_FORMAT_FLOAT_R32, (GX2AAMode) tvAAMode);
+    tvDepthBuffer.surface.image = MEM1_alloc(tvDepthBuffer.surface.imageSize, tvDepthBuffer.surface.alignment);
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU, tvDepthBuffer.surface.image, tvDepthBuffer.surface.imageSize);
+
+    //! Setup TV HiZ buffer
+    GX2CalcDepthBufferHiZInfo(&tvDepthBuffer, &size, &align);
+    tvDepthBuffer.hiZPtr = MEM1_alloc(size, align);
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU, tvDepthBuffer.hiZPtr, size);
+    GX2InitDepthBufferHiZEnable(&tvDepthBuffer, GX2_ENABLE);
+
+    //! Setup color buffer for DRC rendering
+    GX2InitColorBuffer(&drcColorBuffer, GX2_SURFACE_DIM_TEXTURE_2D, 854, 480, 1, GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8, (GX2AAMode) drcAAMode);
+    drcColorBuffer.surface.image = MEM1_alloc(drcColorBuffer.surface.imageSize, drcColorBuffer.surface.alignment);
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU, drcColorBuffer.surface.image, drcColorBuffer.surface.imageSize);
+
+    //! Setup DRC depth buffer (can be the same for both if rendered one after another)
+    GX2InitDepthBuffer(&drcDepthBuffer, GX2_SURFACE_DIM_TEXTURE_2D, drcColorBuffer.surface.width, drcColorBuffer.surface.height, 1, GX2_SURFACE_FORMAT_FLOAT_R32, (GX2AAMode) drcAAMode);
+    drcDepthBuffer.surface.image = MEM1_alloc(drcDepthBuffer.surface.imageSize, drcDepthBuffer.surface.alignment);
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU, drcDepthBuffer.surface.image, drcDepthBuffer.surface.imageSize);
+
+    //! Setup DRC HiZ buffer
+    GX2CalcDepthBufferHiZInfo(&drcDepthBuffer, &size, &align);
+    drcDepthBuffer.hiZPtr = MEM1_alloc(size, align);
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU, drcDepthBuffer.hiZPtr, size);
+    GX2InitDepthBufferHiZEnable(&drcDepthBuffer, GX2_ENABLE);
+
+
+    //! allocate auxilary buffer last as there might not be enough MEM1 left for other stuff after that
+    if (tvColorBuffer.surface.aa) {
+        uint32_t auxSize, auxAlign;
+        GX2CalcColorBufferAuxInfo(&tvColorBuffer, &auxSize, &auxAlign);
+        tvColorBuffer.aaBuffer = MEM1_alloc(auxSize, auxAlign);
+        if (!tvColorBuffer.aaBuffer) {
+            tvColorBuffer.aaBuffer = MEM2_alloc(auxSize, auxAlign);
+        }
+
+        tvColorBuffer.aaSize = auxSize;
+        memset(tvColorBuffer.aaBuffer, GX2_AA_BUFFER_CLEAR_VALUE, auxSize);
+        GX2Invalidate(GX2_INVALIDATE_MODE_CPU, tvColorBuffer.aaBuffer, auxSize);
+    }
+
+    if (drcColorBuffer.surface.aa) {
+        uint32_t auxSize, auxAlign;
+        GX2CalcColorBufferAuxInfo(&drcColorBuffer, &auxSize, &auxAlign);
+        drcColorBuffer.aaBuffer = MEM1_alloc(auxSize, auxAlign);
+        if (!drcColorBuffer.aaBuffer) {
+            drcColorBuffer.aaBuffer = MEM2_alloc(auxSize, auxAlign);
+        }
+        drcColorBuffer.aaSize = auxSize;
+        memset(drcColorBuffer.aaBuffer, GX2_AA_BUFFER_CLEAR_VALUE, auxSize);
+        GX2Invalidate(GX2_INVALIDATE_MODE_CPU, drcColorBuffer.aaBuffer, auxSize);
+    }
+
+    //! allocate memory and setup context state TV
+    tvContextState = (GX2ContextState *) MEM2_alloc(sizeof(GX2ContextState), GX2_CONTEXT_STATE_ALIGNMENT);
+    GX2SetupContextStateEx(tvContextState, GX2_TRUE);
+
+    //! allocate memory and setup context state DRC
+    drcContextState = (GX2ContextState *) MEM2_alloc(sizeof(GX2ContextState), GX2_CONTEXT_STATE_ALIGNMENT);
+    GX2SetupContextStateEx(drcContextState, GX2_TRUE);
+
+    //! set initial context state and render buffers
+    GX2SetContextState(tvContextState);
+    GX2SetColorBuffer(&tvColorBuffer, GX2_RENDER_TARGET_0);
+    GX2SetDepthBuffer(&tvDepthBuffer);
+
+    GX2SetContextState(drcContextState);
+    GX2SetColorBuffer(&drcColorBuffer, GX2_RENDER_TARGET_0);
+    GX2SetDepthBuffer(&drcDepthBuffer);
+
+    //! set initial viewport
+    GX2SetViewport(0.0f, 0.0f, tvColorBuffer.surface.width, tvColorBuffer.surface.height, 0.0f, 1.0f);
+    GX2SetScissor(0, 0, tvColorBuffer.surface.width, tvColorBuffer.surface.height);
+
+    //! this is not necessary but can be used for swap counting and vsyncs
+    GX2SetSwapInterval(1);
+
+    //GX2SetTVGamma(0.8f);
+    //GX2SetDRCGamma(0.8f);
+
+    //! initialize perspective matrix
+    const float cam_X_rot = 25.0f;
+
+    projectionMtx = glm::perspective(45.0f, 1.0f, 0.1f, 100.0f);
+
+    viewMtx = glm::mat4(1.0f);
+    viewMtx = glm::translate(viewMtx, glm::vec3(0.0f, 0.0f, -2.5f));
+    viewMtx = glm::rotate(viewMtx, DegToRad(cam_X_rot), glm::vec3(1.0f, 0.0f, 0.0f));
+
+    GX2InitSampler(&aaSampler, GX2_TEX_CLAMP_MODE_CLAMP, GX2_TEX_XY_FILTER_MODE_LINEAR);
+    GX2InitTexture(&tvAaTexture, tvColorBuffer.surface.width, tvColorBuffer.surface.height, 1, 0, GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8, GX2_SURFACE_DIM_TEXTURE_2D, GX2_TILE_MODE_DEFAULT);
+    tvAaTexture.surface.image     = tvColorBuffer.surface.image;
+    tvAaTexture.surface.imageSize = tvColorBuffer.surface.imageSize;
+    tvAaTexture.surface.mipmaps   = tvColorBuffer.surface.mipmaps;
+}
+
+CVideo::~CVideo() {
+    //! flush buffers
+    GX2Flush();
+    GX2DrawDone();
+    //! shutdown
+    GX2Shutdown();
+    //! free command buffer memory
+    MEM2_free(gx2CommandBuffer);
+    //! free scan buffers
+    MEMBucket_free(tvScanBuffer);
+    MEMBucket_free(drcScanBuffer);
+    //! free color buffers
+    MEM1_free(tvColorBuffer.surface.image);
+    MEM1_free(drcColorBuffer.surface.image);
+    //! free depth buffers
+    MEM1_free(tvDepthBuffer.surface.image);
+    MEM1_free(tvDepthBuffer.hiZPtr);
+    MEM1_free(drcDepthBuffer.surface.image);
+    MEM1_free(drcDepthBuffer.hiZPtr);
+    //! free context buffers
+    MEM2_free(tvContextState);
+    MEM2_free(drcContextState);
+    //! free aux buffer
+    if (tvColorBuffer.aaBuffer) {
+        if (((uint32_t) tvColorBuffer.aaBuffer & 0xF0000000) == 0xF0000000) {
+            MEM1_free(tvColorBuffer.aaBuffer);
+        } else {
+            MEM2_free(tvColorBuffer.aaBuffer);
+        }
+    }
+    if (drcColorBuffer.aaBuffer) {
+        if (((uint32_t) drcColorBuffer.aaBuffer & 0xF0000000) == 0xF0000000) {
+            MEM1_free(drcColorBuffer.aaBuffer);
+        } else {
+            MEM2_free(drcColorBuffer.aaBuffer);
+        }
+    }
+    //! destroy shaders
+    ColorShader::destroyInstance();
+    FXAAShader::destroyInstance();
+    Shader3D::destroyInstance();
+    ShaderFractalColor::destroyInstance();
+    Texture2DShader::destroyInstance();
+}
+
+void CVideo::renderFXAA(const GX2Texture *texture, const GX2Sampler *sampler) {
+    resolution[0] = texture->surface.width;
+    resolution[1] = texture->surface.height;
+
+    GX2Invalidate((GX2InvalidateMode) (GX2_INVALIDATE_MODE_COLOR_BUFFER | GX2_INVALIDATE_MODE_TEXTURE), texture->surface.image, texture->surface.imageSize);
+
+    GX2SetDepthOnlyControl(GX2_ENABLE, GX2_ENABLE, GX2_COMPARE_FUNC_ALWAYS);
+    FXAAShader::instance()->setShaders();
+    FXAAShader::instance()->setAttributeBuffer();
+    FXAAShader::instance()->setResolution(resolution);
+    FXAAShader::instance()->setTextureAndSampler(texture, sampler);
+    FXAAShader::instance()->draw();
+    GX2SetDepthOnlyControl(GX2_ENABLE, GX2_ENABLE, GX2_COMPARE_FUNC_LEQUAL);
+}

src/video/CVideo.h

@@ -0,0 +1,213 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef __CVIDEO_H_
+#define __CVIDEO_H_
+
+#include <gui/gx2_ext.h>
+#include <gx2/clear.h>
+#include <gx2/context.h>
+#include <gx2/display.h>
+#include <gx2/draw.h>
+#include <gx2/event.h>
+#include <gx2/registers.h>
+#include <gx2/sampler.h>
+#include <gx2/state.h>
+#include <gx2/swap.h>
+
+#include <video/shaders/Shader.h>
+
+class CVideo {
+public:
+    CVideo(int32_t forceTvScanMode = -1, int32_t forceDrcScanMode = -1);
+
+    virtual ~CVideo();
+
+    void prepareTvRendering(void) {
+        currContextState = tvContextState;
+        currColorBuffer  = &tvColorBuffer;
+        currDepthBuffer  = &tvDepthBuffer;
+        prepareRendering();
+    }
+
+    void prepareDrcRendering(void) {
+        currContextState = drcContextState;
+        currColorBuffer  = &drcColorBuffer;
+        currDepthBuffer  = &drcDepthBuffer;
+        prepareRendering();
+    }
+
+    void prepareRendering(void) {
+        GX2ClearColor(currColorBuffer, 0.0f, 0.0f, 0.0f, 1.0f);
+        GX2ClearDepthStencilEx(currDepthBuffer, currDepthBuffer->depthClear, currDepthBuffer->stencilClear, GX2_CLEAR_FLAGS_BOTH);
+
+        GX2SetContextState(currContextState);
+        GX2SetViewport(0.0f, 0.0f, currColorBuffer->surface.width, currColorBuffer->surface.height, 0.0f, 1.0f);
+        GX2SetScissor(0, 0, currColorBuffer->surface.width, currColorBuffer->surface.height);
+
+        GX2SetDepthOnlyControl(GX2_ENABLE, GX2_ENABLE, GX2_COMPARE_FUNC_LEQUAL);
+        GX2SetColorControl(GX2_LOGIC_OP_COPY, 1, GX2_DISABLE, GX2_ENABLE);
+        GX2SetBlendControl(GX2_RENDER_TARGET_0, GX2_BLEND_MODE_SRC_ALPHA, GX2_BLEND_MODE_INV_SRC_ALPHA, GX2_BLEND_COMBINE_MODE_ADD, GX2_ENABLE, GX2_BLEND_MODE_SRC_ALPHA, GX2_BLEND_MODE_INV_SRC_ALPHA, GX2_BLEND_COMBINE_MODE_ADD);
+        GX2SetCullOnlyControl(GX2_FRONT_FACE_CCW, GX2_DISABLE, GX2_ENABLE);
+    }
+
+    void setStencilRender(bool bEnable) {
+        if (bEnable) {
+            GX2SetStencilMask(0xff, 0xff, 0x01, 0xff, 0xff, 0x01);
+            GX2SetDepthStencilControl(GX2_DISABLE, GX2_DISABLE, GX2_COMPARE_FUNC_LEQUAL, GX2_ENABLE, GX2_ENABLE, GX2_COMPARE_FUNC_ALWAYS, GX2_STENCIL_FUNCTION_KEEP, GX2_STENCIL_FUNCTION_KEEP, GX2_STENCIL_FUNCTION_REPLACE,
+                                      GX2_COMPARE_FUNC_ALWAYS, GX2_STENCIL_FUNCTION_KEEP, GX2_STENCIL_FUNCTION_KEEP, GX2_STENCIL_FUNCTION_REPLACE);
+        } else {
+            GX2SetStencilMask(0xff, 0xff, 0xff, 0xff, 0xff, 0xff);
+            GX2SetDepthStencilControl(GX2_ENABLE, GX2_ENABLE, GX2_COMPARE_FUNC_LEQUAL, GX2_DISABLE, GX2_DISABLE, GX2_COMPARE_FUNC_NEVER, GX2_STENCIL_FUNCTION_KEEP, GX2_STENCIL_FUNCTION_KEEP, GX2_STENCIL_FUNCTION_KEEP,
+                                      GX2_COMPARE_FUNC_NEVER, GX2_STENCIL_FUNCTION_KEEP, GX2_STENCIL_FUNCTION_KEEP, GX2_STENCIL_FUNCTION_KEEP);
+        }
+    }
+
+    void drcDrawDone(void) {
+        //! on DRC we do a hardware AA because FXAA does not look good
+        //renderFXAA(&drcAaTexture, &aaSampler);
+        GX2CopyColorBufferToScanBuffer(&drcColorBuffer, GX2_SCAN_TARGET_DRC);
+    }
+
+    void tvDrawDone(void) {
+        renderFXAA(&tvAaTexture, &aaSampler);
+        GX2CopyColorBufferToScanBuffer(&tvColorBuffer, GX2_SCAN_TARGET_TV);
+        GX2SwapScanBuffers();
+        GX2Flush();
+    }
+
+    void waitForVSync(void) {
+        GX2WaitForVsync();
+        frameCount++;
+    }
+
+    void tvEnable(bool bEnable) {
+        if (tvEnabled != bEnable) {
+            GX2SetTVEnable(bEnable ? GX2_ENABLE : GX2_DISABLE);
+            tvEnabled = bEnable;
+        }
+    }
+
+    void drcEnable(bool bEnable) {
+        if (drcEnabled != bEnable) {
+            GX2SetDRCEnable(bEnable ? GX2_ENABLE : GX2_DISABLE);
+            drcEnabled = bEnable;
+        }
+    }
+
+    uint32_t getFrameCount(void) const {
+        return frameCount;
+    }
+
+    uint32_t getTvWidth(void) const {
+        return tvColorBuffer.surface.width;
+    }
+
+    uint32_t getTvHeight(void) const {
+        return tvColorBuffer.surface.height;
+    }
+
+    uint32_t getDrcWidth(void) const {
+        return drcColorBuffer.surface.width;
+    }
+
+    uint32_t getDrcHeight(void) const {
+        return drcColorBuffer.surface.height;
+    }
+
+    const glm::mat4 &getProjectionMtx(void) const {
+        return projectionMtx;
+    }
+
+    const glm::mat4 &getViewMtx(void) const {
+        return viewMtx;
+    }
+
+    float getWidthScaleFactor(void) const {
+        return widthScaleFactor;
+    }
+
+    float getHeightScaleFactor(void) const {
+        return heightScaleFactor;
+    }
+
+    float getDepthScaleFactor(void) const {
+        return depthScaleFactor;
+    }
+
+    void screenPosToWorldRay(float posX, float posY, glm::vec3 &rayOrigin, glm::vec3 &rayDirection) {
+        //! normalize positions
+        posX = 2.0f * posX * getWidthScaleFactor();
+        posY = 2.0f * posY * getHeightScaleFactor();
+
+        glm::vec4 rayStart(posX, posY, 0.0f, 1.0f);
+        glm::vec4 rayEnd(posX, posY, 1.0f, 1.0f);
+
+        glm::mat4 IMV           = glm::inverse(projectionMtx * viewMtx);
+        glm::vec4 rayStartWorld = IMV * rayStart;
+        rayStartWorld /= rayStartWorld.w;
+
+        glm::vec4 rayEndWorld = IMV * rayEnd;
+        rayEndWorld /= rayEndWorld.w;
+
+        glm::vec3 rayDirectionWorld(rayEndWorld - rayStartWorld);
+        rayDirectionWorld = glm::normalize(rayDirectionWorld);
+
+        rayOrigin    = glm::vec3(rayStartWorld);
+        rayDirection = glm::normalize(rayDirectionWorld);
+    }
+
+private:
+    static void *GX2RAlloc(uint32_t flags, uint32_t size, uint32_t align);
+
+    static void GX2RFree(uint32_t flags, void *p);
+
+    void renderFXAA(const GX2Texture *texture, const GX2Sampler *sampler);
+
+    void *gx2CommandBuffer;
+
+    void *tvScanBuffer;
+    void *drcScanBuffer;
+
+    uint32_t frameCount;
+    float widthScaleFactor;
+    float heightScaleFactor;
+    float depthScaleFactor;
+
+    bool tvEnabled;
+    bool drcEnabled;
+
+    GX2ColorBuffer tvColorBuffer;
+    GX2DepthBuffer tvDepthBuffer;
+    GX2ColorBuffer drcColorBuffer;
+    GX2DepthBuffer drcDepthBuffer;
+
+    GX2ContextState *tvContextState;
+    GX2ContextState *drcContextState;
+
+    GX2ContextState *currContextState;
+    GX2ColorBuffer *currColorBuffer;
+    GX2DepthBuffer *currDepthBuffer;
+
+    GX2Texture tvAaTexture;
+    GX2Sampler aaSampler;
+
+    glm::mat4 projectionMtx;
+    glm::mat4 viewMtx;
+    glm::vec2 resolution;
+};
+
+#endif // __GX2_VIDEO_H_

src/video/CursorDrawer.cpp

@@ -0,0 +1,83 @@
+/****************************************************************************
+ * Copyright (C) 2016,2017 Maschell
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <video/CursorDrawer.h>
+#include <video/shaders/ColorShader.h>
+#include <video/shaders/FXAAShader.h>
+#include <video/shaders/Shader3D.h>
+#include <video/shaders/ShaderFractalColor.h>
+#include <video/shaders/Texture2DShader.h>
+
+CursorDrawer *CursorDrawer::instance = NULL;
+
+CursorDrawer::CursorDrawer() {
+    init_colorVtxs();
+}
+
+CursorDrawer::~CursorDrawer() {
+    //! destroy shaders
+    ColorShader::destroyInstance();
+    FXAAShader::destroyInstance();
+    Shader3D::destroyInstance();
+    ShaderFractalColor::destroyInstance();
+    Texture2DShader::destroyInstance();
+    if (this->colorVtxs) {
+        free(this->colorVtxs);
+        this->colorVtxs = NULL;
+    }
+}
+
+void CursorDrawer::init_colorVtxs() {
+    if (!this->colorVtxs) {
+        this->colorVtxs = (uint8_t *) memalign(0x40, sizeof(uint8_t) * 16);
+        if (this->colorVtxs == NULL) { return; }
+    }
+    memset(this->colorVtxs, 0xFF, 16 * sizeof(uint8_t));
+
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, this->colorVtxs, 16 * sizeof(uint8_t));
+}
+
+// Could be improved. It be more generic.
+void CursorDrawer::draw_Cursor(float x, float y) {
+    if (this->colorVtxs == NULL) {
+        init_colorVtxs();
+        return;
+    }
+
+    float widthScaleFactor  = 1.0f / (float) 1280;
+    float heightScaleFactor = 1.0f / (float) 720;
+
+    int32_t width = 20;
+
+    glm::vec3 positionOffsets = glm::vec3(0.0f);
+
+    positionOffsets[0] = (x - ((1280) / 2) + (width / 2)) * widthScaleFactor * 2.0f;
+    positionOffsets[1] = -(y - ((720) / 2) + (width / 2)) * heightScaleFactor * 2.0f;
+
+    glm::vec3 scale(width * widthScaleFactor, width * heightScaleFactor, 1.0f);
+
+    ColorShader::instance()->setShaders();
+    ColorShader::instance()->setAttributeBuffer(this->colorVtxs, NULL, 4);
+    ColorShader::instance()->setAngle(0);
+    ColorShader::instance()->setOffset(positionOffsets);
+    ColorShader::instance()->setScale(scale);
+    ColorShader::instance()->setColorIntensity(glm::vec4(1.0f));
+    ColorShader::instance()->draw(GX2_PRIMITIVE_MODE_QUADS, 4);
+}

src/video/CursorDrawer.h

@@ -0,0 +1,64 @@
+/****************************************************************************
+ * Copyright (C) 2016,2017 Maschell
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef _CursorDrawer_H_
+#define _CursorDrawer_H_
+
+#include <string>
+
+#include <stdint.h>
+#include <stdio.h>
+
+class CursorDrawer {
+
+public:
+    static CursorDrawer *getInstance() {
+        if (!instance) {
+            instance = new CursorDrawer();
+        }
+        return instance;
+    }
+
+    static void destroyInstance() {
+        if (instance) {
+            delete instance;
+            instance = NULL;
+        }
+    }
+
+    static void draw(float x, float y) {
+        CursorDrawer *cur_instance = getInstance();
+        if (cur_instance == NULL) { return; }
+        cur_instance->draw_Cursor(x, y);
+    }
+
+private:
+    //!Constructor
+    CursorDrawer();
+
+    //!Destructor
+    ~CursorDrawer();
+
+    static CursorDrawer *instance;
+
+    void draw_Cursor(float x, float y);
+
+    void init_colorVtxs();
+
+    uint8_t *colorVtxs = NULL;
+};
+
+#endif

src/video/shaders/ColorShader.cpp

@@ -0,0 +1,171 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <video/shaders/ColorShader.h>
+#include <malloc.h>
+#include <string.h>
+
+static const uint32_t cpVertexShaderProgram[] = {
+        0x00000000, 0x00008009, 0x20000000, 0x000078a0,
+        0x3c200000, 0x88060094, 0x00c00000, 0x88062014,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00a11f00, 0xfc00620f, 0x02490001, 0x80000040,
+        0xfd041f80, 0x900c0060, 0x83f9223e, 0x0000803f,
+        0xfe282001, 0x10000040, 0xfe001f80, 0x00080060,
+        0xfeac9f80, 0xfd00624f, 0xdb0f49c0, 0xdb0fc940,
+        0xfea81f80, 0x9000e02f, 0x83f9223e, 0x00000000,
+        0xfe041f80, 0x00370000, 0xffa01f00, 0x80000000,
+        0xff101f00, 0x800c0020, 0x7f041f80, 0x80370000,
+        0x0000103f, 0x00000000, 0x02c51f00, 0x80000000,
+        0xfea41f00, 0x80000020, 0xffa09f00, 0x80000040,
+        0xff001f80, 0x800c0060, 0x398ee33f, 0x0000103f,
+        0x02c41f00, 0x9000e00f, 0x02c59f01, 0x80000020,
+        0xfea81f00, 0x80000040, 0x02c19f80, 0x9000e06f,
+        0x398ee33f, 0x00000000, 0x02c11f01, 0x80000000,
+        0x02c49f80, 0x80000060, 0x02e08f01, 0xfe0c620f,
+        0x02c01f80, 0x7f00622f, 0xfe242000, 0x10000000,
+        0xfe20a080, 0x10000020, 0xf2178647, 0x49c0e9fb,
+        0xfbbdb2ab, 0x768ac733};
+
+static const uint32_t cpVertexShaderRegs[] = {
+        0x00000103, 0x00000000, 0x00000000, 0x00000001,
+        0xffffff00, 0xffffffff, 0xffffffff, 0xffffffff,
+        0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+        0xffffffff, 0xffffffff, 0x00000000, 0xfffffffc,
+        0x00000002, 0x00000001, 0x00000000, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x00000000, 0x0000000e, 0x00000010};
+
+static const uint32_t cpPixelShaderProgram[] = {
+        0x20000000, 0x00000ca0, 0x00000000, 0x88062094,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00002000, 0x90000000, 0x0004a000, 0x90000020,
+        0x00082001, 0x90000040, 0x000ca081, 0x90000060,
+        0xbb7dd898, 0x9746c59c, 0xc69b00e7, 0x03c36218};
+static const uint32_t cpPixelShaderRegs[] = {
+        0x00000001, 0x00000002, 0x14000001, 0x00000000,
+        0x00000001, 0x00000100, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x0000000f, 0x00000001, 0x00000010,
+        0x00000000};
+
+ColorShader *ColorShader::shaderInstance = NULL;
+
+ColorShader::ColorShader()
+    : vertexShader(cuAttributeCount) {
+    //! create pixel shader
+    pixelShader.setProgram(cpPixelShaderProgram, sizeof(cpPixelShaderProgram), cpPixelShaderRegs, sizeof(cpPixelShaderRegs));
+
+    colorIntensityLocation = 0;
+    pixelShader.addUniformVar((GX2UniformVar){
+            "unf_color_intensity", GX2_SHADER_VAR_TYPE_FLOAT4, 1, colorIntensityLocation, -1});
+
+    //! create vertex shader
+    vertexShader.setProgram(cpVertexShaderProgram, sizeof(cpVertexShaderProgram), cpVertexShaderRegs, sizeof(cpVertexShaderRegs));
+
+    angleLocation  = 0;
+    offsetLocation = 4;
+    scaleLocation  = 8;
+    vertexShader.addUniformVar((GX2UniformVar){
+            "unf_angle", GX2_SHADER_VAR_TYPE_FLOAT, 1, angleLocation, -1});
+    vertexShader.addUniformVar((GX2UniformVar){
+            "unf_offset", GX2_SHADER_VAR_TYPE_FLOAT3, 1, offsetLocation, -1});
+    vertexShader.addUniformVar((GX2UniformVar){
+            "unf_scale", GX2_SHADER_VAR_TYPE_FLOAT3, 1, scaleLocation, -1});
+
+    colorLocation    = 1;
+    positionLocation = 0;
+    vertexShader.addAttribVar((GX2AttribVar){
+            "attr_color", GX2_SHADER_VAR_TYPE_FLOAT4, 0, colorLocation});
+    vertexShader.addAttribVar((GX2AttribVar){
+            "attr_position", GX2_SHADER_VAR_TYPE_FLOAT3, 0, positionLocation});
+
+    //! setup attribute streams
+    GX2InitAttribStream(vertexShader.getAttributeBuffer(0), positionLocation, 0, 0, GX2_ATTRIB_FORMAT_FLOAT_32_32_32);
+    GX2InitAttribStream(vertexShader.getAttributeBuffer(1), colorLocation, 1, 0, GX2_ATTRIB_FORMAT_UNORM_8_8_8_8);
+
+    //! create fetch shader
+    fetchShader = new FetchShader(vertexShader.getAttributeBuffer(), vertexShader.getAttributesCount());
+
+    //! model vertex has to be align and cannot be in unknown regions for GX2 like 0xBCAE1000
+    positionVtxs = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, cuPositionVtxsSize);
+    if (positionVtxs) {
+        //! position vertex structure
+        int32_t i         = 0;
+        positionVtxs[i++] = -1.0f;
+        positionVtxs[i++] = -1.0f;
+        positionVtxs[i++] = 0.0f;
+        positionVtxs[i++] = 1.0f;
+        positionVtxs[i++] = -1.0f;
+        positionVtxs[i++] = 0.0f;
+        positionVtxs[i++] = 1.0f;
+        positionVtxs[i++] = 1.0f;
+        positionVtxs[i++] = 0.0f;
+        positionVtxs[i++] = -1.0f;
+        positionVtxs[i++] = 1.0f;
+        positionVtxs[i++] = 0.0f;
+        GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, positionVtxs, cuPositionVtxsSize);
+    }
+}
+
+ColorShader::~ColorShader() {
+    if (positionVtxs) {
+        free(positionVtxs);
+        positionVtxs = NULL;
+    }
+
+    delete fetchShader;
+    fetchShader = NULL;
+}

src/video/shaders/ColorShader.h

@@ -0,0 +1,98 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef __COLOR_SHADER_H_
+#define __COLOR_SHADER_H_
+
+#include <video/shaders/FetchShader.h>
+#include <video/shaders/PixelShader.h>
+#include <video/shaders/VertexShader.h>
+
+class ColorShader : public Shader {
+private:
+    ColorShader();
+
+    virtual ~ColorShader();
+
+    static const uint32_t cuAttributeCount   = 2;
+    static const uint32_t cuPositionVtxsSize = 4 * cuVertexAttrSize;
+
+    static ColorShader *shaderInstance;
+
+    FetchShader *fetchShader;
+    VertexShader vertexShader;
+    PixelShader pixelShader;
+
+    float *positionVtxs;
+
+    uint32_t angleLocation;
+    uint32_t offsetLocation;
+    uint32_t scaleLocation;
+    uint32_t colorLocation;
+    uint32_t colorIntensityLocation;
+    uint32_t positionLocation;
+
+public:
+    static const uint32_t cuColorVtxsSize = 4 * cuColorAttrSize;
+
+    static ColorShader *instance() {
+        if (!shaderInstance) {
+            shaderInstance = new ColorShader();
+        }
+        return shaderInstance;
+    }
+
+    static void destroyInstance() {
+        if (shaderInstance) {
+            delete shaderInstance;
+            shaderInstance = NULL;
+        }
+    }
+
+    void setShaders(void) const {
+        fetchShader->setShader();
+        vertexShader.setShader();
+        pixelShader.setShader();
+    }
+
+    void setAttributeBuffer(const uint8_t *colorAttr, const float *posVtxs_in = NULL, const uint32_t &vtxCount = 0) const {
+        if (posVtxs_in && vtxCount) {
+            VertexShader::setAttributeBuffer(0, vtxCount * cuVertexAttrSize, cuVertexAttrSize, posVtxs_in);
+            VertexShader::setAttributeBuffer(1, vtxCount * cuColorAttrSize, cuColorAttrSize, colorAttr);
+        } else {
+            VertexShader::setAttributeBuffer(0, cuPositionVtxsSize, cuVertexAttrSize, positionVtxs);
+            VertexShader::setAttributeBuffer(1, cuColorVtxsSize, cuColorAttrSize, colorAttr);
+        }
+    }
+
+    void setAngle(const float &val) {
+        VertexShader::setUniformReg(angleLocation, 4, &val);
+    }
+
+    void setOffset(const glm::vec3 &vec) {
+        VertexShader::setUniformReg(offsetLocation, 4, &vec[0]);
+    }
+
+    void setScale(const glm::vec3 &vec) {
+        VertexShader::setUniformReg(scaleLocation, 4, &vec[0]);
+    }
+
+    void setColorIntensity(const glm::vec4 &vec) {
+        PixelShader::setUniformReg(colorIntensityLocation, 4, &vec[0]);
+    }
+};
+
+#endif // __COLOR_SHADER_H_

src/video/shaders/FXAAShader.cpp

@@ -0,0 +1,236 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <video/shaders/FXAAShader.h>
+#include <malloc.h>
+#include <string.h>
+
+static const uint32_t cpVertexShaderProgram[] = {
+        0x00000000, 0x00008009, 0x20000000, 0x000004a0,
+        0x3ca00000, 0x88060094, 0x00400000, 0xff0f2094,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0xfd001f80, 0x900c2060, 0x0000803f, 0x00000000,
+        0xc1a229f5, 0xd0eddc33, 0x426618fd, 0x8509cfe7};
+
+static const uint32_t cpVertexShaderRegs[] = {
+        0x00000102, 0x00000000, 0x00000000, 0x00000001,
+        0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+        0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+        0xffffffff, 0xffffffff, 0x00000000, 0xfffffffe,
+        0x00000001, 0x00000000, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x00000000, 0x0000000e, 0x00000010};
+
+static const uint32_t cpPixelShaderProgram[] = {
+        0x20000000, 0x00003ca0, 0xa0000000, 0x000c8080,
+        0x30000000, 0x000010a1, 0xa8000000, 0x0010c080,
+        0x75000000, 0x000088a0, 0x00800100, 0x88062094,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00241f02, 0x1000e00f, 0x00241f00, 0x1000e02f,
+        0x00201f02, 0x00000040, 0x00201f00, 0x00000060,
+        0x00011f80, 0x10332060, 0xff000000, 0xff102200,
+        0xfd001f00, 0x900cc020, 0xffc09f01, 0x90004040,
+        0xffc01f01, 0x90000060, 0x00051f80, 0x1033a040,
+        0x0000803f, 0x00000000, 0xffe00f00, 0x90004000,
+        0xff008000, 0xff102220, 0xffe08f00, 0x90000440,
+        0x010c0000, 0x010c4660, 0xff008080, 0xff004220,
+        0x01a01f00, 0x00280000, 0x01a49f00, 0x00280020,
+        0x01a81f01, 0x00280040, 0xfd0c1f00, 0x1028e06f,
+        0x00208081, 0x90002000, 0x8716993e, 0xa245163f,
+        0xd578e93d, 0x00000080, 0x03a01f00, 0x00280000,
+        0x03a49f00, 0x00280020, 0x03a81f01, 0x1028e04f,
+        0xfd0c1f00, 0x00280060, 0x00a40081, 0x90002020,
+        0x8716993e, 0xa245163f, 0xd578e93d, 0x00000080,
+        0x04a01f00, 0x00280000, 0x04a49f00, 0x1028a02f,
+        0x04a81f01, 0x00280040, 0xfd0c1f00, 0x00280060,
+        0x7fcc1f80, 0x1000c02f, 0x8716993e, 0xa245163f,
+        0xd578e93d, 0x00000080, 0x02a01f00, 0x1028e00f,
+        0x02a49f00, 0x00280020, 0x02a81f01, 0x00280040,
+        0xfd0c1f00, 0x00280060, 0x7fcc1f80, 0x1000e02f,
+        0x8716993e, 0xa245163f, 0xd578e93d, 0x00000080,
+        0x7dc41f00, 0x00020000, 0x7fec0f01, 0x00020020,
+        0x7fc81f00, 0x00000040, 0x7dc41f00, 0x00000060,
+        0x7fec0f81, 0x9001802f, 0xfef88f00, 0x1000e00f,
+        0xfedc8f00, 0x00000420, 0x7de40f00, 0x80010040,
+        0x7ec49f01, 0x00001060, 0xfec41f80, 0x10024060,
+        0xfed49f00, 0x80020000, 0xfe141f00, 0x900c802f,
+        0xfeac1f00, 0x80000040, 0xfec01f02, 0x80020060,
+        0x7cc41f81, 0x90010060, 0x0000003d, 0x00000000,
+        0xfd001f00, 0x900c6000, 0xfea89f00, 0x80010020,
+        0xfec09f81, 0x00020040, 0x0000803f, 0x0000003e,
+        0xfec41f81, 0x00000020, 0xfe041f80, 0x00330000,
+        0x7fe01f00, 0x80000040, 0x7ce41f80, 0x80000060,
+        0xfea81f00, 0x80010000, 0xfeac1f80, 0x80010020,
+        0x000000c1, 0x00000000, 0xfea01f00, 0x00020040,
+        0xfea41f80, 0x00020060, 0x00000041, 0x00000000,
+        0x05c81f01, 0x9000e00f, 0x01cc9f81, 0x9000e06f,
+        0xfeac1f00, 0x01004200, 0xfea01f00, 0x01044220,
+        0xfeac9f00, 0x01002240, 0xfea09f00, 0x01042260,
+        0xfe8c1f80, 0x01008600, 0xacaa2a3e, 0xaaaa2abe,
+        0x7f9c1f00, 0x0100a200, 0x7f801f00, 0x01048220,
+        0x7f901f80, 0x0104a240, 0x02080001, 0x7000a00f,
+        0x02000000, 0x7000c04f, 0x02048000, 0x7000e06f,
+        0x01a81f80, 0x9000e00f, 0xd578e93d, 0x00000000,
+        0x04a80001, 0x1000c00f, 0x04a48000, 0x00000020,
+        0x04a00000, 0x00000040, 0xfe081f00, 0xe00c0060,
+        0xfe0c1f80, 0xe00c0000, 0x01a41f00, 0x7f00620f,
+        0xfea89f00, 0xfe0c822f, 0xfea49f00, 0xff00a24f,
+        0x7d001f80, 0xe00c0060, 0xa245163f, 0x0000803e,
+        0x7ea01f00, 0xfe0ce20f, 0x01a09f80, 0xfe006a4f,
+        0x0000803e, 0x8716993e, 0xfe088001, 0x9001c00f,
+        0xfe488001, 0x1002e44f, 0xfea01f80, 0x80000000,
+        0xd578e93d, 0x00000000, 0x7ca41f00, 0x00280000,
+        0x7da89f00, 0x00280020, 0xff201f00, 0x00280040,
+        0xfd081f80, 0x00280060, 0x8716993e, 0xa245163f,
+        0x00000080, 0x00000000, 0x7fc81f00, 0x80060000,
+        0xfec00f80, 0x80060060, 0xfec09f81, 0xfb80634f,
+        0xfe888f00, 0x7e886300, 0xfea80f01, 0x7f8c6320,
+        0xfee80f00, 0x7d806340, 0xfe680080, 0x06846f60,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x10000100, 0x01101df0, 0x00008010, 0xecdfea0d,
+        0x10000200, 0x03101df0, 0x00002050, 0xecdfea0d,
+        0x10000000, 0x04101df0, 0x00003071, 0xecdfea0d,
+        0x10000200, 0x02101df0, 0x0000b070, 0xecdfea0d,
+        0x10000200, 0x02101df0, 0x00008010, 0xecdfea0d,
+        0x10000100, 0x00101df0, 0x0000a051, 0xecdfea0d,
+        0x10000400, 0x04101df0, 0x00008010, 0xecdfea0d,
+        0x10000500, 0x05101df0, 0x00000011, 0xecdfea0d,
+        0x10000100, 0x01101df0, 0x00008010, 0xecdfea0d,
+        0xfe2e963a, 0x0269a9a3, 0x38f88096, 0x400cf48b};
+static const uint32_t cpPixelShaderRegs[] = {
+        0x00000007, 0x00000002, 0x04000101, 0x00000000,
+        0x00000001, 0x00000100, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x0000000f, 0x00000001, 0x00000010,
+        0x00000000};
+
+FXAAShader *FXAAShader::shaderInstance = NULL;
+
+FXAAShader::FXAAShader()
+    : vertexShader(cuAttributeCount) {
+    //! create pixel shader
+    pixelShader.setProgram(cpPixelShaderProgram, sizeof(cpPixelShaderProgram), cpPixelShaderRegs, sizeof(cpPixelShaderRegs));
+
+    resolutionLocation = 0;
+    pixelShader.addUniformVar((GX2UniformVar){
+            "unf_resolution", GX2_SHADER_VAR_TYPE_FLOAT2, 1, resolutionLocation, -1});
+
+    samplerLocation = 0;
+    pixelShader.addSamplerVar((GX2SamplerVar){
+            "sampl_texture", GX2_SAMPLER_VAR_TYPE_SAMPLER_2D, samplerLocation});
+
+    //! create vertex shader
+    vertexShader.setProgram(cpVertexShaderProgram, sizeof(cpVertexShaderProgram), cpVertexShaderRegs, sizeof(cpVertexShaderRegs));
+
+    positionLocation = 0;
+    texCoordLocation = 1;
+    vertexShader.addAttribVar((GX2AttribVar){
+            "attr_position", GX2_SHADER_VAR_TYPE_FLOAT3, 0, positionLocation});
+    vertexShader.addAttribVar((GX2AttribVar){
+            "attr_texture_coord", GX2_SHADER_VAR_TYPE_FLOAT2, 0, texCoordLocation});
+
+    //! setup attribute streams
+    GX2InitAttribStream(vertexShader.getAttributeBuffer(0), positionLocation, 0, 0, GX2_ATTRIB_FORMAT_FLOAT_32_32_32);
+    GX2InitAttribStream(vertexShader.getAttributeBuffer(1), texCoordLocation, 1, 0, GX2_ATTRIB_FORMAT_FLOAT_32_32);
+
+    //! create fetch shader
+    fetchShader = new FetchShader(vertexShader.getAttributeBuffer(), vertexShader.getAttributesCount());
+
+    //! model vertex has to be align and cannot be in unknown regions for GX2 like 0xBCAE1000
+    posVtxs   = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciPositionVtxsSize);
+    texCoords = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciTexCoordsVtxsSize);
+
+    //! position vertex structure and texture coordinate vertex structure
+    int32_t i    = 0;
+    posVtxs[i++] = -1.0f;
+    posVtxs[i++] = -1.0f;
+    posVtxs[i++] = 0.0f;
+    posVtxs[i++] = 1.0f;
+    posVtxs[i++] = -1.0f;
+    posVtxs[i++] = 0.0f;
+    posVtxs[i++] = 1.0f;
+    posVtxs[i++] = 1.0f;
+    posVtxs[i++] = 0.0f;
+    posVtxs[i++] = -1.0f;
+    posVtxs[i++] = 1.0f;
+    posVtxs[i++] = 0.0f;
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, posVtxs, ciPositionVtxsSize);
+
+    i              = 0;
+    texCoords[i++] = 0.0f;
+    texCoords[i++] = 1.0f;
+    texCoords[i++] = 1.0f;
+    texCoords[i++] = 1.0f;
+    texCoords[i++] = 1.0f;
+    texCoords[i++] = 0.0f;
+    texCoords[i++] = 0.0f;
+    texCoords[i++] = 0.0f;
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, texCoords, ciTexCoordsVtxsSize);
+}
+
+FXAAShader::~FXAAShader() {
+    if (posVtxs) {
+        free(posVtxs);
+        posVtxs = NULL;
+    }
+    if (texCoords) {
+        free(texCoords);
+        texCoords = NULL;
+    }
+
+    delete fetchShader;
+    fetchShader = NULL;
+}

src/video/shaders/FXAAShader.h

@@ -0,0 +1,84 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef __FXAA_SHADER_H_
+#define __FXAA_SHADER_H_
+
+#include <video/shaders/FetchShader.h>
+#include <video/shaders/PixelShader.h>
+#include <video/shaders/VertexShader.h>
+
+class FXAAShader : public Shader {
+public:
+    static FXAAShader *instance() {
+        if (!shaderInstance) {
+            shaderInstance = new FXAAShader();
+        }
+        return shaderInstance;
+    }
+
+    static void destroyInstance() {
+        if (shaderInstance) {
+            delete shaderInstance;
+            shaderInstance = NULL;
+        }
+    }
+
+    void setShaders(void) const {
+        fetchShader->setShader();
+        vertexShader.setShader();
+        pixelShader.setShader();
+    }
+
+    void setAttributeBuffer() const {
+        VertexShader::setAttributeBuffer(0, ciPositionVtxsSize, cuVertexAttrSize, posVtxs);
+        VertexShader::setAttributeBuffer(1, ciTexCoordsVtxsSize, cuTexCoordAttrSize, texCoords);
+    }
+
+    void setResolution(const glm::vec2 &vec) {
+        PixelShader::setUniformReg(resolutionLocation, 4, &vec[0]);
+    }
+
+    void setTextureAndSampler(const GX2Texture *texture, const GX2Sampler *sampler) const {
+        GX2SetPixelTexture((GX2Texture *) texture, samplerLocation);
+        GX2SetPixelSampler((GX2Sampler *) sampler, samplerLocation);
+    }
+
+private:
+    FXAAShader();
+
+    virtual ~FXAAShader();
+
+    static const uint32_t cuAttributeCount    = 2;
+    static const uint32_t ciPositionVtxsSize  = 4 * cuVertexAttrSize;
+    static const uint32_t ciTexCoordsVtxsSize = 4 * cuTexCoordAttrSize;
+
+    static FXAAShader *shaderInstance;
+
+    FetchShader *fetchShader;
+    VertexShader vertexShader;
+    PixelShader pixelShader;
+
+    float *posVtxs;
+    float *texCoords;
+
+    uint32_t samplerLocation;
+    uint32_t positionLocation;
+    uint32_t texCoordLocation;
+    uint32_t resolutionLocation;
+};
+
+#endif // __FXAA_SHADER_H_

src/video/shaders/FetchShader.h

@@ -0,0 +1,57 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef FETCH_SHADER_H
+#define FETCH_SHADER_H
+
+#include <video/shaders/Shader.h>
+
+class FetchShader : public Shader {
+public:
+    FetchShader(GX2AttribStream *attributes, uint32_t attrCount, GX2FetchShaderType type = GX2_FETCH_SHADER_TESSELLATION_NONE, GX2TessellationMode tess = GX2_TESSELLATION_MODE_DISCRETE)
+        : fetchShader(NULL), fetchShaderProgramm(NULL) {
+        uint32_t shaderSize = GX2CalcFetchShaderSizeEx(attrCount, type, tess);
+        fetchShaderProgramm = (uint8_t *) memalign(GX2_SHADER_PROGRAM_ALIGNMENT, shaderSize);
+        if (fetchShaderProgramm) {
+            fetchShader = new GX2FetchShader;
+            GX2InitFetchShaderEx(fetchShader, fetchShaderProgramm, attrCount, attributes, type, tess);
+            GX2Invalidate(GX2_INVALIDATE_MODE_CPU_SHADER, fetchShaderProgramm, shaderSize);
+        }
+    }
+
+    virtual ~FetchShader() {
+        if (fetchShaderProgramm) {
+            free(fetchShaderProgramm);
+        }
+        if (fetchShader) {
+            delete fetchShader;
+        }
+    }
+
+    GX2FetchShader *getFetchShader() const {
+        return fetchShader;
+    }
+
+    void setShader(void) const {
+        GX2SetFetchShader(fetchShader);
+    }
+
+protected:
+    GX2FetchShader *fetchShader;
+    uint8_t *fetchShaderProgramm;
+};
+
+#endif // FETCH_SHADER_H

src/video/shaders/PixelShader.h

@@ -0,0 +1,152 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef PIXEL_SHADER_H
+#define PIXEL_SHADER_H
+
+#include <video/shaders/Shader.h>
+
+class PixelShader : public Shader {
+public:
+    PixelShader()
+        : pixelShader((GX2PixelShader *) memalign(0x40, sizeof(GX2PixelShader))) {
+        if (pixelShader) {
+            memset(pixelShader, 0, sizeof(GX2PixelShader));
+            pixelShader->mode = GX2_SHADER_MODE_UNIFORM_REGISTER;
+        }
+    }
+
+    virtual ~PixelShader() {
+        if (pixelShader) {
+            if (pixelShader->program) {
+                free(pixelShader->program);
+            }
+
+            for (uint32_t i = 0; i < pixelShader->uniformBlockCount; i++) {
+                free((void *) pixelShader->uniformBlocks[i].name);
+            }
+
+            if (pixelShader->uniformBlocks) {
+                free((void *) pixelShader->uniformBlocks);
+            }
+
+            for (uint32_t i = 0; i < pixelShader->uniformVarCount; i++) {
+                free((void *) pixelShader->uniformVars[i].name);
+            }
+
+            if (pixelShader->uniformVars) {
+                free((void *) pixelShader->uniformVars);
+            }
+
+            if (pixelShader->initialValues) {
+                free((void *) pixelShader->initialValues);
+            }
+
+            for (uint32_t i = 0; i < pixelShader->samplerVarCount; i++) {
+                free((void *) pixelShader->samplerVars[i].name);
+            }
+
+            if (pixelShader->samplerVars) {
+                free((void *) pixelShader->samplerVars);
+            }
+
+            if (pixelShader->loopVars) {
+                free((void *) pixelShader->loopVars);
+            }
+
+            free(pixelShader);
+        }
+    }
+
+    void setProgram(const uint32_t *program, const uint32_t &programSize, const uint32_t *regs, const uint32_t &regsSize) {
+        if (!pixelShader) {
+            return;
+        }
+
+        //! this must be moved into an area where the graphic engine has access to and must be aligned to 0x100
+        pixelShader->size    = programSize;
+        pixelShader->program = (uint8_t *) memalign(GX2_SHADER_PROGRAM_ALIGNMENT, pixelShader->size);
+        if (pixelShader->program) {
+            memcpy(pixelShader->program, program, pixelShader->size);
+            GX2Invalidate(GX2_INVALIDATE_MODE_CPU_SHADER, pixelShader->program, pixelShader->size);
+        }
+
+        memcpy(&pixelShader->regs, regs, regsSize);
+    }
+
+    void addUniformVar(const GX2UniformVar &var) {
+        if (!pixelShader) {
+            return;
+        }
+
+        uint32_t idx = pixelShader->uniformVarCount;
+
+        GX2UniformVar *newVar = (GX2UniformVar *) malloc((pixelShader->uniformVarCount + 1) * sizeof(GX2UniformVar));
+        if (newVar) {
+            if (pixelShader->uniformVars) {
+                memcpy(newVar, pixelShader->uniformVars, pixelShader->uniformVarCount * sizeof(GX2UniformVar));
+                free(pixelShader->uniformVars);
+            }
+            pixelShader->uniformVars = newVar;
+
+            memcpy(pixelShader->uniformVars + idx, &var, sizeof(GX2UniformVar));
+            pixelShader->uniformVars[idx].name = (char *) malloc(strlen(var.name) + 1);
+            strcpy((char *) pixelShader->uniformVars[idx].name, var.name);
+
+            pixelShader->uniformVarCount++;
+        }
+    }
+
+    void addSamplerVar(const GX2SamplerVar &var) {
+        if (!pixelShader) {
+            return;
+        }
+
+        uint32_t idx = pixelShader->samplerVarCount;
+
+        GX2SamplerVar *newVar = (GX2SamplerVar *) malloc((pixelShader->samplerVarCount + 1) * sizeof(GX2SamplerVar));
+        if (newVar) {
+            if (pixelShader->samplerVars) {
+                memcpy(newVar, pixelShader->samplerVars, pixelShader->samplerVarCount * sizeof(GX2SamplerVar));
+                free(pixelShader->samplerVars);
+            }
+            pixelShader->samplerVars = newVar;
+
+            memcpy(pixelShader->samplerVars + idx, &var, sizeof(GX2SamplerVar));
+            pixelShader->samplerVars[idx].name = (char *) malloc(strlen(var.name) + 1);
+            strcpy((char *) pixelShader->samplerVars[idx].name, var.name);
+
+            pixelShader->samplerVarCount++;
+        }
+    }
+
+    GX2PixelShader *getPixelShader() const {
+        return pixelShader;
+    }
+
+    void setShader(void) const {
+        GX2SetPixelShader(pixelShader);
+    }
+
+    static inline void setUniformReg(uint32_t location, uint32_t size, const void *reg) {
+        GX2SetPixelUniformReg(location, size, (uint32_t *) reg);
+    }
+
+protected:
+    GX2PixelShader *pixelShader;
+};
+
+#endif // PIXEL_SHADER_H

src/video/shaders/Shader.h

@@ -0,0 +1,72 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef SHADER_H_
+#define SHADER_H_
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <gx2/draw.h>
+#include <gx2/enum.h>
+#include <gx2/mem.h>
+#include <gx2/registers.h>
+#include <gx2/shaders.h>
+#include <malloc.h>
+
+class Shader {
+protected:
+    Shader() {}
+
+    virtual ~Shader() {}
+
+public:
+    static const uint16_t cuVertexAttrSize   = sizeof(float) * 3;
+    static const uint16_t cuTexCoordAttrSize = sizeof(float) * 2;
+    static const uint16_t cuColorAttrSize    = sizeof(uint8_t) * 4;
+
+    static void setLineWidth(const float &width) {
+        GX2SetLineWidth(width);
+    }
+
+    static void draw(int32_t primitive = GX2_PRIMITIVE_MODE_QUADS, uint32_t vtxCount = 4) {
+        switch (primitive) {
+            default:
+            case GX2_PRIMITIVE_MODE_QUADS: {
+                GX2DrawEx(GX2_PRIMITIVE_MODE_QUADS, vtxCount, 0, 1);
+                break;
+            }
+            case GX2_PRIMITIVE_MODE_TRIANGLES: {
+                GX2DrawEx(GX2_PRIMITIVE_MODE_TRIANGLES, vtxCount, 0, 1);
+                break;
+            }
+            case GX2_PRIMITIVE_MODE_TRIANGLE_FAN: {
+                GX2DrawEx(GX2_PRIMITIVE_MODE_TRIANGLE_FAN, vtxCount, 0, 1);
+                break;
+            }
+            case GX2_PRIMITIVE_MODE_LINES: {
+                GX2DrawEx(GX2_PRIMITIVE_MODE_LINES, vtxCount, 0, 1);
+                break;
+            }
+            case GX2_PRIMITIVE_MODE_LINE_STRIP: {
+                GX2DrawEx(GX2_PRIMITIVE_MODE_LINE_STRIP, vtxCount, 0, 1);
+                break;
+            }
+                //! TODO: add other primitives later
+        };
+    }
+};
+
+#endif // SHADER_H_

src/video/shaders/Shader3D.cpp

@@ -0,0 +1,276 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <video/shaders/Shader3D.h>
+#include <malloc.h>
+#include <string.h>
+
+static const uint32_t cpVertexShaderProgram[] = {
+        0x00000000, 0x00008009, 0x20000000, 0x0000e4a1,
+        0x00c00100, 0x88048093, 0x01c00300, 0x98060014,
+        0x9a000000, 0x000058a0, 0x3c200200, 0x88062094,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x0765a101, 0x9000e00f, 0x0761a101, 0x9000e02f,
+        0x01081f00, 0x900ce040, 0x01041f00, 0x900ce060,
+        0x01001f80, 0x900ce000, 0x02001f00, 0x900c6000,
+        0x02041f00, 0x900c6020, 0x076da101, 0x9000e04f,
+        0x0769a181, 0x9000e06f, 0x0745a101, 0x9000c00f,
+        0x0741a181, 0x9000c02f, 0x074da101, 0x9000c04f,
+        0x0749a181, 0x9000c06f, 0x0bc9a000, 0x7f00e20f,
+        0x0bc92080, 0x7f04e22f, 0x0bc9a001, 0x7f08e24f,
+        0x0bc92081, 0x7f0ce26f, 0x0725a101, 0x9000a00f,
+        0x0721a181, 0x9000a02f, 0x072da101, 0x9000a04f,
+        0x0729a181, 0x9000a06f, 0x0ac9a000, 0x7e00c20f,
+        0x0ac92080, 0x7e04c22f, 0x0ac9a001, 0x7e08c24f,
+        0x0ac92081, 0x7e0cc26f, 0x0ba5a000, 0x7f00e20f,
+        0x0ba52080, 0x7f04e22f, 0x0ba5a001, 0x7f08e24f,
+        0x0ba52081, 0x7f0ce26f, 0x08eda000, 0x9000800f,
+        0x08ed2080, 0x9000802f, 0x08eda001, 0x9000804f,
+        0x08ed2081, 0x9000806f, 0x09c9a000, 0x7d00a20f,
+        0x09c92080, 0x7d04a22f, 0x09c9a001, 0x7d08a24f,
+        0x09c92081, 0x7d0ca26f, 0x0aa5a000, 0x7e00c20f,
+        0x0aa52080, 0x7e04c22f, 0x0aa5a001, 0x7e08c24f,
+        0x0aa52081, 0x7e0cc26f, 0x0b81a000, 0x7f004200,
+        0x0b812080, 0x7f044220, 0x0b81a001, 0x7f082240,
+        0x0b812081, 0x7f0c0260, 0x08c9a000, 0x7c00820f,
+        0x08c92080, 0x7c04822f, 0x08c9a001, 0x7c08824f,
+        0x08c92081, 0x7c0c826f, 0x09a5a000, 0x7d00a20f,
+        0x09a52080, 0x7d04a22f, 0x09a5a001, 0x7d08a24f,
+        0x09a52081, 0x7d0ca26f, 0x0a81a000, 0x7e000200,
+        0x0a812080, 0x7e040220, 0x0a81a001, 0x7e080240,
+        0x0a812081, 0x7e0c2260, 0x0240a001, 0x9000c00f,
+        0x0244a001, 0x9000c02f, 0x0148a001, 0x9000c04f,
+        0x004ca001, 0x9000c06f, 0x0264a081, 0x9000e02f,
+        0x0260a001, 0x9000e00f, 0x0224a001, 0x90002020,
+        0x0168a001, 0x9000e04f, 0x006ca001, 0x9000e06f,
+        0x0220a081, 0x90002000, 0x08a5a000, 0x7c00820f,
+        0x08a52080, 0x7c04822f, 0x08a5a001, 0x7c08824f,
+        0x08a52081, 0x7c0c826f, 0x0981a000, 0x7d008200,
+        0x09812080, 0x7d048220, 0x0981a001, 0x7d084240,
+        0x09812081, 0x7d0c4260, 0x02090000, 0x7e00c20f,
+        0x02098000, 0x7e04c22f, 0x0128a001, 0x9000a04f,
+        0x002ca001, 0x9000c06f, 0x02298081, 0x7e0caa6f,
+        0x03090000, 0x7f00e20f, 0x03098000, 0x7f04e22f,
+        0x02090001, 0x7e08f64f, 0x03298001, 0x7f0ce26f,
+        0x03090081, 0x7f08ca4f, 0x0881a000, 0x7c00c200,
+        0x08812080, 0x7c04e220, 0x0881a001, 0x7c08a240,
+        0x08812081, 0x7c0c8260, 0x0200a001, 0x9000800f,
+        0x0204a001, 0x9000802f, 0x0108a001, 0x9000804f,
+        0x000ca001, 0x9000806f, 0x01098080, 0x0104aa2f,
+        0x01090000, 0x0100a20f, 0x02858000, 0x7e04c22f,
+        0x01090001, 0x7d08a24f, 0x01298081, 0x7e0cc26f,
+        0x02850000, 0x7e00f60f, 0x03858000, 0x7f04622f,
+        0x02450001, 0x7f08e24f, 0x02458001, 0x7d0ca26f,
+        0x03850080, 0x7f00ca0f, 0x00090000, 0x7c004200,
+        0x00098000, 0x7c04b220, 0x03450001, 0x7e08c24f,
+        0x03458001, 0x7f0ce26f, 0x03e18080, 0xfe042620,
+        0x01850000, 0x7d00a200, 0x01858000, 0x7d04622f,
+        0x00090001, 0x7c086240, 0x00298081, 0x7c0c0260,
+        0x02c10000, 0x7f000200, 0x02e18000, 0x7e040620,
+        0x01450001, 0x7d088240, 0x01458001, 0x7e0c6260,
+        0x01e18080, 0xfe04c620, 0x03c10000, 0x7e002200,
+        0x03818001, 0x7f0c4220, 0x02a10001, 0x7f081640,
+        0x02818001, 0x7d0c3660, 0x03a10081, 0x7e082a40,
+        0x07080000, 0x0100c20f, 0x07088000, 0x0104622f,
+        0x00458001, 0x000cea4f, 0x07288081, 0x0204f66f,
+        0x00850000, 0x0200620f, 0x00858000, 0x05046a2f,
+        0x07080001, 0x0108c24f, 0x01818001, 0x030c726f,
+        0x07cc8080, 0xfe04c22f, 0x01c10000, 0x0500660f,
+        0x00e18000, 0xfe04622f, 0x00450001, 0x0308624f,
+        0x07cc9f01, 0x7f0ce26f, 0x00c10080, 0xfe00e60f,
+        0x07cc1f00, 0x7e00660f, 0x00a10001, 0xfe08c22f,
+        0x01a10001, 0x0408624f, 0x00818001, 0x7f086a6f,
+        0x07c09f80, 0x7e048200, 0x07e00f00, 0xfe008220,
+        0x07cc1f01, 0x7e086a4f, 0x07c09f81, 0x7f0c8240,
+        0x07c08f80, 0xfe088260, 0x2c34800d, 0xe3b4f15e,
+        0x7642ed30, 0x7408600d};
+
+static const uint32_t cpVertexShaderRegs[] = {
+        0x00000108, 0x00000000, 0x00000002, 0x00000001,
+        0xffff0001, 0xffffffff, 0xffffffff, 0xffffffff,
+        0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+        0xffffffff, 0xffffffff, 0x00000000, 0xfffffffc,
+        0x00000002, 0x00000000, 0x00000001, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x00000000, 0x0000000e, 0x00000010};
+
+static const uint32_t cPixelShaderProgram[] = {
+        0x20000000, 0x000008a4, 0x03000000, 0x01004085,
+        0x23000000, 0x000044a8, 0x35000000, 0x000000a4,
+        0x06000000, 0x01004085, 0x36000000, 0x00002ca8,
+        0x50000000, 0x0000c080, 0x42000000, 0x00001ca0,
+        0x00800000, 0x88062094, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0xfd001f80, 0x900c0060, 0x0000803f, 0x00000000,
+        0x02011f80, 0x8c110000, 0xf8402000, 0x9006a00f,
+        0x02552001, 0x00000020, 0x01248082, 0x80020060,
+        0xfe3c1f00, 0x1000e04f, 0xfe041f80, 0x1033c00f,
+        0xfe482081, 0x80060020, 0xfee40f81, 0x0289e30f,
+        0x02c51f80, 0x80060060, 0xfeec0f80, 0x0285634f,
+        0xfec80f80, 0x80000060, 0xfe4ca081, 0x9000e04f,
+        0xfe281f00, 0x80060000, 0xf8c01f81, 0x9006e02f,
+        0xfee00f81, 0xfd80636f, 0x0000803f, 0x00000000,
+        0x7fc49f81, 0xf880e34f, 0xfe381f80, 0x00000000,
+        0x7de00f81, 0xfe800360, 0x01011f80, 0x8c100000,
+        0x00a81f00, 0x9000e02f, 0x00000082, 0x80020060,
+        0x00002040, 0x00000000, 0xfeac9f80, 0xfd00624f,
+        0x3333333f, 0x00002040, 0xfee88f80, 0x0101620f,
+        0x00cc1f80, 0x9000e06f, 0xf8c09f01, 0x80060020,
+        0xfe2c1f80, 0x9006e04f, 0xfee48f81, 0xf880630f,
+        0x7fc81f80, 0xfd800360, 0x0000803f, 0x00000000,
+        0x000ca001, 0x80000000, 0x00091f00, 0x800c0020,
+        0x00051f00, 0x800c0040, 0x00011f80, 0x800c0060,
+        0xfe2c0000, 0x90002000, 0xfe288000, 0x90002020,
+        0xfe240001, 0x90002040, 0xfe208081, 0x90002060,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x10000100, 0x01100df0, 0x00008010, 0xecdfea0d,
+        0x99720984, 0x041cab0d, 0xa28a9ccd, 0x95d199a5};
+static const uint32_t cPixelShaderRegs[] = {
+        0x00000102, 0x00000002, 0x14000002, 0x00000000,
+        0x00000002, 0x00000100, 0x00000101, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x0000000f, 0x00000001, 0x00000010,
+        0x00000000};
+
+Shader3D *Shader3D::shaderInstance = NULL;
+
+Shader3D::Shader3D()
+    : vertexShader(cuAttributeCount) {
+    //! create pixel shader
+    pixelShader.setProgram(cPixelShaderProgram, sizeof(cPixelShaderProgram), cPixelShaderRegs, sizeof(cPixelShaderRegs));
+
+    colorIntensityLocation = 0;
+    fadeDistanceLocation   = 4;
+    fadeOutLocation        = 8;
+    pixelShader.addUniformVar((GX2UniformVar){
+            "unf_color_intensity", GX2_SHADER_VAR_TYPE_FLOAT4, 1, colorIntensityLocation, -1});
+    pixelShader.addUniformVar((GX2UniformVar){
+            "unf_fade_distance", GX2_SHADER_VAR_TYPE_FLOAT, 1, fadeDistanceLocation, -1});
+    pixelShader.addUniformVar((GX2UniformVar){
+            "unf_fade_out_alpha", GX2_SHADER_VAR_TYPE_FLOAT4, 1, fadeOutLocation, -1});
+
+    samplerLocation = 0;
+    pixelShader.addSamplerVar((GX2SamplerVar){
+            "sampl_texture", GX2_SAMPLER_VAR_TYPE_SAMPLER_2D, samplerLocation});
+    //! create vertex shader
+    vertexShader.setProgram(cpVertexShaderProgram, sizeof(cpVertexShaderProgram), cpVertexShaderRegs, sizeof(cpVertexShaderRegs));
+
+    modelMatrixLocation      = 0;
+    projectionMatrixLocation = 16;
+    viewMatrixLocation       = 32;
+    vertexShader.addUniformVar((GX2UniformVar){
+            "modelMatrix", GX2_SHADER_VAR_TYPE_FLOAT4X4, 1, modelMatrixLocation, -1});
+    vertexShader.addUniformVar((GX2UniformVar){
+            "viewMatrix", GX2_SHADER_VAR_TYPE_FLOAT4X4, 1, projectionMatrixLocation, -1});
+    vertexShader.addUniformVar((GX2UniformVar){
+            "projectionMatrix", GX2_SHADER_VAR_TYPE_FLOAT4X4, 1, viewMatrixLocation, -1});
+
+    positionLocation = 0;
+    texCoordLocation = 1;
+    vertexShader.addAttribVar((GX2AttribVar){
+            "attr_position", GX2_SHADER_VAR_TYPE_FLOAT4, 0, positionLocation});
+    vertexShader.addAttribVar((GX2AttribVar){
+            "attr_texture_coord", GX2_SHADER_VAR_TYPE_FLOAT2, 0, texCoordLocation});
+
+    //! setup attribute streams
+    GX2InitAttribStream(vertexShader.getAttributeBuffer(0), positionLocation, 0, 0, GX2_ATTRIB_FORMAT_FLOAT_32_32_32);
+    GX2InitAttribStream(vertexShader.getAttributeBuffer(1), texCoordLocation, 1, 0, GX2_ATTRIB_FORMAT_FLOAT_32_32);
+
+    //! create fetch shader
+    fetchShader = new FetchShader(vertexShader.getAttributeBuffer(), vertexShader.getAttributesCount());
+
+    //! initialize default quad texture vertexes as those are very commonly used
+    //! model vertex has to be align and cannot be in unknown regions for GX2 like 0xBCAE1000
+    posVtxs   = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciPositionVtxsSize);
+    texCoords = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciTexCoordsVtxsSize);
+
+    //! position vertex structure and texture coordinate vertex structure
+    int32_t i    = 0;
+    posVtxs[i++] = -1.0f;
+    posVtxs[i++] = -1.0f;
+    posVtxs[i++] = 0.0f;
+    posVtxs[i++] = 1.0f;
+    posVtxs[i++] = -1.0f;
+    posVtxs[i++] = 0.0f;
+    posVtxs[i++] = 1.0f;
+    posVtxs[i++] = 1.0f;
+    posVtxs[i++] = 0.0f;
+    posVtxs[i++] = -1.0f;
+    posVtxs[i++] = 1.0f;
+    posVtxs[i++] = 0.0f;
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, posVtxs, ciPositionVtxsSize);
+
+    i              = 0;
+    texCoords[i++] = 0.0f;
+    texCoords[i++] = 1.0f;
+    texCoords[i++] = 1.0f;
+    texCoords[i++] = 1.0f;
+    texCoords[i++] = 1.0f;
+    texCoords[i++] = 0.0f;
+    texCoords[i++] = 0.0f;
+    texCoords[i++] = 0.0f;
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, texCoords, ciTexCoordsVtxsSize);
+}
+
+Shader3D::~Shader3D() {
+    if (posVtxs) {
+        free(posVtxs);
+        posVtxs = NULL;
+    }
+    if (texCoords) {
+        free(texCoords);
+        texCoords = NULL;
+    }
+
+    delete fetchShader;
+    fetchShader = NULL;
+}

src/video/shaders/Shader3D.h

@@ -0,0 +1,116 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef SHADER_3D_H_
+#define SHADER_3D_H_
+
+#include <video/shaders/FetchShader.h>
+#include <video/shaders/PixelShader.h>
+#include <video/shaders/VertexShader.h>
+
+class Shader3D : public Shader {
+private:
+    Shader3D();
+
+    virtual ~Shader3D();
+
+    static Shader3D *shaderInstance;
+
+    static const unsigned char cuAttributeCount = 2;
+    static const uint32_t ciPositionVtxsSize    = 4 * cuVertexAttrSize;
+    static const uint32_t ciTexCoordsVtxsSize   = 4 * cuTexCoordAttrSize;
+
+    FetchShader *fetchShader;
+    VertexShader vertexShader;
+    PixelShader pixelShader;
+
+    float *posVtxs;
+    float *texCoords;
+
+    uint32_t modelMatrixLocation;
+    uint32_t viewMatrixLocation;
+    uint32_t projectionMatrixLocation;
+    uint32_t positionLocation;
+    uint32_t texCoordLocation;
+
+    uint32_t colorIntensityLocation;
+    uint32_t fadeDistanceLocation;
+    uint32_t fadeOutLocation;
+    uint32_t samplerLocation;
+
+public:
+    static Shader3D *instance() {
+        if (!shaderInstance) {
+            shaderInstance = new Shader3D();
+        }
+        return shaderInstance;
+    }
+
+    static void destroyInstance() {
+        if (shaderInstance) {
+            delete shaderInstance;
+            shaderInstance = NULL;
+        }
+    }
+
+    void setShaders(void) const {
+        fetchShader->setShader();
+        vertexShader.setShader();
+        pixelShader.setShader();
+    }
+
+    void setAttributeBuffer(const uint32_t &vtxCount = 0, const float *posVtxs_in = NULL, const float *texCoords_in = NULL) const {
+        if (posVtxs_in && texCoords_in && vtxCount) {
+            VertexShader::setAttributeBuffer(0, vtxCount * cuVertexAttrSize, cuVertexAttrSize, posVtxs_in);
+            VertexShader::setAttributeBuffer(1, vtxCount * cuTexCoordAttrSize, cuTexCoordAttrSize, texCoords_in);
+        } else {
+            //! use default quad vertex and texture coordinates if nothing is passed
+            VertexShader::setAttributeBuffer(0, ciPositionVtxsSize, cuVertexAttrSize, posVtxs);
+            VertexShader::setAttributeBuffer(1, ciTexCoordsVtxsSize, cuTexCoordAttrSize, texCoords);
+        }
+    }
+
+    void setProjectionMtx(const glm::mat4 &mtx) {
+        VertexShader::setUniformReg(projectionMatrixLocation, 16, &mtx[0][0]);
+    }
+
+    void setViewMtx(const glm::mat4 &mtx) {
+        VertexShader::setUniformReg(viewMatrixLocation, 16, &mtx[0][0]);
+    }
+
+    void setModelViewMtx(const glm::mat4 &mtx) {
+        VertexShader::setUniformReg(modelMatrixLocation, 16, &mtx[0][0]);
+    }
+
+    void setColorIntensity(const glm::vec4 &vec) {
+        PixelShader::setUniformReg(colorIntensityLocation, 4, &vec[0]);
+    }
+
+    void setAlphaFadeOut(const glm::vec4 &vec) {
+        PixelShader::setUniformReg(fadeOutLocation, 4, &vec[0]);
+    }
+
+    void setDistanceFadeOut(const float &value) {
+        PixelShader::setUniformReg(fadeDistanceLocation, 4, &value);
+    }
+
+    void setTextureAndSampler(const GX2Texture *texture, const GX2Sampler *sampler) const {
+        GX2SetPixelTexture((GX2Texture *) texture, samplerLocation);
+        GX2SetPixelSampler((GX2Sampler *) sampler, samplerLocation);
+    }
+};
+
+#endif // SHADER_3D_H_

src/video/shaders/ShaderFractalColor.cpp

@@ -0,0 +1,384 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <video/shaders/ShaderFractalColor.h>
+#include <malloc.h>
+#include <string.h>
+
+static const uint32_t cpVertexShaderProgram[] = {
+        0x00000000, 0x00008009, 0x20000000, 0x0000eca1,
+        0x00c00000, 0x88068093, 0x01400200, 0x9a048013,
+        0x9c000000, 0x000044a0, 0x3c200000, 0x88060094,
+        0x02400000, 0x88062014, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x0765a101, 0x9000e00f, 0x0761a101, 0x9000e02f,
+        0x03001f00, 0x900c8040, 0x03041f80, 0x900c8060,
+        0x076da101, 0x9000e04f, 0x0769a181, 0x9000e06f,
+        0x0745a101, 0x9000c00f, 0x0741a181, 0x9000c02f,
+        0x074da101, 0x9000c04f, 0x0749a181, 0x9000c06f,
+        0x0bc9a000, 0x7f00e20f, 0x0bc92080, 0x7f04e22f,
+        0x0bc9a001, 0x7f08e24f, 0x0bc92081, 0x7f0ce26f,
+        0x0725a101, 0x9000a00f, 0x0721a181, 0x9000a02f,
+        0x072da101, 0x9000a04f, 0x0729a181, 0x9000a06f,
+        0x0ac9a000, 0x7e00c20f, 0x0ac92080, 0x7e04c22f,
+        0x0ac9a001, 0x7e08c24f, 0x0ac92081, 0x7e0cc26f,
+        0x0ba5a000, 0x7f00e20f, 0x0ba52080, 0x7f04e22f,
+        0x0ba5a001, 0x7f08e24f, 0x0ba52081, 0x7f0ce26f,
+        0x08eda000, 0x9000800f, 0x08ed2080, 0x9000802f,
+        0x08eda001, 0x9000804f, 0x08ed2081, 0x9000806f,
+        0x09c9a000, 0x7d00a20f, 0x09c92080, 0x7d04a22f,
+        0x09c9a001, 0x7d08a24f, 0x09c92081, 0x7d0ca26f,
+        0x0aa5a000, 0x7e00c20f, 0x0aa52080, 0x7e04c22f,
+        0x0aa5a001, 0x7e08c24f, 0x0aa52081, 0x7e0cc26f,
+        0x0b81a000, 0x7f006200, 0x0b812080, 0x7f046220,
+        0x0b81a001, 0x7f080240, 0x0b812081, 0x7f0c0260,
+        0x08c9a000, 0x7c00820f, 0x08c92080, 0x7c04822f,
+        0x08c9a001, 0x7c08824f, 0x08c92081, 0x7c0c826f,
+        0x09a5a000, 0x7d00a20f, 0x09a52080, 0x7d04a22f,
+        0x09a5a001, 0x7d08a24f, 0x09a52081, 0x7d0ca26f,
+        0x0a81a000, 0x7e008200, 0x0a812080, 0x7e048220,
+        0x0a81a001, 0x7e086240, 0x0a812081, 0x7e0c4260,
+        0x0340a001, 0x9000c00f, 0x0344a001, 0x9000c02f,
+        0x0048a001, 0x9000c04f, 0x004ca001, 0x9000c06f,
+        0x0364a081, 0x9000e02f, 0x0360a001, 0x9000e00f,
+        0x0324a001, 0x90000020, 0x0068a001, 0x9000e04f,
+        0x006ca001, 0x9000e06f, 0x0320a081, 0x90000000,
+        0x08a5a000, 0x7c00820f, 0x08a52080, 0x7c04822f,
+        0x08a5a001, 0x7c08824f, 0x08a52081, 0x7c0c826f,
+        0x0981a000, 0x7d00a200, 0x09812080, 0x7d04a220,
+        0x0981a001, 0x7d08a240, 0x09812081, 0x7d0c6260,
+        0x02890000, 0x7e00c20f, 0x02898000, 0x7e04c22f,
+        0x0028a001, 0x9000a04f, 0x002ca001, 0x9000c06f,
+        0x02498081, 0x7e0caa6f, 0x03890000, 0x7f00e20f,
+        0x03898000, 0x7f04e22f, 0x02690001, 0x7e08f64f,
+        0x03498001, 0x7f0ce26f, 0x03690081, 0x7f08ca4f,
+        0x0881a000, 0x7c00c200, 0x08812080, 0x7c04c220,
+        0x0881a001, 0x7c08e240, 0x08812081, 0x7c0ca260,
+        0x0300a001, 0x9000800f, 0x0304a001, 0x9000802f,
+        0x0008a001, 0x9000804f, 0x000ca001, 0x9000806f,
+        0x01898080, 0x0004aa2f, 0x01890000, 0x0000a20f,
+        0x02a58000, 0x7e04c22f, 0x01690001, 0x7d08a24f,
+        0x01498081, 0x7e0cc26f, 0x02a50000, 0x7e00f60f,
+        0x03a58000, 0x7f04622f, 0x02a50001, 0x7f08e24f,
+        0x02658001, 0x7d0ca26f, 0x03a50080, 0x7f00ca0f,
+        0x00890000, 0x7c00820f, 0x00898000, 0x7c049220,
+        0x03a50001, 0x7e08c24f, 0x03658001, 0x7f0ce26f,
+        0x03c18080, 0xfe04862f, 0x01a50000, 0x7d008200,
+        0x01a58000, 0x7d04622f, 0x00690001, 0x7c086240,
+        0x00498081, 0x7c0c4260, 0x02c10000, 0x7f00e20f,
+        0x02c18000, 0x7e04c62f, 0x01a50001, 0x7d080240,
+        0x01658001, 0x7e0c0260, 0x01c18080, 0xfe040620,
+        0x03c10000, 0x7e00620f, 0x03a18001, 0x7f0c622f,
+        0x02e10001, 0x7f08764f, 0x02a18001, 0x7d0c766f,
+        0x03e10081, 0x7e084a0f, 0x02e80f00, 0xfe000e00,
+        0x02c88f00, 0x7c046220, 0x02c81f01, 0xff00c240,
+        0x02c89f01, 0xfe04c260, 0x00a50080, 0x7c00aa00,
+        0x01c10000, 0x0400760f, 0x00a58000, 0x0404622f,
+        0x00a50001, 0x0308e24f, 0x00658001, 0x020c626f,
+        0x00c10080, 0x0500ea0f, 0x02c41f00, 0x0000620f,
+        0x00c18000, 0xfe04c22f, 0x01e10001, 0x0008624f,
+        0x01a18001, 0x000c666f, 0x00a18081, 0xfe0ce66f,
+        0x00e10001, 0x7f08620f, 0x02048000, 0x03046a2f,
+        0x02c41f01, 0x06086a4f, 0x02c49f01, 0x060c6a6f,
+        0x02e00f80, 0xfe000220, 0x02c08f00, 0xfe040200,
+        0x02e08f01, 0xfe0c0240, 0x02c01f80, 0xfe080260,
+        0x8aa480ad, 0x2bfc5ca6, 0xb5e05b5b, 0xd48dc71c};
+
+static const uint32_t cpVertexShaderRegs[] = {
+        0x00000108, 0x00000000, 0x00000004, 0x00000001,
+        0xff000201, 0xffffffff, 0xffffffff, 0xffffffff,
+        0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+        0xffffffff, 0xffffffff, 0x00000000, 0xfffffff8,
+        0x00000003, 0x00000001, 0x00000000, 0x00000002,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x00000000, 0x0000000e, 0x00000010};
+
+static const uint32_t cpPixelShaderProgram[] = {
+        0x20000000, 0x000008a4, 0x04000000, 0x01004085,
+        0x23000000, 0x0000eca1, 0x9f000000, 0x0000e0a8,
+        0xd8000000, 0x000000a4, 0x07000000, 0x01004085,
+        0xd9000000, 0x000048a8, 0xec000000, 0x000000a4,
+        0x0a000000, 0x01004085, 0xed000000, 0x000050a8,
+        0x02010000, 0x000030a0, 0x00000000, 0x88062094,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0xfd001f80, 0x900c0060, 0x0000803f, 0x00000000,
+        0x03011f80, 0x8c210000, 0xfd001f00, 0x900c0000,
+        0xfd001f00, 0x900ca02f, 0x00000002, 0x80020040,
+        0x00048002, 0x80020060, 0xf8001f80, 0x900cc04f,
+        0x0000803f, 0x00000000, 0xfea81f00, 0x9000e00f,
+        0xfeac1f00, 0x9000e02f, 0xf8001f00, 0x900c804f,
+        0xf8001f80, 0x900ca06f, 0x00000040, 0x00000000,
+        0xfea01f00, 0x00280000, 0xfea41f00, 0x00280020,
+        0xfe041f00, 0x00280040, 0xfd041f80, 0x00280060,
+        0xaf67bb3e, 0x00000080, 0x7fc41f00, 0x00000000,
+        0x7fc01f80, 0x00000020, 0xfe041f00, 0x100ac00f,
+        0xfe001f80, 0x100ac02f, 0xfea01f00, 0x00280000,
+        0xfea41f00, 0x00280020, 0xfe041f00, 0x00280040,
+        0xfd041f00, 0x1028e06f, 0x7fc01f82, 0x00000000,
+        0x8c65583e, 0x00000080, 0x7ea41f00, 0x80000000,
+        0x7ea01f00, 0x80000020, 0xfee01f00, 0x10006040,
+        0x7fc48f82, 0x00000860, 0xa7c4623b, 0x00000000,
+        0xfea81f00, 0x1000e00f, 0x7fcc9f01, 0x10006020,
+        0xfe001f00, 0x000a0040, 0xfe041f00, 0x000a0060,
+        0xfea89f80, 0x10008040, 0x8c65583e, 0x3acd13bf,
+        0xfeb81f00, 0x7e04c20f, 0xfebc1f00, 0x7e00822f,
+        0x03c89f00, 0x80060040, 0xfea49f00, 0x1000e06f,
+        0xfea41f81, 0x10006060, 0x00809043, 0x8c65583e,
+        0x3acd13bf, 0x00000000, 0xfea81f00, 0xf880a30f,
+        0xfe001f00, 0x900ca02f, 0x7dc41f00, 0x1000e04f,
+        0xfe081f00, 0xfd80636f, 0x04081f80, 0x900c800f,
+        0x0000803f, 0x00000000, 0xfea81f00, 0xf900620f,
+        0xfea41f00, 0xf900622f, 0xfe0c1f00, 0x900ca04f,
+        0xfec00f00, 0x1000c46f, 0xfefc0f80, 0x10006000,
+        0x00000842, 0x00000000, 0xfeac1f00, 0xf900620f,
+        0x7fc81f00, 0x9000c02f, 0x7dc49f00, 0x9000e04f,
+        0x7df08f01, 0x10008060, 0x030c1f80, 0x900ca02f,
+        0x00000842, 0x00000000, 0xfea41f00, 0x80000000,
+        0x7ecc1f00, 0x9000e02f, 0x7e688000, 0x80000040,
+        0xfea81f00, 0x80000060, 0x7d6c8081, 0x80000000,
+        0xa7c4623b, 0x00000000, 0xfe001f00, 0x000a0000,
+        0xfe0c1f00, 0x000a0020, 0xfea41f00, 0x80000040,
+        0x03648000, 0xfe08626f, 0x7d648081, 0xff00420f,
+        0xa7c4623b, 0x00000000, 0xfeb01f00, 0x7e04620f,
+        0xfeb41f00, 0x7f08662f, 0x7c800001, 0xff006e4f,
+        0xfe081f00, 0x000a0060, 0x03680081, 0xfe0c4e0f,
+        0x00809043, 0x00000000, 0xfebc1f00, 0x7f04620f,
+        0x7cc41f00, 0x00000020, 0x7cc49f00, 0x1000e04f,
+        0xff901f00, 0x00000060, 0xfe981f80, 0x00000000,
+        0x00809043, 0x00000000, 0xfea81f00, 0xf900620f,
+        0x7cc41f00, 0x00000020, 0x00c09f00, 0x1000c04f,
+        0xfe0c1f00, 0x80010060, 0xff001f80, 0x80010000,
+        0x00000842, 0x00000000, 0xfea81f00, 0xf900620f,
+        0xfecc9f01, 0x80000020, 0x7fc81f00, 0x9000e04f,
+        0x7dc89f00, 0x1000c86f, 0xffe01f80, 0x80000000,
+        0x00000842, 0x00000000, 0xfeac1f00, 0xf900620f,
+        0x7ec81f00, 0x9000802f, 0xfec49f00, 0x9000a040,
+        0xfea89f00, 0x80000060, 0xffe01f80, 0x9000a060,
+        0x00000842, 0xa7c4623b, 0xfea41f00, 0x80000000,
+        0x7ecc1f00, 0x9000e02f, 0xfe0c1f00, 0x000a0040,
+        0x7c888081, 0x80000000, 0xa7c4623b, 0x00000000,
+        0xfe001f00, 0x000a0000, 0xfeb81f00, 0x7f08622f,
+        0xfea49f00, 0x80000040, 0x048c8081, 0xff00420f,
+        0x00809043, 0xa7c4623b, 0xfeb01f00, 0x7c04620f,
+        0x03600000, 0xff00622f, 0xfea49f00, 0x80000040,
+        0xfe081f80, 0x000a0060, 0x00809043, 0x0ccec73c,
+        0xfebc1f00, 0x7f040200, 0xfea09f00, 0x90000020,
+        0xfe941f00, 0x10000040, 0xfe081f80, 0x30080060,
+        0x00809043, 0x0ccec73c, 0x00041f00, 0x20080000,
+        0x00a01f00, 0x80000020, 0x002c1f02, 0x1000e04f,
+        0x00081f80, 0x80010060, 0x0ccec73c, 0x00000000,
+        0xfe201f02, 0x1000800f, 0xfec81f03, 0x80020020,
+        0xfe041f00, 0x20080040, 0xfe881f00, 0x00000060,
+        0xfecc9f81, 0x9000a06f, 0xfe0c1f00, 0x000a0000,
+        0xfe801f00, 0x00000020, 0xfec01f02, 0x80020040,
+        0xfe281f02, 0x1000c06f, 0xfe841f82, 0x1000804f,
+        0xfe041f00, 0x000a0000, 0x7fc81f02, 0x00000020,
+        0xfe8c1f00, 0x00000040, 0xfecc9f03, 0x80020060,
+        0xfe881f82, 0x1000a00f, 0x7cc01f02, 0x00000000,
+        0xfe8c1f02, 0x1000e02f, 0xfec49f00, 0x80000040,
+        0xfe081f00, 0x000a0060, 0x03c89f80, 0x9000e04f,
+        0x7ecc9f03, 0x00000000, 0xfec01f00, 0x80000020,
+        0x04c81f00, 0x80000040, 0x7c880f01, 0xfe086a6f,
+        0x7dac8f81, 0x9000800f, 0x7da00f00, 0xfe04620f,
+        0xfec01f00, 0x80000020, 0x03c01f00, 0x80000840,
+        0x03ac0f00, 0xfe08c66f, 0xfebc9f80, 0xfd00420f,
+        0xe07be53f, 0x5c8e5a3f, 0xfeb09f00, 0xfd00620f,
+        0x05e81f00, 0x9000f02f, 0x7fe48f00, 0xfe04624f,
+        0x04ec8f00, 0xfe08626f, 0x03840f81, 0x7f08a20f,
+        0xe07be53f, 0x5c8e5a3f, 0x7e0c1f00, 0x900ce00f,
+        0xfe0c1f00, 0x900c802f, 0x05cc1f00, 0x9000e84f,
+        0xfeb89f80, 0xfd00626f, 0xe07be53f, 0x5c8e5a3f,
+        0x7cc09f81, 0x80000020, 0x7fa40f00, 0x00280000,
+        0xfe848f00, 0x00280020, 0x7fe80f00, 0x00280440,
+        0xfd001f80, 0x00280060, 0x00000080, 0x00000000,
+        0xfdc01f80, 0xf800620f, 0x00000243, 0x00000000,
+        0xfea01f80, 0x90000060, 0x5555d53f, 0x00000000,
+        0x02011f80, 0x8c110000, 0x02448002, 0x80020000,
+        0xf8402000, 0x9006a02f, 0x02552081, 0x00000040,
+        0xfe301f00, 0x1000e06f, 0xfe081f80, 0x1033c02f,
+        0xfe4c2081, 0x80060040, 0xfee88f81, 0x0289e32f,
+        0x02c59f80, 0x80060000, 0xfee08f80, 0x0285636f,
+        0xfecc8f80, 0x80000000, 0xfe40a081, 0x80000060,
+        0x00cc9f81, 0x9000e04f, 0xfe281f00, 0x80060000,
+        0xf8c01f81, 0x9006c02f, 0xfee00f81, 0xfd80636f,
+        0x0000803f, 0x00000000, 0x7ec49f81, 0xf880e34f,
+        0xfe381f80, 0x00000000, 0x7de40f81, 0xfe800360,
+        0x00011f80, 0x8c100000, 0xf8001f00, 0x900ce00f,
+        0x00311f00, 0x1000e02f, 0x02a41f00, 0xf910624f,
+        0x02a01f00, 0xf910626f, 0x00011f80, 0x1033e04f,
+        0x00000040, 0x00000000, 0xfecc9f03, 0x80020000,
+        0xfec81f83, 0x80020060, 0x7fd49f01, 0x00000020,
+        0x7fd41f80, 0x00000040, 0xfe081f00, 0x80010000,
+        0xfe041f80, 0x80010060, 0xfee00f01, 0x80000000,
+        0xfeec0f81, 0x80000020, 0xfec01f00, 0x00280000,
+        0xfec49f00, 0x00280020, 0x7fe00f00, 0x00280040,
+        0xfd001f80, 0x00280060, 0x00000080, 0x00000000,
+        0xfe001f80, 0x00350000, 0x00ec1f82, 0x000c0260,
+        0x01011f00, 0x800c0000, 0x01051f00, 0x800c0020,
+        0x002c1f00, 0x80060040, 0xf8008001, 0x9006e06f,
+        0x01091f80, 0x800c0000, 0x01c01f00, 0x90000000,
+        0xfe088001, 0xfd80632f, 0x01e81f00, 0x90000040,
+        0x01c49f80, 0x90000020, 0x0000803f, 0x00000000,
+        0x7fcc9f80, 0xf880630f, 0xfe20a081, 0x80000000,
+        0x01cc1f80, 0x90000060, 0xc21e82a7, 0x62ccc547,
+        0x1708607c, 0x73ea57a6};
+static const uint32_t cpPixelShaderRegs[] = {
+        0x00000106, 0x00000002, 0x14000003, 0x00000000,
+        0x00000003, 0x00000100, 0x00000101, 0x00000102,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x0000000f, 0x00000001, 0x00000010,
+        0x00000000};
+
+ShaderFractalColor *ShaderFractalColor::shaderInstance = NULL;
+
+ShaderFractalColor::ShaderFractalColor()
+    : vertexShader(cuAttributeCount) {
+    //! create pixel shader
+    pixelShader.setProgram(cpPixelShaderProgram, sizeof(cpPixelShaderProgram), cpPixelShaderRegs, sizeof(cpPixelShaderRegs));
+
+    blurLocation           = 0;
+    colorIntensityLocation = 4;
+    fadeOutLocation        = 8;
+    fractalLocation        = 12;
+    pixelShader.addUniformVar((GX2UniformVar){
+            "unf_blur_border", GX2_SHADER_VAR_TYPE_FLOAT, 1, blurLocation, -1});
+    pixelShader.addUniformVar((GX2UniformVar){
+            "unf_color_intensity", GX2_SHADER_VAR_TYPE_FLOAT4, 1, colorIntensityLocation, -1});
+    pixelShader.addUniformVar((GX2UniformVar){
+            "unf_fade_out_alpha", GX2_SHADER_VAR_TYPE_FLOAT4, 1, fadeOutLocation, -1});
+    pixelShader.addUniformVar((GX2UniformVar){
+            "unf_fract_alpha", GX2_SHADER_VAR_TYPE_INT, 1, fractalLocation, -1});
+    //! create vertex shader
+    vertexShader.setProgram(cpVertexShaderProgram, sizeof(cpVertexShaderProgram), cpVertexShaderRegs, sizeof(cpVertexShaderRegs));
+
+    modelMatrixLocation      = 0;
+    projectionMatrixLocation = 16;
+    viewMatrixLocation       = 32;
+    vertexShader.addUniformVar((GX2UniformVar){
+            "modelMatrix", GX2_SHADER_VAR_TYPE_FLOAT4X4, 1, modelMatrixLocation, -1});
+    vertexShader.addUniformVar((GX2UniformVar){
+            "projectionMatrix", GX2_SHADER_VAR_TYPE_FLOAT4X4, 1, projectionMatrixLocation, -1});
+    vertexShader.addUniformVar((GX2UniformVar){
+            "viewMatrix", GX2_SHADER_VAR_TYPE_FLOAT4X4, 1, viewMatrixLocation, -1});
+
+    positionLocation = 0;
+    colorLocation    = 1;
+    texCoordLocation = 2;
+    vertexShader.addAttribVar((GX2AttribVar){
+            "attr_colors", GX2_SHADER_VAR_TYPE_FLOAT4, 0, colorLocation});
+    vertexShader.addAttribVar((GX2AttribVar){
+            "attr_position", GX2_SHADER_VAR_TYPE_FLOAT3, 0, positionLocation});
+    vertexShader.addAttribVar((GX2AttribVar){
+            "attr_texture_coord", GX2_SHADER_VAR_TYPE_FLOAT2, 0, texCoordLocation});
+
+    //! setup attribute streams
+    GX2InitAttribStream(vertexShader.getAttributeBuffer(0), positionLocation, 0, 0, GX2_ATTRIB_FORMAT_FLOAT_32_32_32);
+    GX2InitAttribStream(vertexShader.getAttributeBuffer(1), texCoordLocation, 1, 0, GX2_ATTRIB_FORMAT_FLOAT_32_32);
+    GX2InitAttribStream(vertexShader.getAttributeBuffer(2), colorLocation, 2, 0, GX2_ATTRIB_FORMAT_UNORM_8_8_8_8);
+
+    //! create fetch shader
+    fetchShader = new FetchShader(vertexShader.getAttributeBuffer(), vertexShader.getAttributesCount());
+
+    //! initialize default quad texture vertexes as those are very commonly used
+    //! model vertex has to be align and cannot be in unknown regions for GX2 like 0xBCAE1000
+    posVtxs   = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciPositionVtxsSize);
+    texCoords = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciTexCoordsVtxsSize);
+    colorVtxs = (uint8_t *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciColorVtxsSize);
+
+    //! position vertex structure and texture coordinate vertex structure
+    int32_t i    = 0;
+    posVtxs[i++] = -1.0f;
+    posVtxs[i++] = -1.0f;
+    posVtxs[i++] = 0.0f;
+    posVtxs[i++] = 1.0f;
+    posVtxs[i++] = -1.0f;
+    posVtxs[i++] = 0.0f;
+    posVtxs[i++] = 1.0f;
+    posVtxs[i++] = 1.0f;
+    posVtxs[i++] = 0.0f;
+    posVtxs[i++] = -1.0f;
+    posVtxs[i++] = 1.0f;
+    posVtxs[i++] = 0.0f;
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, posVtxs, ciPositionVtxsSize);
+
+    i              = 0;
+    texCoords[i++] = 0.0f;
+    texCoords[i++] = 1.0f;
+    texCoords[i++] = 1.0f;
+    texCoords[i++] = 1.0f;
+    texCoords[i++] = 1.0f;
+    texCoords[i++] = 0.0f;
+    texCoords[i++] = 0.0f;
+    texCoords[i++] = 0.0f;
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, texCoords, ciTexCoordsVtxsSize);
+
+
+    for (i = 0; i < (int32_t) ciColorVtxsSize; i++) {
+        colorVtxs[i] = 0xff;
+    }
+
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, colorVtxs, ciColorVtxsSize);
+}
+
+ShaderFractalColor::~ShaderFractalColor() {
+    if (posVtxs) {
+        free(posVtxs);
+        posVtxs = NULL;
+    }
+    if (texCoords) {
+        free(texCoords);
+        texCoords = NULL;
+    }
+    if (colorVtxs) {
+        free(colorVtxs);
+        colorVtxs = NULL;
+    }
+
+    delete fetchShader;
+    fetchShader = NULL;
+}

src/video/shaders/ShaderFractalColor.h

@@ -0,0 +1,120 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef SHADER_FRACTAL_COLOR_H_
+#define SHADER_FRACTAL_COLOR_H_
+
+#include <video/shaders/FetchShader.h>
+#include <video/shaders/PixelShader.h>
+#include <video/shaders/VertexShader.h>
+
+class ShaderFractalColor : public Shader {
+private:
+    ShaderFractalColor();
+
+    virtual ~ShaderFractalColor();
+
+    static ShaderFractalColor *shaderInstance;
+
+    static const unsigned char cuAttributeCount = 3;
+    static const uint32_t ciPositionVtxsSize    = 4 * cuVertexAttrSize;
+    static const uint32_t ciTexCoordsVtxsSize   = 4 * cuTexCoordAttrSize;
+    static const uint32_t ciColorVtxsSize       = 4 * cuColorAttrSize;
+
+    FetchShader *fetchShader;
+    VertexShader vertexShader;
+    PixelShader pixelShader;
+
+    float *posVtxs;
+    float *texCoords;
+    uint8_t *colorVtxs;
+
+    uint32_t modelMatrixLocation;
+    uint32_t viewMatrixLocation;
+    uint32_t projectionMatrixLocation;
+    uint32_t positionLocation;
+    uint32_t colorLocation;
+    uint32_t texCoordLocation;
+
+    uint32_t blurLocation;
+    uint32_t colorIntensityLocation;
+    uint32_t fadeOutLocation;
+    uint32_t fractalLocation;
+
+public:
+    static ShaderFractalColor *instance() {
+        if (!shaderInstance) {
+            shaderInstance = new ShaderFractalColor();
+        }
+        return shaderInstance;
+    }
+
+    static void destroyInstance() {
+        if (shaderInstance) {
+            delete shaderInstance;
+            shaderInstance = NULL;
+        }
+    }
+
+    void setShaders(void) const {
+        fetchShader->setShader();
+        vertexShader.setShader();
+        pixelShader.setShader();
+    }
+
+    void setAttributeBuffer(const uint32_t &vtxCount = 0, const float *posVtxs_in = NULL, const float *texCoords_in = NULL, const uint8_t *colorVtxs_in = NULL) const {
+        if (posVtxs_in && texCoords_in && vtxCount) {
+            VertexShader::setAttributeBuffer(0, vtxCount * cuVertexAttrSize, cuVertexAttrSize, posVtxs_in);
+            VertexShader::setAttributeBuffer(1, vtxCount * cuTexCoordAttrSize, cuTexCoordAttrSize, texCoords_in);
+            VertexShader::setAttributeBuffer(2, vtxCount * cuColorAttrSize, cuColorAttrSize, colorVtxs_in);
+        } else {
+            //! use default quad vertex and texture coordinates if nothing is passed
+            VertexShader::setAttributeBuffer(0, ciPositionVtxsSize, cuVertexAttrSize, posVtxs);
+            VertexShader::setAttributeBuffer(1, ciTexCoordsVtxsSize, cuTexCoordAttrSize, texCoords);
+            VertexShader::setAttributeBuffer(2, ciColorVtxsSize, cuColorAttrSize, colorVtxs);
+        }
+    }
+
+    void setProjectionMtx(const glm::mat4 &mtx) {
+        VertexShader::setUniformReg(projectionMatrixLocation, 16, &mtx[0][0]);
+    }
+
+    void setViewMtx(const glm::mat4 &mtx) {
+        VertexShader::setUniformReg(viewMatrixLocation, 16, &mtx[0][0]);
+    }
+
+    void setModelViewMtx(const glm::mat4 &mtx) {
+        VertexShader::setUniformReg(modelMatrixLocation, 16, &mtx[0][0]);
+    }
+
+    void setBlurBorder(const float &blurBorderSize) {
+        PixelShader::setUniformReg(blurLocation, 4, &blurBorderSize);
+    }
+
+    void setColorIntensity(const glm::vec4 &vec) {
+        PixelShader::setUniformReg(colorIntensityLocation, 4, &vec[0]);
+    }
+
+    void setAlphaFadeOut(const glm::vec4 &vec) {
+        PixelShader::setUniformReg(fadeOutLocation, 4, &vec[0]);
+    }
+
+    void setFractalColor(const int &fractalColorEnable) {
+        PixelShader::setUniformReg(fractalLocation, 4, &fractalColorEnable);
+    }
+};
+
+#endif // SHADER_FRACTAL_COLOR_H_

src/video/shaders/Texture2DShader.cpp

@@ -0,0 +1,281 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#include <video/shaders/Texture2DShader.h>
+#include <malloc.h>
+#include <string.h>
+
+static const uint32_t cpVertexShaderProgram[] = {
+        0x00000000, 0x00008009, 0x20000000, 0x000080a0,
+        0x3c200100, 0x88060094, 0x00400000, 0x88042014,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x02290001, 0x80000000, 0x02041f00, 0x900c0020,
+        0x00a11f00, 0xfc00624f, 0xfd041f00, 0x900c4060,
+        0x02001f80, 0x900c0000, 0x83f9223e, 0x0000803f,
+        0xfe081f00, 0x00080020, 0xfe202081, 0x10004040,
+        0xfea49f80, 0xfd00620f, 0xdb0f49c0, 0xdb0fc940,
+        0xfea01f80, 0x9000e06f, 0x83f9223e, 0x00000000,
+        0xfe0c1f80, 0x00370000, 0xffa01f00, 0x80000040,
+        0xff101f00, 0x800c0060, 0x7f0c1f80, 0x80370040,
+        0x0000103f, 0x00000000, 0xffa01f00, 0x80000000,
+        0xff001f00, 0x800c0020, 0x02c51f01, 0x80000040,
+        0xfeac9f80, 0x80000060, 0x0000103f, 0x398ee33f,
+        0xfea01f00, 0x80000000, 0x02c19f01, 0x9000e02f,
+        0x01c41f01, 0x9000e04f, 0x02c59f80, 0x80000060,
+        0x398ee33f, 0x00000000, 0x01c49f01, 0x80000020,
+        0x02c11f80, 0x80000040, 0x01e08f00, 0xfe04624f,
+        0x01c01f81, 0x7f08626f, 0xfe2c2000, 0x10004000,
+        0xfe28a080, 0x10004020, 0xeb825790, 0xb6f711be,
+        0x7c0e2df2, 0x81173cfa};
+
+static const uint32_t cpVertexShaderRegs[] = {
+        0x00000103, 0x00000000, 0x00000000, 0x00000001,
+        0xffffff00, 0xffffffff, 0xffffffff, 0xffffffff,
+        0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+        0xffffffff, 0xffffffff, 0x00000000, 0xfffffffc,
+        0x00000002, 0x00000000, 0x00000001, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x000000ff, 0x000000ff, 0x000000ff,
+        0x000000ff, 0x00000000, 0x0000000e, 0x00000010};
+
+static const uint32_t cPixelShaderProgram[] = {
+        0x20000000, 0x00000ca4, 0x0b000000, 0x00000085,
+        0x24000000, 0x000050a0, 0xb0000000, 0x000cc080,
+        0x39000000, 0x00005ca0, 0xb8000000, 0x000cc080,
+        0x51000000, 0x000078a0, 0xc0000000, 0x000cc080,
+        0x70000000, 0x000064a0, 0xc8000000, 0x0008c080,
+        0x8a000000, 0x00005ca0, 0x0e000000, 0x01008086,
+        0xce000000, 0x0000c080, 0xa2000000, 0x00000ca8,
+        0x00800000, 0x88062094, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00051f00, 0x80060000, 0x00011f80, 0x80060040,
+        0xfec81f80, 0xfb802320, 0x01041f80, 0x8c220000,
+        0x00a41f00, 0xfc10620f, 0x010d1f00, 0x900c0021,
+        0x00091f00, 0x80060040, 0x00a01f80, 0xfc10626f,
+        0x00000040, 0x00000000, 0xfe080000, 0xfe8cc300,
+        0xfe088080, 0xfe80c320, 0x00a11f00, 0xfe000200,
+        0x00a51f00, 0xfe040220, 0x00a19f00, 0xfe000240,
+        0x00a59f00, 0xfe040260, 0x00a11f81, 0xfe002600,
+        0x4260e5bc, 0xa69bc4bc, 0x0ad7a3bc, 0x00000000,
+        0x00a11f00, 0x06004200, 0x00a59f00, 0x06042220,
+        0x00a51f00, 0x06044240, 0x00a11f01, 0x06008260,
+        0x00a51f81, 0x06048620, 0x6f1283bc, 0x0ad7a3bc,
+        0xa69b44bc, 0x00000000, 0x00a41f00, 0x80000000,
+        0x00a01f00, 0x80000020, 0x00ac1f00, 0x80000040,
+        0x00a81f00, 0x80000060, 0x00a19f80, 0x06000600,
+        0xcac3123c, 0x6f1203bc, 0x03a41f00, 0xfe00620f,
+        0x03a01f00, 0xfe04622f, 0x03ac1f00, 0xfe08624f,
+        0x03a81f00, 0xfe0c626f, 0x00a59f80, 0x06040620,
+        0xcc28913b, 0x6f1203bc, 0x01a41f00, 0xfe00620f,
+        0x01a01f00, 0xfe04622f, 0x01ac1f00, 0xfe08624f,
+        0x01a81f00, 0xfe0c626f, 0x00a19f80, 0x06002600,
+        0xe8eab03c, 0x6f1283bb, 0x02ac1f00, 0xfe084200,
+        0x02a81f00, 0xfe0c4220, 0x02a41f00, 0xfe004240,
+        0x02a01f00, 0xfe044260, 0x00a59f80, 0x06042620,
+        0x92bb353d, 0x6f1283bb, 0x04a81f00, 0x0204620f,
+        0x04ac1f00, 0x0200662f, 0x04a41f00, 0x0208624f,
+        0x04a01f00, 0x020c626f, 0x00a19f80, 0x06004600,
+        0xc4139f3d, 0x6f12833b, 0x00a41f00, 0xfe08620f,
+        0x00a01f00, 0xfe0c622f, 0x00ac1f00, 0xfe04624f,
+        0x00a81f00, 0xfe00626f, 0x00a59f80, 0x06044620,
+        0xb950ed3d, 0x6f12833b, 0x01a41f00, 0xfe00620f,
+        0x01a01f00, 0xfe04622f, 0x01ac1f00, 0xfe08624f,
+        0x01a81f00, 0xfe0c626f, 0x00a19f80, 0x06002600,
+        0xecd7163e, 0x6f12033c, 0x03a41f00, 0xfe000200,
+        0x03a01f00, 0xfe040220, 0x03ac1f00, 0xfe082240,
+        0x03a81f00, 0xfe0c2260, 0x00a59f80, 0x06042620,
+        0x2168233e, 0x6f12033c, 0x00a11f00, 0x06006200,
+        0x00a51f00, 0x06046220, 0x00a19f00, 0x06006240,
+        0x00a59f00, 0x06046260, 0x00a11f81, 0x0600e600,
+        0xa69b443c, 0x6f12833c, 0x0ad7a33c, 0x00000000,
+        0x02ac1f00, 0x0108620f, 0x02a81f00, 0x010c622f,
+        0x02a41f00, 0x0000624f, 0x02a01f00, 0x0004666f,
+        0x00a59f80, 0x0604e620, 0xecd7163e, 0x0ad7a33c,
+        0x04a81f00, 0xfe04620f, 0x04ac1f00, 0xfe00622f,
+        0x04a41f00, 0xfe08624f, 0x04a01f00, 0xfe0c626f,
+        0x00a19f80, 0x06008600, 0xb950ed3d, 0xa69bc43c,
+        0x05a41f00, 0xfe08620f, 0x05a01f00, 0xfe0c622f,
+        0x05ac1f00, 0xfe04624f, 0x05a81f00, 0xfe00626f,
+        0x00a59f80, 0x06048620, 0xc4139f3d, 0xa69bc43c,
+        0x03a41f00, 0xfe00a200, 0x03a01f00, 0xfe04a220,
+        0x03ac1f00, 0xfe086240, 0x03a81f00, 0xfe0c6260,
+        0x00a19f80, 0x06006600, 0x92bb353d, 0x4260e53c,
+        0x00a51f80, 0x06046220, 0x4260e53c, 0x00000000,
+        0x07ac1f00, 0x0308620f, 0x07a81f00, 0x030c622f,
+        0x07a41f00, 0x0500624f, 0x07a01f80, 0x0504626f,
+        0xe8eab03c, 0x00000000, 0x04a81f00, 0xfe04620f,
+        0x04ac1f00, 0xfe00622f, 0x04a41f00, 0xfe08624f,
+        0x04a01f80, 0xfe0c626f, 0xcac3123c, 0x00000000,
+        0x06a41f00, 0xfe08620f, 0x06a01f00, 0xfe0c622f,
+        0x06ac1f00, 0xfe04624f, 0x06a81f80, 0xfe00626f,
+        0xcc28913b, 0x00000000, 0xfe20a000, 0x9000e00f,
+        0xfe242000, 0x9000e02f, 0xfe28a001, 0x9000e04f,
+        0xfe2c2081, 0x9000e06f, 0xfe28a081, 0x80060020,
+        0xfee48f00, 0x7f842300, 0xfee40f00, 0x7f802320,
+        0xfee48f01, 0x7f8c2340, 0xfee40f81, 0x08842b60,
+        0x00202000, 0x90002000, 0x0024a000, 0x90002020,
+        0x00282001, 0x90002040, 0x002ca081, 0x90002060,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x10000000, 0x03100df0, 0x00008010, 0xecdfea0d,
+        0x10000000, 0x00100df0, 0x0000a051, 0xecdfea0d,
+        0x10000100, 0x01100df0, 0x00008010, 0xecdfea0d,
+        0x10000200, 0x02100df0, 0x00000011, 0xecdfea0d,
+        0x10000400, 0x04100df0, 0x0000b070, 0xecdfea0d,
+        0x10000000, 0x00100df0, 0x00008010, 0xecdfea0d,
+        0x10000100, 0x01100df0, 0x00008010, 0xecdfea0d,
+        0x10000600, 0x03100df0, 0x00008010, 0xecdfea0d,
+        0x10000200, 0x02100df0, 0x00008010, 0xecdfea0d,
+        0x10000100, 0x04100df0, 0x00008010, 0xecdfea0d,
+        0x10000300, 0x05100df0, 0x00008010, 0xecdfea0d,
+        0x10000300, 0x03100df0, 0x0000a051, 0xecdfea0d,
+        0x10000700, 0x07100df0, 0x00008010, 0xecdfea0d,
+        0x10000400, 0x04100df0, 0x00008010, 0xecdfea0d,
+        0x10000300, 0x06100df0, 0x00008010, 0xecdfea0d,
+        0x10000000, 0x00100df0, 0x00008010, 0xecdfea0d,
+        0xc8581837, 0x22740275, 0x281eddcc, 0xfa8b9b65};
+static const uint32_t cPixelShaderRegs[] = {
+        0x00000109, 0x00000002, 0x14000001, 0x00000000,
+        0x00000001, 0x00000100, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x00000000, 0x00000000, 0x00000000,
+        0x00000000, 0x0000000f, 0x00000001, 0x00000010,
+        0x00000000};
+
+Texture2DShader *Texture2DShader::shaderInstance = NULL;
+
+Texture2DShader::Texture2DShader()
+    : vertexShader(cuAttributeCount) {
+    //! create pixel shader
+    pixelShader.setProgram(cPixelShaderProgram, sizeof(cPixelShaderProgram), cPixelShaderRegs, sizeof(cPixelShaderRegs));
+
+    blurLocation           = 0;
+    colorIntensityLocation = 4;
+    pixelShader.addUniformVar((GX2UniformVar){
+            "unf_blur_texture_direction", GX2_SHADER_VAR_TYPE_FLOAT3, 1, blurLocation, -1});
+    pixelShader.addUniformVar((GX2UniformVar){
+            "unf_color_intensity", GX2_SHADER_VAR_TYPE_FLOAT4, 1, colorIntensityLocation, -1});
+
+    samplerLocation = 0;
+    pixelShader.addSamplerVar((GX2SamplerVar){
+            "sampl_texture", GX2_SAMPLER_VAR_TYPE_SAMPLER_2D, samplerLocation});
+
+    //! create vertex shader
+    vertexShader.setProgram(cpVertexShaderProgram, sizeof(cpVertexShaderProgram), cpVertexShaderRegs, sizeof(cpVertexShaderRegs));
+
+    angleLocation  = 0;
+    offsetLocation = 4;
+    scaleLocation  = 8;
+    vertexShader.addUniformVar((GX2UniformVar){
+            "unf_angle", GX2_SHADER_VAR_TYPE_FLOAT, 1, angleLocation, -1});
+    vertexShader.addUniformVar((GX2UniformVar){
+            "unf_offset", GX2_SHADER_VAR_TYPE_FLOAT3, 1, offsetLocation, -1});
+    vertexShader.addUniformVar((GX2UniformVar){
+            "unf_scale", GX2_SHADER_VAR_TYPE_FLOAT3, 1, scaleLocation, -1});
+
+    positionLocation = 0;
+    texCoordLocation = 1;
+    vertexShader.addAttribVar((GX2AttribVar){
+            "attr_position", GX2_SHADER_VAR_TYPE_FLOAT3, 0, positionLocation});
+    vertexShader.addAttribVar((GX2AttribVar){
+            "attr_texture_coord", GX2_SHADER_VAR_TYPE_FLOAT2, 0, texCoordLocation});
+
+    //! setup attribute streams
+    GX2InitAttribStream(vertexShader.getAttributeBuffer(0), positionLocation, 0, 0, GX2_ATTRIB_FORMAT_FLOAT_32_32_32);
+    GX2InitAttribStream(vertexShader.getAttributeBuffer(1), texCoordLocation, 1, 0, GX2_ATTRIB_FORMAT_FLOAT_32_32);
+
+    //! create fetch shader
+    fetchShader = new FetchShader(vertexShader.getAttributeBuffer(), vertexShader.getAttributesCount());
+
+    //! model vertex has to be align and cannot be in unknown regions for GX2 like 0xBCAE1000
+    posVtxs   = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciPositionVtxsSize);
+    texCoords = (float *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ciTexCoordsVtxsSize);
+
+    //! defaults for normal square
+    //! position vertex structure and texture coordinate vertex structure
+    int32_t i    = 0;
+    posVtxs[i++] = -1.0f;
+    posVtxs[i++] = -1.0f;
+    posVtxs[i++] = 0.0f;
+    posVtxs[i++] = 1.0f;
+    posVtxs[i++] = -1.0f;
+    posVtxs[i++] = 0.0f;
+    posVtxs[i++] = 1.0f;
+    posVtxs[i++] = 1.0f;
+    posVtxs[i++] = 0.0f;
+    posVtxs[i++] = -1.0f;
+    posVtxs[i++] = 1.0f;
+    posVtxs[i++] = 0.0f;
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, posVtxs, ciPositionVtxsSize);
+
+    i              = 0;
+    texCoords[i++] = 0.0f;
+    texCoords[i++] = 1.0f;
+    texCoords[i++] = 1.0f;
+    texCoords[i++] = 1.0f;
+    texCoords[i++] = 1.0f;
+    texCoords[i++] = 0.0f;
+    texCoords[i++] = 0.0f;
+    texCoords[i++] = 0.0f;
+    GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, texCoords, ciTexCoordsVtxsSize);
+}
+
+Texture2DShader::~Texture2DShader() {
+    if (posVtxs) {
+        free(posVtxs);
+        posVtxs = NULL;
+    }
+    if (texCoords) {
+        free(texCoords);
+        texCoords = NULL;
+    }
+
+    delete fetchShader;
+    fetchShader = NULL;
+}

src/video/shaders/Texture2DShader.h

@@ -0,0 +1,110 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef __TEXTURE_2D_SHADER_H_
+#define __TEXTURE_2D_SHADER_H_
+
+#include <video/shaders/FetchShader.h>
+#include <video/shaders/PixelShader.h>
+#include <video/shaders/VertexShader.h>
+
+
+class Texture2DShader : public Shader {
+private:
+    Texture2DShader();
+
+    virtual ~Texture2DShader();
+
+    static const uint32_t cuAttributeCount    = 2;
+    static const uint32_t ciPositionVtxsSize  = 4 * cuVertexAttrSize;
+    static const uint32_t ciTexCoordsVtxsSize = 4 * cuTexCoordAttrSize;
+
+    static Texture2DShader *shaderInstance;
+
+    FetchShader *fetchShader;
+    VertexShader vertexShader;
+    PixelShader pixelShader;
+
+    float *posVtxs;
+    float *texCoords;
+
+    uint32_t angleLocation;
+    uint32_t offsetLocation;
+    uint32_t scaleLocation;
+    uint32_t colorIntensityLocation;
+    uint32_t blurLocation;
+    uint32_t samplerLocation;
+    uint32_t positionLocation;
+    uint32_t texCoordLocation;
+
+public:
+    static Texture2DShader *instance() {
+        if (!shaderInstance) {
+            shaderInstance = new Texture2DShader();
+        }
+        return shaderInstance;
+    }
+
+    static void destroyInstance() {
+        if (shaderInstance) {
+            delete shaderInstance;
+            shaderInstance = NULL;
+        }
+    }
+
+    void setShaders(void) const {
+        fetchShader->setShader();
+        vertexShader.setShader();
+        pixelShader.setShader();
+    }
+
+    void setAttributeBuffer(const float *texCoords_in = NULL, const float *posVtxs_in = NULL, const uint32_t &vtxCount = 0) const {
+        if (posVtxs_in && texCoords_in && vtxCount) {
+            VertexShader::setAttributeBuffer(0, vtxCount * cuVertexAttrSize, cuVertexAttrSize, posVtxs_in);
+            VertexShader::setAttributeBuffer(1, vtxCount * cuTexCoordAttrSize, cuTexCoordAttrSize, texCoords_in);
+        } else {
+            VertexShader::setAttributeBuffer(0, ciPositionVtxsSize, cuVertexAttrSize, posVtxs);
+            VertexShader::setAttributeBuffer(1, ciTexCoordsVtxsSize, cuTexCoordAttrSize, texCoords);
+        }
+    }
+
+    void setAngle(const float &val) {
+        VertexShader::setUniformReg(angleLocation, 4, &val);
+    }
+
+    void setOffset(const glm::vec3 &vec) {
+        VertexShader::setUniformReg(offsetLocation, 4, &vec[0]);
+    }
+
+    void setScale(const glm::vec3 &vec) {
+        VertexShader::setUniformReg(scaleLocation, 4, &vec[0]);
+    }
+
+    void setColorIntensity(const glm::vec4 &vec) {
+        PixelShader::setUniformReg(colorIntensityLocation, 4, &vec[0]);
+    }
+
+    void setBlurring(const glm::vec3 &vec) {
+        PixelShader::setUniformReg(blurLocation, 4, &vec[0]);
+    }
+
+    void setTextureAndSampler(const GX2Texture *texture, const GX2Sampler *sampler) const {
+        GX2SetPixelTexture((GX2Texture *) texture, samplerLocation);
+        GX2SetPixelSampler((GX2Sampler *) sampler, samplerLocation);
+    }
+};
+
+#endif // __TEXTURE_2D_SHADER_H_

src/video/shaders/VertexShader.h

@@ -0,0 +1,181 @@
+/****************************************************************************
+ * Copyright (C) 2015 Dimok
+ *
+ * This program 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 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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, see <http://www.gnu.org/licenses/>.
+ ****************************************************************************/
+#ifndef VERTEX_SHADER_H
+#define VERTEX_SHADER_H
+
+#include <gui/gx2_ext.h>
+#include <video/shaders/Shader.h>
+#include <string.h>
+
+class VertexShader : public Shader {
+public:
+    VertexShader(uint32_t numAttr)
+        : attributesCount(numAttr), attributes(new GX2AttribStream[attributesCount]), vertexShader((GX2VertexShader *) memalign(0x40, sizeof(GX2VertexShader))) {
+        if (vertexShader) {
+            memset(vertexShader, 0, sizeof(GX2VertexShader));
+            vertexShader->mode = GX2_SHADER_MODE_UNIFORM_REGISTER;
+        }
+    }
+
+    virtual ~VertexShader() {
+        delete[] attributes;
+
+        if (vertexShader) {
+            if (vertexShader->program) {
+                free(vertexShader->program);
+            }
+
+            for (uint32_t i = 0; i < vertexShader->uniformBlockCount; i++) {
+                free((void *) vertexShader->uniformBlocks[i].name);
+            }
+
+            if (vertexShader->uniformBlocks) {
+                free((void *) vertexShader->uniformBlocks);
+            }
+
+            for (uint32_t i = 0; i < vertexShader->uniformVarCount; i++) {
+                free((void *) vertexShader->uniformVars[i].name);
+            }
+
+            if (vertexShader->uniformVars) {
+                free((void *) vertexShader->uniformVars);
+            }
+
+            if (vertexShader->initialValues) {
+                free((void *) vertexShader->initialValues);
+            }
+
+            for (uint32_t i = 0; i < vertexShader->samplerVarCount; i++) {
+                free((void *) vertexShader->samplerVars[i].name);
+            }
+
+            if (vertexShader->samplerVars) {
+                free((void *) vertexShader->samplerVars);
+            }
+
+            for (uint32_t i = 0; i < vertexShader->attribVarCount; i++) {
+                free((void *) vertexShader->attribVars[i].name);
+            }
+
+            if (vertexShader->attribVars) {
+                free((void *) vertexShader->attribVars);
+            }
+
+            if (vertexShader->loopVars) {
+                free((void *) vertexShader->loopVars);
+            }
+
+            free(vertexShader);
+        }
+    }
+
+    void setProgram(const uint32_t *program, const uint32_t &programSize, const uint32_t *regs, const uint32_t &regsSize) {
+        if (!vertexShader) {
+            return;
+        }
+
+        //! this must be moved into an area where the graphic engine has access to and must be aligned to 0x100
+        vertexShader->size    = programSize;
+        vertexShader->program = (uint8_t *) memalign(GX2_SHADER_PROGRAM_ALIGNMENT, vertexShader->size);
+        if (vertexShader->program) {
+            memcpy(vertexShader->program, program, vertexShader->size);
+            GX2Invalidate(GX2_INVALIDATE_MODE_CPU_SHADER, vertexShader->program, vertexShader->size);
+        }
+
+        memcpy(&vertexShader->regs, regs, regsSize);
+    }
+
+    void addUniformVar(const GX2UniformVar &var) {
+        if (!vertexShader) {
+            return;
+        }
+
+        uint32_t idx = vertexShader->uniformVarCount;
+
+        GX2UniformVar *newVar = (GX2UniformVar *) malloc((vertexShader->uniformVarCount + 1) * sizeof(GX2UniformVar));
+        if (newVar) {
+            if (vertexShader->uniformVarCount > 0) {
+                memcpy(newVar, vertexShader->uniformVars, vertexShader->uniformVarCount * sizeof(GX2UniformVar));
+                free(vertexShader->uniformVars);
+            }
+            vertexShader->uniformVars = newVar;
+
+            memcpy(vertexShader->uniformVars + idx, &var, sizeof(GX2UniformVar));
+            vertexShader->uniformVars[idx].name = (char *) malloc(strlen(var.name) + 1);
+            strcpy((char *) vertexShader->uniformVars[idx].name, var.name);
+
+            vertexShader->uniformVarCount++;
+        }
+    }
+
+    void addAttribVar(const GX2AttribVar &var) {
+        if (!vertexShader) {
+            return;
+        }
+
+        uint32_t idx = vertexShader->attribVarCount;
+
+        GX2AttribVar *newVar = (GX2AttribVar *) malloc((vertexShader->attribVarCount + 1) * sizeof(GX2AttribVar));
+        if (newVar) {
+            if (vertexShader->attribVarCount > 0) {
+                memcpy(newVar, vertexShader->attribVars, vertexShader->attribVarCount * sizeof(GX2AttribVar));
+                free(vertexShader->attribVars);
+            }
+            vertexShader->attribVars = newVar;
+
+            memcpy(vertexShader->attribVars + idx, &var, sizeof(GX2AttribVar));
+            vertexShader->attribVars[idx].name = (char *) malloc(strlen(var.name) + 1);
+            strcpy((char *) vertexShader->attribVars[idx].name, var.name);
+
+            vertexShader->attribVarCount++;
+        }
+    }
+
+    static inline void setAttributeBuffer(uint32_t bufferIdx, uint32_t bufferSize, uint32_t stride, const void *buffer) {
+        GX2SetAttribBuffer(bufferIdx, bufferSize, stride, (void *) buffer);
+    }
+
+    GX2VertexShader *getVertexShader() const {
+        return vertexShader;
+    }
+
+    void setShader(void) const {
+        GX2SetVertexShader(vertexShader);
+    }
+
+    GX2AttribStream *getAttributeBuffer(uint32_t idx = 0) const {
+        if (idx >= attributesCount) {
+            return NULL;
+        }
+        return &attributes[idx];
+    }
+
+    uint32_t getAttributesCount() const {
+        return attributesCount;
+    }
+
+    static void setUniformReg(uint32_t location, uint32_t size, const void *reg) {
+        GX2SetVertexUniformReg(location, size, (uint32_t *) reg);
+    }
+
+protected:
+    uint32_t attributesCount;
+    GX2AttribStream *attributes;
+    GX2VertexShader *vertexShader;
+};
+
+#endif // VERTEX_SHADER_H