Use latest wut, use libgui

This commit is contained in:
orboditilt 2019-08-15 11:21:02 +02:00
parent c41649224e
commit a7de4e03aa
120 changed files with 1078 additions and 17447 deletions

5
.gitignore vendored Normal file
View File

@ -0,0 +1,5 @@
build/
*.rpx
*.elf
*.exe
src/resources/filelist.h

311
Makefile
View File

@ -1,259 +1,160 @@
#--------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
# Clear the implicit built in rules
#---------------------------------------------------------------------------------
.SUFFIXES: .SUFFIXES:
#--------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
ifeq ($(strip $(DEVKITPPC)),)
$(error "Please set DEVKITPPC in your environment. export DEVKITPPC=<path to>devkitPPC")
endif
ifeq ($(strip $(DEVKITPRO)),) ifeq ($(strip $(DEVKITPRO)),)
$(error "Please set DEVKITPRO in your environment. export DEVKITPRO=<path to>devkitPRO") $(error "Please set DEVKITPRO in your environment. export DEVKITPRO=<path to>/devkitpro")
endif endif
ifeq ($(strip $(WUT_ROOT)),)
$(error "Please ensure WUT_ROOT is in your environment.")
endif
export PATH := $(DEVKITPPC)/bin:$(PORTLIBS)/bin:$(PATH)
export LIBOGC_INC := $(DEVKITPRO)/libogc/include
export LIBOGC_LIB := $(DEVKITPRO)/libogc/lib/wii
export PORTLIBS := $(DEVKITPRO)/portlibs/ppc
PREFIX := powerpc-eabi- TOPDIR ?= $(CURDIR)
export AS := $(PREFIX)as include $(DEVKITPRO)/wut/share/wut_rules
export CC := $(PREFIX)gcc
export CXX := $(PREFIX)g++
export AR := $(PREFIX)ar
export OBJCOPY := $(PREFIX)objcopy
export ELF2RPL := $(WUT_ROOT)/bin/elf2rpl #-------------------------------------------------------------------------------
#---------------------------------------------------------------------------------
# TARGET is the name of the output # TARGET is the name of the output
# BUILD is the directory where object files & intermediate files will be placed # BUILD is the directory where object files & intermediate files will be placed
# SOURCES is a list of directories containing source code # SOURCES is a list of directories containing source code
# INCLUDES is a list of directories containing extra header files # DATA is a list of directories containing data files
#--------------------------------------------------------------------------------- # INCLUDES is a list of directories containing header files
TARGET := flappy_bird #-------------------------------------------------------------------------------
TARGET := $(notdir $(CURDIR))
BUILD := build BUILD := build
BUILD_DBG := $(TARGET)_dbg
SOURCES := src \ SOURCES := src \
src/dynamic_libs \
src/fs \ src/fs \
src/game \
src/gui \ src/gui \
src/kernel \ src/game \
src/loader \
src/menu \ src/menu \
src/network \
src/patcher \
src/resources \ src/resources \
src/settings \
src/sounds \
src/system \ src/system \
src/utils \ src/utils
src/video \
src/video/shaders
DATA := data \ DATA := data \
data/images \ data/images \
data/fonts \ data/sounds \
data/sounds data/fonts
INCLUDES := src
INCLUDES := src #-------------------------------------------------------------------------------
#---------------------------------------------------------------------------------
# options for code generation # options for code generation
#--------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
CFLAGS := -std=gnu11 -mrvl -mcpu=750 -meabi -mhard-float -ffast-math \ CFLAGS := -g -Wall -O2 -ffunction-sections \
-O3 -Wall -Wextra -Wno-unused-parameter -Wno-strict-aliasing $(INCLUDE) $(MACHDEP)
CXXFLAGS := -std=gnu++11 -mrvl -mcpu=750 -meabi -mhard-float -ffast-math \
-O3 -Wall -Wextra -Wno-unused-parameter -Wno-strict-aliasing $(INCLUDE)
ASFLAGS := -mregnames
LDFLAGS := -nostartfiles -T $(WUT_ROOT)/rules/rpl.ld -pie -fPIE -z common-page-size=64 -z max-page-size=64 -lcrt \
-Wl,-wrap,malloc,-wrap,free,-wrap,memalign,-wrap,calloc,-wrap,realloc,-wrap,malloc_usable_size \
-Wl,-wrap,_malloc_r,-wrap,_free_r,-wrap,_realloc_r,-wrap,_calloc_r,-wrap,_memalign_r,-wrap,_malloc_usable_size_r \
-Wl,-wrap,valloc,-wrap,_valloc_r,-wrap,_pvalloc_r,-wrap,__eabi -Wl,--gc-sections
#--------------------------------------------------------------------------------- CFLAGS += $(INCLUDE) -D__WIIU__ -D__WUT__
Q := @
MAKEFLAGS += --no-print-directory
#---------------------------------------------------------------------------------
# any extra libraries we wish to link with the project
#---------------------------------------------------------------------------------
LIBS := -lcrt -lcoreinit -lproc_ui -lnsysnet -lsndcore2 -lvpad -lgx2 -lsysapp -lgd -lpng -lz -lfreetype -lmad -lvorbisidec
#--------------------------------------------------------------------------------- CXXFLAGS := $(CFLAGS)
# list of directories containing libraries, this must be the top level containing
# include and lib
#---------------------------------------------------------------------------------
LIBDIRS := $(CURDIR) \
$(DEVKITPPC)/ \
$(DEVKITPPC)/lib/gcc/powerpc-eabi/4.8.2 \
$(WUT_ROOT)/lib
#--------------------------------------------------------------------------------- ASFLAGS := -g $(ARCH)
LDFLAGS = -g $(ARCH) $(RPXSPECS) -Wl,-Map,$(notdir $*.map)
LIBS := -lgui -lfreetype -lgd -lpng -ljpeg -lz -lmad -lvorbisidec -logg -lbz2 -lwut
#-------------------------------------------------------------------------------
# list of directories containing libraries, this must be the top level
# containing include and lib
#-------------------------------------------------------------------------------
LIBDIRS := $(PORTLIBS) $(WUT_ROOT)
#-------------------------------------------------------------------------------
# no real need to edit anything past this point unless you need to add additional # no real need to edit anything past this point unless you need to add additional
# rules for different file extensions # rules for different file extensions
#--------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
ifneq ($(BUILD),$(notdir $(CURDIR))) ifneq ($(BUILD),$(notdir $(CURDIR)))
#--------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
export PROJECTDIR := $(CURDIR)
export OUTPUT := $(CURDIR)/$(TARGETDIR)/$(TARGET)
export VPATH := $(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
$(foreach dir,$(DATA),$(CURDIR)/$(dir))
export DEPSDIR := $(CURDIR)/$(BUILD)
#---------------------------------------------------------------------------------
# automatically build a list of object files for our project
#---------------------------------------------------------------------------------
FILELIST := $(shell bash ./filelist.sh) FILELIST := $(shell bash ./filelist.sh)
CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
sFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.S)))
BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
TTFFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.ttf)))
PNGFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.png)))
#---------------------------------------------------------------------------------
# use CXX for linking C++ projects, CC for standard C
#---------------------------------------------------------------------------------
ifeq ($(strip $(CPPFILES)),)
export LD := $(CC)
else
export LD := $(CXX)
endif
export OFILES := $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) \
$(sFILES:.s=.o) $(SFILES:.S=.o) \
$(PNGFILES:.png=.png.o) $(addsuffix .o,$(BINFILES))
#---------------------------------------------------------------------------------
# build a list of include paths
#---------------------------------------------------------------------------------
export INCLUDE := $(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
-I$(CURDIR)/$(BUILD) -I$(WUT_ROOT)/include \
-I$(PORTLIBS)/include -I$(PORTLIBS)/include/freetype2
#---------------------------------------------------------------------------------
# build a list of library paths
#---------------------------------------------------------------------------------
export LIBPATHS := $(foreach dir,$(LIBDIRS),-L$(dir)) \
-L$(LIBOGC_LIB) -L$(PORTLIBS)/lib
export OUTPUT := $(CURDIR)/$(TARGET) export OUTPUT := $(CURDIR)/$(TARGET)
.PHONY: $(BUILD) clean install export TOPDIR := $(CURDIR)
export VPATH := $(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
$(foreach dir,$(DATA),$(CURDIR)/$(dir))
export DEPSDIR := $(CURDIR)/$(BUILD)
CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
#-------------------------------------------------------------------------------
# use CXX for linking C++ projects, CC for standard C
#-------------------------------------------------------------------------------
ifeq ($(strip $(CPPFILES)),)
#-------------------------------------------------------------------------------
export LD := $(CC)
#-------------------------------------------------------------------------------
else
#-------------------------------------------------------------------------------
export LD := $(CXX)
#-------------------------------------------------------------------------------
endif
#-------------------------------------------------------------------------------
export OFILES_BIN := $(addsuffix .o,$(BINFILES))
export OFILES_SRC := $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
export OFILES := $(OFILES_BIN) $(OFILES_SRC)
export HFILES_BIN := $(addsuffix .h,$(subst .,_,$(BINFILES)))
export INCLUDE := $(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
-I$(CURDIR)/$(BUILD) -I$(PORTLIBS_PATH)/ppc/include/freetype2
export LIBPATHS := $(foreach dir,$(LIBDIRS),-L$(dir)/lib)
.PHONY: $(BUILD) clean all
#-------------------------------------------------------------------------------
all: $(BUILD)
#---------------------------------------------------------------------------------
$(BUILD): $(BUILD):
@[ -d $@ ] || mkdir -p $@ @[ -d $@ ] || mkdir -p $@
# @$(Q)$(MAKE) -C sd_loader
@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile @$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
#--------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
clean: clean_channel clean:
@echo clean ... @echo clean ...
@rm -fr $(BUILD) $(OUTPUT).elf $(OUTPUT).bin $(BUILD_DBG).elf $(OUTPUT).rpx @rm -fr $(BUILD) $(TARGET).rpx $(TARGET).elf
# @$(MAKE) -C sd_loader clean
#--------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
install_channel: $(BUILD) NUSPacker.jar encryptKeyWith
@cp $(OUTPUT).rpx channel/code/
java -jar NUSPacker.jar -in "channel" -out "install_channel"
NUSPacker.jar:
wget https://bitbucket.org/timogus/nuspacker/downloads/NUSPacker.jar
encryptKeyWith:
@echo "Missing common key file \"encryptKeyWith\"! Insert the common key as string into \"encryptKeyWith\" file in the HBL Makefile path!"
@exit 1
clean_channel:
@rm -fr install_channel NUSPacker.jar fst.bin output tmp
#---------------------------------------------------------------------------------
else else
.PHONY: all
DEPENDS := $(OFILES:.o=.d) DEPENDS := $(OFILES:.o=.d)
#--------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
# main targets # main targets
#--------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
$(OUTPUT).rpx: $(OUTPUT).elf all : $(OUTPUT).rpx
$(OUTPUT).elf: $(OFILES)
#--------------------------------------------------------------------------------- $(OUTPUT).rpx : $(OUTPUT).elf
# This rule links in binary data with the .jpg extension $(OUTPUT).elf : $(OFILES)
#---------------------------------------------------------------------------------
%.elf: $(OFILES)
@echo "linking ... $(TARGET).elf"
$(Q)$(LD) $^ $(LDFLAGS) -o $@ $(LIBPATHS) $(LIBS)
# $(Q)$(OBJCOPY) -S -R .comment -R .gnu.attributes ../$(BUILD_DBG).elf $@
#--------------------------------------------------------------------------------- $(OFILES_SRC) : $(HFILES_BIN)
%.rpx: %.elf
#---------------------------------------------------------------------------------
@echo "[RPX] $(notdir $@)"
@$(ELF2RPL) $^ $@
#--------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
%.a: # you need a rule like this for each extension you use as binary data
#--------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
@echo $(notdir $@) %.bin.o %_bin.h : %.bin
@rm -f $@
@$(AR) -rc $@ $^
#---------------------------------------------------------------------------------
%.o: %.cpp
@echo $(notdir $<) @echo $(notdir $<)
@$(CXX) -MMD -MP -MF $(DEPSDIR)/$*.d $(CXXFLAGS) -c $< -o $@ $(ERROR_FILTER) @$(bin2o)
#--------------------------------------------------------------------------------- %.png.o %_png.h : %.png
%.o: %.c
@echo $(notdir $<) @echo $(notdir $<)
@$(CC) -MMD -MP -MF $(DEPSDIR)/$*.d $(CFLAGS) -c $< -o $@ $(ERROR_FILTER) @$(bin2o)
#--------------------------------------------------------------------------------- %.ogg.o %_ogg.h : %.ogg
%.o: %.S
@echo $(notdir $<) @echo $(notdir $<)
@$(CC) -MMD -MP -MF $(DEPSDIR)/$*.d -x assembler-with-cpp $(ASFLAGS) -c $< -o $@ $(ERROR_FILTER) @$(bin2o)
#--------------------------------------------------------------------------------- %.mp3.o %_mp3.h : %.mp3
%.png.o : %.png
@echo $(notdir $<) @echo $(notdir $<)
@bin2s -a 32 $< | $(AS) -o $(@) @$(bin2o)
#--------------------------------------------------------------------------------- %.ttf.o %_ttf.h : %.ttf
%.jpg.o : %.jpg
@echo $(notdir $<) @echo $(notdir $<)
@bin2s -a 32 $< | $(AS) -o $(@) @$(bin2o)
#---------------------------------------------------------------------------------
%.ttf.o : %.ttf
@echo $(notdir $<)
@bin2s -a 32 $< | $(AS) -o $(@)
#---------------------------------------------------------------------------------
%.bin.o : %.bin
@echo $(notdir $<)
@bin2s -a 32 $< | $(AS) -o $(@)
#---------------------------------------------------------------------------------
%.wav.o : %.wav
@echo $(notdir $<)
@bin2s -a 32 $< | $(AS) -o $(@)
#---------------------------------------------------------------------------------
%.mp3.o : %.mp3
@echo $(notdir $<)
@bin2s -a 32 $< | $(AS) -o $(@)
#---------------------------------------------------------------------------------
%.ogg.o : %.ogg
@echo $(notdir $<)
@bin2s -a 32 $< | $(AS) -o $(@)
-include $(DEPENDS) -include $(DEPENDS)
#--------------------------------------------------------------------------------- #-------------------------------------------------------------------------------
endif endif
#--------------------------------------------------------------------------------- #-------------------------------------------------------------------------------

View File

@ -1,18 +1,15 @@
#Flappy Bird RPX# # Flappy Bird RPX
A RPX Flappy Bird port for WiiU A RPX Flappy Bird port for WiiU
Assest from floppy bird HTML5 and original android game Assest from floppy bird HTML5 and original android game
#Installation# # Usage
Put the Flappy Bird folder on an SD card in the "install" folder. Use wup installer y mod to install to your NAND or USB. It is recommended to install to USB. Signature patching is required.
#Usage#
Press A to begin the Game Press A to begin the Game
Press A to jump Press A to jump
Press HOME to exit Press HOME to exit
Avoid the pipes and the floor! Avoid the pipes and the floor!
#Building# # Building
In order to build this application, you need the custom liboGC and portlibs modified/created by dimok. You can find them on the loadiine_gx2 repo (https://github.com/dimok789/loadiine_gx2/releases/tag/v0.2). Simply put the files in your devkit folder and run the Makefile. In order to build this application, you need [wut](https://github.com/devkitPro/wut/) and [libgui](https://github.com/wiiu-env/libgui) installed.
#Credits:# #Credits:#
<b>dimok</b> - WiiU librabries, dynamic_libs, examples, Homebrew Launcher <b>dimok</b> - WiiU librabries, dynamic_libs, examples, Homebrew Launcher

View File

@ -19,12 +19,11 @@
#include <proc_ui/procui.h> #include <proc_ui/procui.h>
#include <sysapp/launch.h> #include <sysapp/launch.h>
#include "Application.h" #include "Application.h"
#include "common/common.h"
#include "gui/FreeTypeGX.h" #include "gui/FreeTypeGX.h"
#include "gui/VPadController.h" #include "gui/VPadController.h"
#include "gui/WPadController.h" #include "gui/WPadController.h"
#include "resources/Resources.h" #include "resources/Resources.h"
#include "sounds/SoundHandler.hpp" #include "gui/sounds/SoundHandler.hpp"
#include "system/memory.h" #include "system/memory.h"
#include "utils/logger.h" #include "utils/logger.h"
@ -38,7 +37,7 @@ Application::Application()
, video(NULL) , video(NULL)
, mainWindow(NULL) , mainWindow(NULL)
, fontSystem(NULL) , fontSystem(NULL)
, exitCode(EXIT_RELAUNCH_ON_LOAD) , exitCode(0)
{ {
controller[0] = new VPadController(GuiTrigger::CHANNEL_1); controller[0] = new VPadController(GuiTrigger::CHANNEL_1);
controller[1] = new WPadController(GuiTrigger::CHANNEL_2); controller[1] = new WPadController(GuiTrigger::CHANNEL_2);
@ -47,10 +46,10 @@ Application::Application()
controller[4] = new WPadController(GuiTrigger::CHANNEL_5); controller[4] = new WPadController(GuiTrigger::CHANNEL_5);
//! create bgMusic //! create bgMusic
// bgMusic = new GuiSound(Resources::GetFile("bgMusic.ogg"), Resources::GetFileSize("bgMusic.ogg")); bgMusic = new GuiSound(Resources::GetFile("bgMusic.ogg"), Resources::GetFileSize("bgMusic.ogg"));
// bgMusic->SetLoop(true); bgMusic->SetLoop(true);
// bgMusic->Play(); bgMusic->Play();
// bgMusic->SetVolume(50); bgMusic->SetVolume(50);
exitApplication = false; exitApplication = false;

View File

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

View File

@ -1,69 +0,0 @@
#ifndef COMMON_H
#define COMMON_H
#ifdef __cplusplus
extern "C" {
#endif
#include "os_defs.h"
#define HBL_VERSION_INT 200
#define CAFE_OS_SD_PATH "/vol/external01"
#define SD_PATH "fs:"
#define WIIU_PATH "/wiiu"
/* Macros for libs */
#define LIB_CORE_INIT 0
#define LIB_NSYSNET 1
#define LIB_GX2 2
#define LIB_AOC 3
#define LIB_AX 4
#define LIB_FS 5
#define LIB_OS 6
#define LIB_PADSCORE 7
#define LIB_SOCKET 8
#define LIB_SYS 9
#define LIB_VPAD 10
#define LIB_NN_ACP 11
#define LIB_SYSHID 12
#define LIB_VPADBASE 13
// functions types
#define STATIC_FUNCTION 0
#define DYNAMIC_FUNCTION 1
// none dynamic libs
#define LIB_LOADER 0x1001
#ifndef MEM_BASE
#define MEM_BASE (0x00800000)
#endif
#define ELF_DATA_ADDR (*(volatile unsigned int*)(MEM_BASE + 0x1300 + 0x00))
#define ELF_DATA_SIZE (*(volatile unsigned int*)(MEM_BASE + 0x1300 + 0x04))
#define HBL_CHANNEL_OFFSET (0x1300 + 0x08)
#define HBL_CHANNEL (*(volatile unsigned int*)(MEM_BASE + HBL_CHANNEL_OFFSET))
#define RPX_MAX_SIZE (*(volatile unsigned int*)(MEM_BASE + 0x1300 + 0x0C))
#define RPX_MAX_CODE_SIZE (*(volatile unsigned int*)(MEM_BASE + 0x1300 + 0x10))
#define MAIN_ENTRY_ADDR (*(volatile unsigned int*)(MEM_BASE + 0x1400 + 0x00))
#define OS_FIRMWARE_OFFSET (0x1400 + 0x04)
#define OS_FIRMWARE (*(volatile unsigned int*)(MEM_BASE + 0x1400 + 0x04))
#define OS_SPECIFICS ((OsSpecifics*)(MEM_BASE + 0x1500))
#define MEM_AREA_TABLE ((s_mem_area*)(MEM_BASE + 0x1600))
#define APP_BASE_MEM ((unsigned char*)(MEM_BASE + 0x2000))
#ifndef EXIT_SUCCESS
#define EXIT_SUCCESS 0
#endif
#define EXIT_HBL_EXIT 0xFFFFFFFE
#define EXIT_RELAUNCH_ON_LOAD 0xFFFFFFFD
#ifdef __cplusplus
}
#endif
#endif /* COMMON_H */

View File

@ -1,177 +0,0 @@
#ifndef __GX2_EXTENSION_H
#define __GX2_EXTENSION_H
#ifdef __cplusplus
extern "C" {
#endif
#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>
#define GX2_FALSE 0
#define GX2_TRUE 1
#define GX2_DISABLE 0
#define GX2_ENABLE 1
#define GX2_COMMAND_BUFFER_SIZE 0x400000
#define GX2_SCAN_BUFFER_ALIGNMENT 0x1000
#define GX2_CONTEXT_STATE_ALIGNMENT 0x100
#define GX2_SHADER_ALIGNMENT 0x100
#define GX2_VERTEX_BUFFER_ALIGNMENT 0x40
#define GX2_INDEX_BUFFER_ALIGNMENT 0x20
#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
static const u32 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 u32 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
};
typedef struct _GX2Color {
u8 r, g, b, a;
} GX2Color;
typedef struct _GX2ColorF32 {
f32 r, g, b, a;
} GX2ColorF32;
static inline void GX2InitDepthBuffer(GX2DepthBuffer *depthBuffer, GX2SurfaceDim dim, u32 width, u32 height, u32 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, u32 width, u32 height, u32 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;
u32 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, u32 location, u32 buffer, u32 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, u32 width, u32 height, u32 depth, u32 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;
u32 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 /* COMMON_H */

View File

@ -1,40 +0,0 @@
#ifndef __OS_DEFS_H_
#define __OS_DEFS_H_
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _OsSpecifics
{
unsigned int addr_OSDynLoad_Acquire;
unsigned int addr_OSDynLoad_FindExport;
unsigned int addr_OSTitle_main_entry;
unsigned int addr_KernSyscallTbl1;
unsigned int addr_KernSyscallTbl2;
unsigned int addr_KernSyscallTbl3;
unsigned int addr_KernSyscallTbl4;
unsigned int addr_KernSyscallTbl5;
int (*LiWaitIopComplete)(int, int *);
int (*LiWaitIopCompleteWithInterrupts)(int, int *);
unsigned int addr_LiWaitOneChunk;
unsigned int addr_PrepareTitle_hook;
unsigned int addr_sgIsLoadingBuffer;
unsigned int addr_gDynloadInitialized;
unsigned int orig_LiWaitOneChunkInstr;
} OsSpecifics;
typedef struct _s_mem_area
{
unsigned int address;
unsigned int size;
struct _s_mem_area* next;
} s_mem_area;
#ifdef __cplusplus
}
#endif
#endif // __OS_DEFS_H_

View File

@ -1,7 +0,0 @@
#ifndef TYPES_H
#define TYPES_H
#include <wut_types.h>
#endif /* TYPES_H */

View File

@ -1,26 +0,0 @@
#ifndef __EXPORTS_H_
#define __EXPORTS_H_
#include <coreinit/dynload.h>
#include <coreinit/debug.h>
#define EXPORT_DECL(res, func, ...) res (* func)(__VA_ARGS__) __attribute__((section(".data"))) = 0;
#define EXPORT_VAR(type, var) type var __attribute__((section(".data")));
#define EXPORT_FUNC_WRITE(func, val) *(u32*)(((u32)&func) + 0) = (u32)val
#define OS_FIND_EXPORT(handle, func) funcPointer = 0; \
OSDynLoad_FindExport(handle, 0, # func, (void**) &funcPointer); \
if(!funcPointer) \
OSFatal("Function " # func " is NULL"); \
EXPORT_FUNC_WRITE(func, funcPointer);
#define OS_FIND_EXPORT_EX(handle, func, func_p) \
funcPointer = 0; \
OSDynLoad_FindExport(handle, 0, # func, (void**) &funcPointer); \
if(!funcPointer) \
OSFatal("Function " # func " is NULL"); \
EXPORT_FUNC_WRITE(func_p, funcPointer);
#endif

View File

@ -1,50 +0,0 @@
/****************************************************************************
* Copyright (C) 2015
* 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 "exports.h"
#include "padscore_functions.h"
EXPORT_DECL(void, KPADInit, void);
EXPORT_DECL(s32, WPADProbe, s32 chan, u32 * pad_type);
EXPORT_DECL(s32, WPADSetDataFormat, s32 chan, s32 format);
EXPORT_DECL(void, WPADEnableURCC, s32 enable);
EXPORT_DECL(void, WPADRead, s32 chan, void * data);
EXPORT_DECL(s32, KPADRead, s32 chan, void * data, u32 size);
void InitPadScoreFunctionPointers(void)
{
unsigned int *funcPointer = 0;
OSDynLoadModule padscore_handle;
OSDynLoad_Acquire("padscore.rpl", &padscore_handle);
OS_FIND_EXPORT(padscore_handle, KPADInit);
OS_FIND_EXPORT(padscore_handle, WPADProbe);
OS_FIND_EXPORT(padscore_handle, WPADSetDataFormat);
OS_FIND_EXPORT(padscore_handle, WPADEnableURCC);
OS_FIND_EXPORT(padscore_handle, WPADRead);
OS_FIND_EXPORT(padscore_handle, KPADRead);
KPADInit();
WPADEnableURCC(1);
}

View File

@ -1,122 +0,0 @@
/****************************************************************************
* Copyright (C) 2015
* 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 __PAD_SCORE_FUNCTIONS_H_
#define __PAD_SCORE_FUNCTIONS_H_
#ifdef __cplusplus
extern "C" {
#endif
#include "common/types.h"
#define WPAD_BUTTON_LEFT 0x0001
#define WPAD_BUTTON_RIGHT 0x0002
#define WPAD_BUTTON_DOWN 0x0004
#define WPAD_BUTTON_UP 0x0008
#define WPAD_BUTTON_PLUS 0x0010
#define WPAD_BUTTON_2 0x0100
#define WPAD_BUTTON_1 0x0200
#define WPAD_BUTTON_B 0x0400
#define WPAD_BUTTON_A 0x0800
#define WPAD_BUTTON_MINUS 0x1000
#define WPAD_BUTTON_Z 0x2000
#define WPAD_BUTTON_C 0x4000
#define WPAD_BUTTON_HOME 0x8000
#define WPAD_CLASSIC_BUTTON_UP 0x0001
#define WPAD_CLASSIC_BUTTON_LEFT 0x0002
#define WPAD_CLASSIC_BUTTON_ZR 0x0004
#define WPAD_CLASSIC_BUTTON_X 0x0008
#define WPAD_CLASSIC_BUTTON_A 0x0010
#define WPAD_CLASSIC_BUTTON_Y 0x0020
#define WPAD_CLASSIC_BUTTON_B 0x0040
#define WPAD_CLASSIC_BUTTON_ZL 0x0080
#define WPAD_CLASSIC_BUTTON_R 0x0200
#define WPAD_CLASSIC_BUTTON_PLUS 0x0400
#define WPAD_CLASSIC_BUTTON_HOME 0x0800
#define WPAD_CLASSIC_BUTTON_MINUS 0x1000
#define WPAD_CLASSIC_BUTTON_L 0x2000
#define WPAD_CLASSIC_BUTTON_DOWN 0x4000
#define WPAD_CLASSIC_BUTTON_RIGHT 0x8000
void InitPadScoreFunctionPointers(void);
typedef struct _KPADData
{
u32 btns_h;
u32 btns_d;
u32 btns_r;
u32 unused_1[5];
f32 pos_x;
f32 pos_y;
u32 unused_2[3];
f32 angle_x;
f32 angle_y;
u32 unused_3[8];
u8 device_type;
u8 wpad_error;
u8 pos_valid;
u8 unused_4[1];
union
{
struct
{
f32 stick_x;
f32 stick_y;
} nunchuck;
struct
{
u32 btns_h;
u32 btns_d;
u32 btns_r;
f32 lstick_x;
f32 lstick_y;
f32 rstick_x;
f32 rstick_y;
f32 ltrigger;
f32 rtrigger;
} classic;
u32 unused_6[20];
};
u32 unused_7[16];
} KPADData;
typedef void (* wpad_connect_callback_t)(s32 chan, s32 status);
extern void (* KPADInit)(void);
extern s32 (* WPADProbe)(s32 chan, u32 * pad_type);
extern s32 (* WPADSetDataFormat)(s32 chan, s32 format);
extern void (* WPADEnableURCC)(s32 enable);
extern void (* WPADRead)(s32 chan, void * data);
extern s32 (* KPADRead)(s32 chan, void * data, u32 size);
#ifdef __cplusplus
}
#endif
#endif // __PAD_SCORE_FUNCTIONS_H_

View File

@ -1,15 +1,11 @@
#include <string.h> #include <string.h>
#include <coreinit/title.h> #include <sysapp/launch.h>
#include "common/common.h"
#include "utils/utils.h"
#include "main.h" #include "main.h"
static volatile uint8_t ucRunOnce = 0;
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
//! ******************************************************************* //! *******************************************************************
//! * Jump to our application * //! * Jump to our application *
//! ******************************************************************* //! *******************************************************************
return Menu_Main(); return Menu_Main();
} }

View File

@ -1,40 +1,36 @@
#include <stdarg.h> #include <stdarg.h>
#include <stdlib.h> #include <stdlib.h>
#include "CFile.hpp" #include <stdio.h>
#include <strings.h>
#include <fs/CFile.hpp>
CFile::CFile() CFile::CFile() {
{ iFd = -1;
iFd = -1; mem_file = NULL;
mem_file = NULL; filesize = 0;
filesize = 0; pos = 0;
pos = 0;
} }
CFile::CFile(const std::string & filepath, eOpenTypes mode) CFile::CFile(const std::string & filepath, eOpenTypes mode) {
{ iFd = -1;
iFd = -1; this->open(filepath, mode);
this->open(filepath, mode);
} }
CFile::CFile(const u8 * mem, int size) CFile::CFile(const uint8_t * mem, int32_t size) {
{ iFd = -1;
iFd = -1; this->open(mem, size);
this->open(mem, size);
} }
CFile::~CFile() CFile::~CFile() {
{ this->close();
this->close();
} }
int CFile::open(const std::string & filepath, eOpenTypes mode) int32_t CFile::open(const std::string & filepath, eOpenTypes mode) {
{ this->close();
this->close();
s32 openMode = 0; int32_t openMode = 0;
switch(mode) switch(mode) {
{
default: default:
case ReadOnly: case ReadOnly:
openMode = O_RDONLY; openMode = O_RDONLY;
@ -48,80 +44,72 @@ int CFile::open(const std::string & filepath, eOpenTypes mode)
case Append: case Append:
openMode = O_APPEND | O_WRONLY; openMode = O_APPEND | O_WRONLY;
break; break;
} }
//! Using fopen works only on the first launch as expected //! Using fopen works only on the first launch as expected
//! on the second launch it causes issues because we don't overwrite //! on the second launch it causes issues because we don't overwrite
//! the .data sections which is needed for a normal application to re-init //! the .data sections which is needed for a normal application to re-init
//! this will be added with launching as RPX //! this will be added with launching as RPX
iFd = ::open(filepath.c_str(), openMode); iFd = ::open(filepath.c_str(), openMode);
if(iFd < 0) if(iFd < 0)
return iFd; return iFd;
filesize = ::lseek(iFd, 0, SEEK_END); filesize = ::lseek(iFd, 0, SEEK_END);
::lseek(iFd, 0, SEEK_SET); ::lseek(iFd, 0, SEEK_SET);
return 0; return 0;
} }
int CFile::open(const u8 * mem, int size) int32_t CFile::open(const uint8_t * mem, int32_t size) {
{ this->close();
this->close();
mem_file = mem; mem_file = mem;
filesize = size; filesize = size;
return 0; return 0;
} }
void CFile::close() void CFile::close() {
{ if(iFd >= 0)
if(iFd >= 0) ::close(iFd);
::close(iFd);
iFd = -1; iFd = -1;
mem_file = NULL; mem_file = NULL;
filesize = 0; filesize = 0;
pos = 0; pos = 0;
} }
int CFile::read(u8 * ptr, size_t size) int32_t CFile::read(uint8_t * ptr, size_t size) {
{ if(iFd >= 0) {
if(iFd >= 0) int32_t ret = ::read(iFd, ptr,size);
{ if(ret > 0)
int ret = ::read(iFd, ptr,size); pos += ret;
if(ret > 0) return ret;
pos += ret; }
return ret;
}
int readsize = size; int32_t readsize = size;
if(readsize > (s64) (filesize-pos)) if(readsize > (int64_t) (filesize-pos))
readsize = filesize-pos; readsize = filesize-pos;
if(readsize <= 0) if(readsize <= 0)
return readsize; return readsize;
if(mem_file != NULL) if(mem_file != NULL) {
{ memcpy(ptr, mem_file+pos, readsize);
memcpy(ptr, mem_file+pos, readsize); pos += readsize;
pos += readsize; return readsize;
return readsize; }
}
return -1; return -1;
} }
int CFile::write(const u8 * ptr, size_t size) int32_t CFile::write(const uint8_t * ptr, size_t size) {
{ if(iFd >= 0) {
if(iFd >= 0) size_t done = 0;
{ while(done < size) {
size_t done = 0; int32_t ret = ::write(iFd, ptr, size - done);
while(done < size)
{
int ret = ::write(iFd, ptr, size - done);
if(ret <= 0) if(ret <= 0)
return ret; return ret;
@ -129,67 +117,54 @@ int CFile::write(const u8 * ptr, size_t size)
done += ret; done += ret;
pos += ret; pos += ret;
} }
return done; return done;
} }
return -1; return -1;
} }
int CFile::seek(long int offset, int origin) int32_t CFile::seek(long int offset, int32_t origin) {
{ int32_t ret = 0;
int ret = 0; int64_t newPos = pos;
s64 newPos = pos;
if(origin == SEEK_SET) if(origin == SEEK_SET) {
{ newPos = offset;
newPos = offset; } else if(origin == SEEK_CUR) {
} newPos += offset;
else if(origin == SEEK_CUR) } else if(origin == SEEK_END) {
{ newPos = filesize+offset;
newPos += offset; }
}
else if(origin == SEEK_END)
{
newPos = filesize+offset;
}
if(newPos < 0) if(newPos < 0) {
{ pos = 0;
pos = 0; } else {
}
else {
pos = newPos; pos = newPos;
} }
if(iFd >= 0) if(iFd >= 0)
ret = ::lseek(iFd, pos, SEEK_SET); ret = ::lseek(iFd, pos, SEEK_SET);
if(mem_file != NULL) if(mem_file != NULL) {
{ if(pos > filesize) {
if(pos > filesize) pos = filesize;
{ }
pos = filesize; }
}
}
return ret; return ret;
} }
int CFile::fwrite(const char *format, ...) int32_t CFile::fwrite(const char *format, ...) {
{ char tmp[512];
int result = -1; tmp[0] = 0;
char * tmp = NULL; int32_t result = -1;
va_list va; va_list va;
va_start(va, format); va_start(va, format);
if((vasprintf(&tmp, format, va) >= 0) && tmp) if((vsprintf(tmp, format, va) >= 0)) {
{ result = this->write((uint8_t *)tmp, strlen(tmp));
result = this->write((u8 *)tmp, strlen(tmp)); }
} va_end(va);
va_end(va);
if(tmp)
free(tmp);
return result; return result;
} }

View File

@ -4,54 +4,58 @@
#include <stdio.h> #include <stdio.h>
#include <string> #include <string>
#include <string.h> #include <string.h>
#include <unistd.h>
#include <fcntl.h> #include <fcntl.h>
#include "common/types.h" #include <unistd.h>
#include <wut_types.h>
class CFile class CFile {
{ public:
public: enum eOpenTypes {
enum eOpenTypes ReadOnly,
{ WriteOnly,
ReadOnly, ReadWrite,
WriteOnly, Append
ReadWrite, };
Append
};
CFile(); CFile();
CFile(const std::string & filepath, eOpenTypes mode); CFile(const std::string & filepath, eOpenTypes mode);
CFile(const u8 * memory, int memsize); CFile(const uint8_t * memory, int32_t memsize);
virtual ~CFile(); virtual ~CFile();
int open(const std::string & filepath, eOpenTypes mode); int32_t open(const std::string & filepath, eOpenTypes mode);
int open(const u8 * memory, int memsize); int32_t open(const uint8_t * memory, int32_t memsize);
bool isOpen() const { BOOL isOpen() const {
if(iFd >= 0) if(iFd >= 0)
return true; return true;
if(mem_file) if(mem_file)
return true; return true;
return false; return false;
} }
void close(); void close();
int read(u8 * ptr, size_t size); int32_t read(uint8_t * ptr, size_t size);
int write(const u8 * ptr, size_t size); int32_t write(const uint8_t * ptr, size_t size);
int fwrite(const char *format, ...); int32_t fwrite(const char *format, ...);
int seek(long int offset, int origin); int32_t seek(long int offset, int32_t origin);
u64 tell() { return pos; }; uint64_t tell() {
u64 size() { return filesize; }; return pos;
void rewind() { this->seek(0, SEEK_SET); }; };
uint64_t size() {
return filesize;
};
void rewind() {
this->seek(0, SEEK_SET);
};
protected: protected:
int iFd; int32_t iFd;
const u8 * mem_file; const uint8_t * mem_file;
u64 filesize; uint64_t filesize;
u64 pos; uint64_t pos;
}; };
#endif #endif

View File

@ -28,205 +28,186 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <string> #include <string>
#include <strings.h>
#include <algorithm> #include <algorithm>
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/dirent.h> #include <sys/dirent.h>
#include "DirList.h" #include <fs/DirList.h>
#include "utils/StringTools.h" #include <utils/StringTools.h>
DirList::DirList() DirList::DirList() {
{ Flags = 0;
Flags = 0; Filter = 0;
Filter = 0; Depth = 0;
Depth = 0;
} }
DirList::DirList(const std::string & path, const char *filter, u32 flags, u32 maxDepth) DirList::DirList(const std::string & path, const char *filter, uint32_t flags, uint32_t maxDepth) {
{ this->LoadPath(path, filter, flags, maxDepth);
this->LoadPath(path, filter, flags, maxDepth); this->SortList();
this->SortList();
} }
DirList::~DirList() DirList::~DirList() {
{ ClearList();
ClearList();
} }
bool DirList::LoadPath(const std::string & folder, const char *filter, u32 flags, u32 maxDepth) BOOL DirList::LoadPath(const std::string & folder, const char *filter, uint32_t flags, uint32_t maxDepth) {
{ if(folder.empty()) return false;
if(folder.empty()) return false;
Flags = flags; Flags = flags;
Filter = filter; Filter = filter;
Depth = maxDepth; Depth = maxDepth;
std::string folderpath(folder); std::string folderpath(folder);
u32 length = folderpath.size(); uint32_t length = folderpath.size();
//! clear path of double slashes //! clear path of double slashes
RemoveDoubleSlashs(folderpath); StringTools::RemoveDoubleSlashs(folderpath);
//! remove last slash if exists //! remove last slash if exists
if(length > 0 && folderpath[length-1] == '/') if(length > 0 && folderpath[length-1] == '/')
folderpath.erase(length-1); folderpath.erase(length-1);
//! add root slash if missing //! add root slash if missing
if(folderpath.find('/') == std::string::npos) if(folderpath.find('/') == std::string::npos) {
folderpath += '/'; folderpath += '/';
}
return InternalLoadPath(folderpath); return InternalLoadPath(folderpath);
} }
bool DirList::InternalLoadPath(std::string &folderpath) BOOL DirList::InternalLoadPath(std::string &folderpath) {
{ if(folderpath.size() < 3)
if(folderpath.size() < 3) return false;
return false;
struct dirent *dirent = NULL; struct dirent *dirent = NULL;
DIR *dir = NULL; DIR *dir = NULL;
dir = opendir(folderpath.c_str()); dir = opendir(folderpath.c_str());
if (dir == NULL) if (dir == NULL)
return false; return false;
while ((dirent = readdir(dir)) != 0) while ((dirent = readdir(dir)) != 0) {
{ BOOL isDir = dirent->d_type & DT_DIR;
bool isDir = dirent->d_type & DT_DIR; const char *filename = dirent->d_name;
const char *filename = dirent->d_name;
if(isDir) if(isDir) {
{ if(strcmp(filename,".") == 0 || strcmp(filename,"..") == 0)
if(strcmp(filename,".") == 0 || strcmp(filename,"..") == 0) continue;
continue;
if((Flags & CheckSubfolders) && (Depth > 0)) if((Flags & CheckSubfolders) && (Depth > 0)) {
{ int32_t length = folderpath.size();
int length = folderpath.size(); if(length > 2 && folderpath[length-1] != '/') {
if(length > 2 && folderpath[length-1] != '/') folderpath += '/';
folderpath += '/'; }
folderpath += filename; folderpath += filename;
Depth--; Depth--;
InternalLoadPath(folderpath); InternalLoadPath(folderpath);
folderpath.erase(length); folderpath.erase(length);
Depth++; Depth++;
} }
if(!(Flags & Dirs)) if(!(Flags & Dirs))
continue; continue;
} } else if(!(Flags & Files)) {
else if(!(Flags & Files)) continue;
{ }
continue;
}
if(Filter) if(Filter) {
{ char * fileext = strrchr(filename, '.');
char * fileext = strrchr(filename, '.'); if(!fileext)
if(!fileext) continue;
continue;
if(strtokcmp(fileext, Filter, ",") == 0) if(StringTools::strtokcmp(fileext, Filter, ",") == 0)
AddEntrie(folderpath, filename, isDir); AddEntrie(folderpath, filename, isDir);
} } else {
else AddEntrie(folderpath, filename, isDir);
{ }
AddEntrie(folderpath, filename, isDir); }
} closedir(dir);
}
closedir(dir);
return true; return true;
} }
void DirList::AddEntrie(const std::string &filepath, const char * filename, bool isDir) void DirList::AddEntrie(const std::string &filepath, const char * filename, BOOL isDir) {
{ if(!filename)
if(!filename) return;
return;
int pos = FileInfo.size(); int32_t pos = FileInfo.size();
FileInfo.resize(pos+1); FileInfo.resize(pos+1);
FileInfo[pos].FilePath = (char *) malloc(filepath.size()+strlen(filename)+2); FileInfo[pos].FilePath = (char *) malloc(filepath.size()+strlen(filename)+2);
if(!FileInfo[pos].FilePath) if(!FileInfo[pos].FilePath) {
{ FileInfo.resize(pos);
FileInfo.resize(pos); return;
return; }
}
sprintf(FileInfo[pos].FilePath, "%s/%s", filepath.c_str(), filename); sprintf(FileInfo[pos].FilePath, "%s/%s", filepath.c_str(), filename);
FileInfo[pos].isDir = isDir; FileInfo[pos].isDir = isDir;
} }
void DirList::ClearList() void DirList::ClearList() {
{ for(uint32_t i = 0; i < FileInfo.size(); ++i) {
for(u32 i = 0; i < FileInfo.size(); ++i) if(FileInfo[i].FilePath) {
{ free(FileInfo[i].FilePath);
if(FileInfo[i].FilePath) FileInfo[i].FilePath = NULL;
free(FileInfo[i].FilePath); }
} }
FileInfo.clear(); FileInfo.clear();
std::vector<DirEntry>().swap(FileInfo); std::vector<DirEntry>().swap(FileInfo);
} }
const char * DirList::GetFilename(int ind) const const char * DirList::GetFilename(int32_t ind) const {
{ if (!valid(ind))
if (!valid(ind)) return "";
return "";
return FullpathToFilename(FileInfo[ind].FilePath); return StringTools::FullpathToFilename(FileInfo[ind].FilePath);
} }
static bool SortCallback(const DirEntry & f1, const DirEntry & f2) static BOOL SortCallback(const DirEntry & f1, const DirEntry & f2) {
{ if(f1.isDir && !(f2.isDir)) return true;
if(f1.isDir && !(f2.isDir)) return true; if(!(f1.isDir) && f2.isDir) return false;
if(!(f1.isDir) && f2.isDir) return false;
if(f1.FilePath && !f2.FilePath) return true; if(f1.FilePath && !f2.FilePath) return true;
if(!f1.FilePath) return false; if(!f1.FilePath) return false;
if(strcasecmp(f1.FilePath, f2.FilePath) > 0) if(strcasecmp(f1.FilePath, f2.FilePath) > 0)
return false; return false;
return true; return true;
} }
void DirList::SortList() void DirList::SortList() {
{ if(FileInfo.size() > 1)
if(FileInfo.size() > 1) std::sort(FileInfo.begin(), FileInfo.end(), SortCallback);
std::sort(FileInfo.begin(), FileInfo.end(), SortCallback);
} }
void DirList::SortList(bool (*SortFunc)(const DirEntry &a, const DirEntry &b)) void DirList::SortList(BOOL (*SortFunc)(const DirEntry &a, const DirEntry &b)) {
{ if(FileInfo.size() > 1)
if(FileInfo.size() > 1) std::sort(FileInfo.begin(), FileInfo.end(), SortFunc);
std::sort(FileInfo.begin(), FileInfo.end(), SortFunc);
} }
u64 DirList::GetFilesize(int index) const uint64_t DirList::GetFilesize(int32_t index) const {
{ struct stat st;
struct stat st; const char *path = GetFilepath(index);
const char *path = GetFilepath(index);
if(!path || stat(path, &st) != 0) if(!path || stat(path, &st) != 0)
return 0; return 0;
return st.st_size; return st.st_size;
} }
int DirList::GetFileIndex(const char *filename) const int32_t DirList::GetFileIndex(const char *filename) const {
{ if(!filename)
if(!filename) return -1;
return -1;
for (u32 i = 0; i < FileInfo.size(); ++i) for (uint32_t i = 0; i < FileInfo.size(); ++i) {
{ if (strcasecmp(GetFilename(i), filename) == 0)
if (strcasecmp(GetFilename(i), filename) == 0) return i;
return i; }
}
return -1; return -1;
} }

View File

@ -29,68 +29,75 @@
#include <vector> #include <vector>
#include <string> #include <string>
#include "common/types.h" #include <wut_types.h>
typedef struct typedef struct {
{ char * FilePath;
char * FilePath; BOOL isDir;
bool isDir;
} DirEntry; } DirEntry;
class DirList class DirList {
{
public: public:
//!Constructor //!Constructor
DirList(void); DirList(void);
//!\param path Path from where to load the filelist of all files //!\param path Path from where to load the filelist of all files
//!\param filter A fileext that needs to be filtered //!\param filter A fileext that needs to be filtered
//!\param flags search/filter flags from the enum //!\param flags search/filter flags from the enum
DirList(const std::string & path, const char *filter = NULL, u32 flags = Files | Dirs, u32 maxDepth = 0xffffffff); DirList(const std::string & path, const char *filter = NULL, uint32_t flags = Files | Dirs, uint32_t maxDepth = 0xffffffff);
//!Destructor //!Destructor
virtual ~DirList(); virtual ~DirList();
//! Load all the files from a directory //! Load all the files from a directory
bool LoadPath(const std::string & path, const char *filter = NULL, u32 flags = Files | Dirs, u32 maxDepth = 0xffffffff); BOOL LoadPath(const std::string & path, const char *filter = NULL, uint32_t flags = Files | Dirs, uint32_t maxDepth = 0xffffffff);
//! Get a filename of the list //! Get a filename of the list
//!\param list index //!\param list index
const char * GetFilename(int index) const; const char * GetFilename(int32_t index) const;
//! Get the a filepath of the list //! Get the a filepath of the list
//!\param list index //!\param list index
const char *GetFilepath(int index) const { if (!valid(index)) return ""; else return FileInfo[index].FilePath; } const char *GetFilepath(int32_t index) const {
//! Get the a filesize of the list if (!valid(index)) return "";
//!\param list index else return FileInfo[index].FilePath;
u64 GetFilesize(int index) const; }
//! Is index a dir or a file //! Get the a filesize of the list
//!\param list index //!\param list index
bool IsDir(int index) const { if(!valid(index)) return false; return FileInfo[index].isDir; }; uint64_t GetFilesize(int32_t index) const;
//! Get the filecount of the whole list //! Is index a dir or a file
int GetFilecount() const { return FileInfo.size(); }; //!\param list index
//! Sort list by filepath BOOL IsDir(int32_t index) const {
void SortList(); if(!valid(index)) return false;
//! Custom sort command for custom sort functions definitions return FileInfo[index].isDir;
void SortList(bool (*SortFunc)(const DirEntry &a, const DirEntry &b)); };
//! Get the index of the specified filename //! Get the filecount of the whole list
int GetFileIndex(const char *filename) const; int32_t GetFilecount() const {
//! Enum for search/filter flags return FileInfo.size();
enum };
{ //! Sort list by filepath
Files = 0x01, void SortList();
Dirs = 0x02, //! Custom sort command for custom sort functions definitions
CheckSubfolders = 0x08, void SortList(BOOL (*SortFunc)(const DirEntry &a, const DirEntry &b));
}; //! Get the index of the specified filename
int32_t GetFileIndex(const char *filename) const;
//! Enum for search/filter flags
enum {
Files = 0x01,
Dirs = 0x02,
CheckSubfolders = 0x08,
};
protected: protected:
// Internal parser // Internal parser
bool InternalLoadPath(std::string &path); BOOL InternalLoadPath(std::string &path);
//!Add a list entrie //!Add a list entrie
void AddEntrie(const std::string &filepath, const char * filename, bool isDir); void AddEntrie(const std::string &filepath, const char * filename, BOOL isDir);
//! Clear the list //! Clear the list
void ClearList(); void ClearList();
//! Check if valid pos is requested //! Check if valid pos is requested
inline bool valid(u32 pos) const { return (pos < FileInfo.size()); }; inline BOOL valid(uint32_t pos) const {
return (pos < FileInfo.size());
};
u32 Flags; uint32_t Flags;
u32 Depth; uint32_t Depth;
const char *Filter; const char *Filter;
std::vector<DirEntry> FileInfo; std::vector<DirEntry> FileInfo;
}; };
#endif #endif

144
src/fs/FSUtils.cpp Normal file
View File

@ -0,0 +1,144 @@
#include <malloc.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <fs/FSUtils.h>
#include <fs/CFile.hpp>
#include <utils/logger.h>
int32_t FSUtils::LoadFileToMem(const char *filepath, uint8_t **inbuffer, uint32_t *size) {
//! always initialze input
*inbuffer = NULL;
if(size)
*size = 0;
int32_t iFd = open(filepath, O_RDONLY);
if (iFd < 0)
return -1;
uint32_t filesize = lseek(iFd, 0, SEEK_END);
lseek(iFd, 0, SEEK_SET);
uint8_t *buffer = (uint8_t *) malloc(filesize);
if (buffer == NULL) {
close(iFd);
return -2;
}
uint32_t blocksize = 0x4000;
uint32_t done = 0;
int32_t readBytes = 0;
while(done < filesize) {
if(done + blocksize > filesize) {
blocksize = filesize - done;
}
readBytes = read(iFd, buffer + done, blocksize);
if(readBytes <= 0)
break;
done += readBytes;
}
close(iFd);
if (done != filesize) {
free(buffer);
buffer = NULL;
return -3;
}
*inbuffer = buffer;
//! sign is optional input
if(size) {
*size = filesize;
}
return filesize;
}
int32_t FSUtils::CheckFile(const char * filepath) {
if(!filepath)
return 0;
struct stat filestat;
char dirnoslash[strlen(filepath)+2];
snprintf(dirnoslash, sizeof(dirnoslash), "%s", filepath);
while(dirnoslash[strlen(dirnoslash)-1] == '/')
dirnoslash[strlen(dirnoslash)-1] = '\0';
char * notRoot = strrchr(dirnoslash, '/');
if(!notRoot) {
strcat(dirnoslash, "/");
}
if (stat(dirnoslash, &filestat) == 0)
return 1;
return 0;
}
int32_t FSUtils::CreateSubfolder(const char * fullpath) {
if(!fullpath)
return 0;
int32_t result = 0;
char dirnoslash[strlen(fullpath)+1];
strcpy(dirnoslash, fullpath);
int32_t pos = strlen(dirnoslash)-1;
while(dirnoslash[pos] == '/') {
dirnoslash[pos] = '\0';
pos--;
}
if(CheckFile(dirnoslash)) {
return 1;
} else {
char parentpath[strlen(dirnoslash)+2];
strcpy(parentpath, dirnoslash);
char * ptr = strrchr(parentpath, '/');
if(!ptr) {
//!Device root directory (must be with '/')
strcat(parentpath, "/");
struct stat filestat;
if (stat(parentpath, &filestat) == 0)
return 1;
return 0;
}
ptr++;
ptr[0] = '\0';
result = CreateSubfolder(parentpath);
}
if(!result)
return 0;
if (mkdir(dirnoslash, 0777) == -1) {
return 0;
}
return 1;
}
BOOL FSUtils::saveBufferToFile(const char * path, void * buffer, uint32_t size) {
int32_t res = open(path, O_CREAT | O_TRUNC | O_WRONLY);
close(res);
CFile file(path, CFile::WriteOnly);
if (!file.isOpen()) {
DEBUG_FUNCTION_LINE("Failed to open %s\n",path);
return false;
}
file.write((const uint8_t*) buffer,size);
file.close();
return true;
}

16
src/fs/FSUtils.h Normal file
View File

@ -0,0 +1,16 @@
#ifndef __FS_UTILS_H_
#define __FS_UTILS_H_
#include <wut_types.h>
class FSUtils {
public:
static int32_t LoadFileToMem(const char *filepath, uint8_t **inbuffer, uint32_t *size);
//! todo: C++ class
static int32_t CreateSubfolder(const char * fullpath);
static int32_t CheckFile(const char * filepath);
static BOOL saveBufferToFile(const char * path, void * buffer, uint32_t size);
};
#endif // __FS_UTILS_H_

View File

@ -1,182 +0,0 @@
#include <malloc.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <coreinit/filesystem.h>
#define FS_MAX_MOUNTPATH_SIZE 128
int MountFS(void *pClient, void *pCmd, char **mount_path)
{
int result = -1;
void *mountSrc = malloc(sizeof(FSMountSource));
if(!mountSrc)
return -3;
char* mountPath = (char*) malloc(FS_MAX_MOUNTPATH_SIZE);
if(!mountPath) {
free(mountSrc);
return -4;
}
memset(mountSrc, 0, sizeof(FSMountSource));
memset(mountPath, 0, FS_MAX_MOUNTPATH_SIZE);
// Mount sdcard
if (FSGetMountSource(pClient, pCmd, FS_MOUNT_SOURCE_SD, mountSrc, -1) == 0)
{
result = FSMount(pClient, pCmd, mountSrc, mountPath, FS_MAX_MOUNTPATH_SIZE, -1);
if((result == 0) && mount_path) {
*mount_path = (char*)malloc(strlen(mountPath) + 1);
if(*mount_path)
strcpy(*mount_path, mountPath);
}
}
free(mountPath);
free(mountSrc);
return result;
}
int UmountFS(void *pClient, void *pCmd, const char *mountPath)
{
int result = -1;
result = FSUnmount(pClient, pCmd, mountPath, -1);
return result;
}
int LoadFileToMem(const char *filepath, u8 **inbuffer, u32 *size)
{
//! always initialze input
*inbuffer = NULL;
if(size)
*size = 0;
int iFd = open(filepath, O_RDONLY);
if (iFd < 0)
return -1;
u32 filesize = lseek(iFd, 0, SEEK_END);
lseek(iFd, 0, SEEK_SET);
u8 *buffer = (u8 *) malloc(filesize);
if (buffer == NULL)
{
close(iFd);
return -2;
}
u32 blocksize = 0x4000;
u32 done = 0;
int readBytes = 0;
while(done < filesize)
{
if(done + blocksize > filesize) {
blocksize = filesize - done;
}
readBytes = read(iFd, buffer + done, blocksize);
if(readBytes <= 0)
break;
done += readBytes;
}
close(iFd);
if (done != filesize)
{
free(buffer);
return -3;
}
*inbuffer = buffer;
//! sign is optional input
if(size)
*size = filesize;
return filesize;
}
int CheckFile(const char * filepath)
{
if(!filepath)
return 0;
struct stat filestat;
char dirnoslash[strlen(filepath)+2];
snprintf(dirnoslash, sizeof(dirnoslash), "%s", filepath);
while(dirnoslash[strlen(dirnoslash)-1] == '/')
dirnoslash[strlen(dirnoslash)-1] = '\0';
char * notRoot = strrchr(dirnoslash, '/');
if(!notRoot)
{
strcat(dirnoslash, "/");
}
if (stat(dirnoslash, &filestat) == 0)
return 1;
return 0;
}
int CreateSubfolder(const char * fullpath)
{
if(!fullpath)
return 0;
int result = 0;
char dirnoslash[strlen(fullpath)+1];
strcpy(dirnoslash, fullpath);
int pos = strlen(dirnoslash)-1;
while(dirnoslash[pos] == '/')
{
dirnoslash[pos] = '\0';
pos--;
}
if(CheckFile(dirnoslash))
{
return 1;
}
else
{
char parentpath[strlen(dirnoslash)+2];
strcpy(parentpath, dirnoslash);
char * ptr = strrchr(parentpath, '/');
if(!ptr)
{
//!Device root directory (must be with '/')
strcat(parentpath, "/");
struct stat filestat;
if (stat(parentpath, &filestat) == 0)
return 1;
return 0;
}
ptr++;
ptr[0] = '\0';
result = CreateSubfolder(parentpath);
}
if(!result)
return 0;
if (mkdir(dirnoslash, 0777) == -1)
{
return 0;
}
return 1;
}

View File

@ -1,23 +0,0 @@
#ifndef __FS_UTILS_H_
#define __FS_UTILS_H_
#ifdef __cplusplus
extern "C" {
#endif
#include "common/types.h"
int MountFS(void *pClient, void *pCmd, char **mount_path);
int UmountFS(void *pClient, void *pCmd, const char *mountPath);
int LoadFileToMem(const char *filepath, u8 **inbuffer, u32 *size);
//! todo: C++ class
int CreateSubfolder(const char * fullpath);
int CheckFile(const char * filepath);
#ifdef __cplusplus
}
#endif
#endif // __FS_UTILS_H_

View File

@ -1,608 +0,0 @@
/*
* 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/>.
*/
#include "video/CVideo.h"
#include "video/shaders/Texture2DShader.h"
#include "FreeTypeGX.h"
using namespace std;
#define ALIGN4(x) (((x) + 3) & ~3)
/**
* Default constructor for the FreeTypeGX class for WiiXplorer.
*/
FreeTypeGX::FreeTypeGX(const uint8_t* fontBuffer, FT_Long bufferSize, bool lastFace)
{
int faceIndex = 0;
ftPointSize = 0;
GX2InitSampler(&ftSampler, GX2_TEX_CLAMP_MODE_CLAMP_BORDER, GX2_TEX_XY_FILTER_MODE_LINEAR);
FT_Init_FreeType(&ftLibrary);
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);
}
/**
* Default destructor for the FreeTypeGX class.
*/
FreeTypeGX::~FreeTypeGX()
{
unloadFont();
FT_Done_Face(ftFace);
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;
wchar_t *strWChar = new (std::nothrow) wchar_t[strlen(strChar) + 1];
if (!strWChar) return NULL;
int bt = mbstowcs(strWChar, strChar, strlen(strChar));
if (bt > 0)
{
strWChar[bt] = 0;
return strWChar;
}
wchar_t *tempDest = strWChar;
while ((*tempDest++ = *strChar++))
;
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);
}
}
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;
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();
}
/**
* 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)
{
map<int16_t, ftGX2Data>::iterator itr = fontData.find(pixelSize);
if (itr != fontData.end())
{
map<wchar_t, ftgxCharData>::iterator itr2 = itr->second.ftgxCharMap.find(charCode);
if (itr2 != itr->second.ftgxCharMap.end())
{
return &itr2->second;
}
}
//!Cache ascender and decender as well
ftGX2Data *ftData = &fontData[pixelSize];
FT_UInt gIndex;
uint16_t textureWidth = 0, textureHeight = 0;
if (ftPointSize != pixelSize)
{
ftPointSize = pixelSize;
FT_Set_Pixel_Sizes(ftFace, 0, ftPointSize);
ftData->ftgxAlign.ascender = (int16_t) ftFace->size->metrics.ascender >> 6;
ftData->ftgxAlign.descender = (int16_t) ftFace->size->metrics.descender >> 6;
ftData->ftgxAlign.max = 0;
ftData->ftgxAlign.min = 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;
//! Initialize texture
charData->texture = new GX2Texture;
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);
loadGlyphData(glyphBitmap, charData);
return charData;
}
}
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;
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);
}
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.
*/
void 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;
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;
int32_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);
}
/**
* 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)
{
std::map<int16_t, ftGX2Data>::iterator itr = fontData.find(pixelSize);
if (itr == fontData.end()) return 0;
switch (format & FTGX_ALIGN_MASK)
{
case FTGX_ALIGN_TOP:
return itr->second.ftgxAlign.descender;
case FTGX_ALIGN_MIDDLE:
default:
return (itr->second.ftgxAlign.ascender + itr->second.ftgxAlign.descender + 1) >> 1;
case FTGX_ALIGN_BOTTOM:
return itr->second.ftgxAlign.ascender;
case FTGX_ALIGN_BASELINE:
return 0;
case FTGX_ALIGN_GLYPH_TOP:
return itr->second.ftgxAlign.max;
case FTGX_ALIGN_GLYPH_MIDDLE:
return (itr->second.ftgxAlign.max + itr->second.ftgxAlign.min + 1) >> 1;
case FTGX_ALIGN_GLYPH_BOTTOM:
return itr->second.ftgxAlign.min;
}
return 0;
}
/**
* 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 & internalRenderingScale)
{
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);
}
int i = 0;
while (text[i])
{
ftgxCharData* glyphData = cacheGlyphData(text[i], pixelSize);
if (glyphData != NULL)
{
if (ftKerningEnabled && i > 0)
{
FT_Get_Kerning(ftFace, fontData[pixelSize].ftgxCharMap[text[i - 1]].glyphIndex, glyphData->glyphIndex, FT_KERNING_DEFAULT, &pairDelta);
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,internalRenderingScale);
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;
FT_Vector pairDelta;
int i = 0;
while (text[i])
{
ftgxCharData* glyphData = cacheGlyphData(text[i], pixelSize);
if (glyphData != NULL)
{
if (ftKerningEnabled && (i > 0))
{
FT_Get_Kerning(ftFace, fontData[pixelSize].ftgxCharMap[text[i - 1]].glyphIndex, glyphData->glyphIndex, FT_KERNING_DEFAULT, &pairDelta);
strWidth += pairDelta.x >> 6;
}
strWidth += glyphData->glyphAdvanceX;
}
++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;
FT_Get_Kerning(ftFace, fontData[pixelSize].ftgxCharMap[prevChar].glyphIndex, glyphData->glyphIndex, FT_KERNING_DEFAULT, &pairDelta);
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)
{
getOffset(text, pixelSize);
return fontData[pixelSize].ftgxAlign.max - fontData[pixelSize].ftgxAlign.min;
}
/**
* Get the maximum offset above and minimum offset below the font origin line.
*
* This function calculates the maximum pixel height above the font origin line and the minimum
* pixel height below the font origin line and returns the values in an addressible structure.
*
* @param text NULL terminated string to calculate.
* @param offset returns the max and min values above and below the font origin line
*
*/
void FreeTypeGX::getOffset(const wchar_t *text, int16_t pixelSize, uint16_t widthLimit)
{
if (fontData.find(pixelSize) != fontData.end())
return;
int16_t strMax = 0, strMin = 9999;
uint16_t currWidth = 0;
int i = 0;
while (text[i])
{
if (widthLimit > 0 && currWidth >= widthLimit) break;
ftgxCharData* glyphData = cacheGlyphData(text[i], pixelSize);
if (glyphData != NULL)
{
strMax = glyphData->renderOffsetMax > strMax ? glyphData->renderOffsetMax : strMax;
strMin = glyphData->renderOffsetMin < strMin ? glyphData->renderOffsetMin : strMin;
currWidth += glyphData->glyphAdvanceX;
}
++i;
}
if (ftPointSize != pixelSize)
{
ftPointSize = pixelSize;
FT_Set_Pixel_Sizes(ftFace, 0, ftPointSize);
}
fontData[pixelSize].ftgxAlign.ascender = ftFace->size->metrics.ascender >> 6;
fontData[pixelSize].ftgxAlign.descender = ftFace->size->metrics.descender >> 6;
fontData[pixelSize].ftgxAlign.max = strMax;
fontData[pixelSize].ftgxAlign.min = 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 & internalRenderingScale)
{
static const f32 imageAngle = 0.0f;
static const f32 blurScale = (2.0f/ (internalRenderingScale));
f32 offsetLeft = blurScale * ((f32)x + 0.5f * (f32)texture->surface.width) * (f32)pVideo->getWidthScaleFactor();
f32 offsetTop = blurScale * ((f32)y - 0.5f * (f32)texture->surface.height) * (f32)pVideo->getHeightScaleFactor();
f32 widthScale = blurScale * (f32)texture->surface.width * pVideo->getWidthScaleFactor();
f32 heightScale = blurScale * (f32)texture->surface.height * pVideo->getHeightScaleFactor();
glm::vec3 positionOffsets( offsetLeft, offsetTop, (f32)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();
}

View File

@ -1,154 +0,0 @@
/*
* 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/>.
*/
#ifndef FREETYPEGX_H_
#define FREETYPEGX_H_
#include <string>
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_BITMAP_H
#include <malloc.h>
#include <string.h>
#include <wchar.h>
#include <map>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include "common/types.h"
/*! \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. */
int16_t ftPointSize; /**< Current set size of the rendered font. */
bool ftKerningEnabled; /**< Flag indicating the availability of font kerning data. */
uint8_t vertexIndex; /**< Vertex format descriptor index. */
GX2Sampler ftSampler;
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);
void 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 & internalRenderingScale);
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 & internalRenderingScale);
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);
void getOffset(const wchar_t *text, int16_t pixelSize, uint16_t widthLimit = 0);
static wchar_t* charToWideChar(const char* p);
static char* wideCharToUTF8(const wchar_t* strChar);
};
#endif /* FREETYPEGX_H_ */

View File

@ -1,42 +0,0 @@
#include "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
f32 currPosX = getCenterX();
f32 currPosY = getCenterY();
f32 currPosZ = getDepth();
f32 currScaleX = getScaleX() * (f32)getWidth() * pVideo->getWidthScaleFactor();
f32 currScaleY = getScaleY() * (f32)getHeight() * pVideo->getHeightScaleFactor();
f32 currScaleZ = getScaleZ() * (f32)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();
}

View File

@ -1,23 +0,0 @@
#ifndef _GAME_BG_IMAGE_H_
#define _GAME_BG_IMAGE_H_
#include "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);
private:
glm::mat4 identity;
glm::vec4 alphaFadeOut;
};
#endif // _GAME_BG_IMAGE_H_

View File

@ -1,321 +0,0 @@
#include "GameIcon.h"
#include "GameIconModel.h"
#include "Application.h"
#include "video/CVideo.h"
#include "video/shaders/Shader3D.h"
#include "video/shaders/ShaderFractalColor.h"
static const f32 cfIconMirrorScale = 1.15f;
static const f32 cfIconMirrorAlpha = 0.45f;
GameIcon::GameIcon(const std::string & filename, GuiImageData *preloadImage)
: GuiImageAsync(filename, preloadImage)
{
bSelected = false;
bRenderStroke = true;
bRenderReflection = false;
bIconLast = false;
strokeFractalEnable = 1;
strokeBlurBorder = 0.0f;
distanceFadeout = 0.0f;
rotationX = 0.0f;
reflectionAlpha = 0.4f;
strokeWidth = 2.35f;
colorIntensity = glm::vec4(1.0f);
colorIntensityMirror = colorIntensity;
alphaFadeOutNorm = glm::vec4(0.0f);
alphaFadeOutRefl = glm::vec4(-1.0f, 0.0f, 0.9f, 1.0f);
selectionBlurOuterColorIntensity = glm::vec4(0.09411764f * 1.15f, 0.56862745f * 1.15f, 0.96862745098f * 1.15f, 1.0f);
selectionBlurOuterSize = 1.65f;
selectionBlurOuterBorderSize = 0.5f;
selectionBlurInnerColorIntensity = glm::vec4(0.46666667f, 0.90588235f, 1.0f, 1.0f);
selectionBlurInnerSize = 1.45f;
selectionBlurInnerBorderSize = 0.95f;
vtxCount = sizeof(cfGameIconPosVtxs) / (Shader3D::cuVertexAttrSize);
//! texture and vertex coordinates
posVtxs = (f32*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, sizeof(cfGameIconPosVtxs));
texCoords = (f32*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, sizeof(cfGameIconTexCoords));
if(posVtxs)
{
memcpy((f32*)posVtxs, cfGameIconPosVtxs, sizeof(cfGameIconPosVtxs));
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, (f32*)posVtxs, sizeof(cfGameIconPosVtxs));
}
if(texCoords)
{
memcpy((f32*)texCoords, cfGameIconTexCoords, sizeof(cfGameIconTexCoords));
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, (f32*)texCoords, sizeof(cfGameIconTexCoords));
}
//! create vertexes for the mirror frame
texCoordsMirror = (f32*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, sizeof(cfGameIconTexCoords));
if(texCoordsMirror)
{
for(u32 i = 0; i < vtxCount; i++)
{
texCoordsMirror[i*2 + 0] = texCoords[i*2 + 0] * cfIconMirrorScale - ((cfIconMirrorScale - 1.0f) - (cfIconMirrorScale - 1.0f) * 0.5f);
texCoordsMirror[i*2 + 1] = texCoords[i*2 + 1] * cfIconMirrorScale - ((cfIconMirrorScale - 1.0f) - (cfIconMirrorScale - 1.0f) * 0.5f);
}
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, texCoordsMirror, sizeof(cfGameIconTexCoords));
}
//! setup stroke of the icon
strokePosVtxs = (f32*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, sizeof(cfGameIconStrokeVtxs));
if(strokePosVtxs)
{
memcpy(strokePosVtxs, cfGameIconStrokeVtxs, sizeof(cfGameIconStrokeVtxs));
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, strokePosVtxs, sizeof(cfGameIconStrokeVtxs));
}
strokeTexCoords = (f32*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, cuGameIconStrokeVtxCount * Shader::cuTexCoordAttrSize);
if(strokeTexCoords)
{
for(size_t i = 0, n = 0; i < cuGameIconStrokeVtxCount; n += 2, i += 3)
{
strokeTexCoords[n] = (1.0f + strokePosVtxs[i]) * 0.5f;
strokeTexCoords[n+1] = 1.0f - (1.0f + strokePosVtxs[i+1]) * 0.5f;
}
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, strokeTexCoords, cuGameIconStrokeVtxCount * Shader::cuTexCoordAttrSize);
}
strokeColorVtxs = (u8*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, cuGameIconStrokeVtxCount * Shader::cuColorAttrSize);
if(strokeColorVtxs)
{
for(size_t i = 0; i < (cuGameIconStrokeVtxCount * Shader::cuColorAttrSize); i++)
strokeColorVtxs[i] = 0xff;
GX2Invalidate(GX2_INVALIDATE_MODE_CPU_ATTRIBUTE_BUFFER, strokeColorVtxs, cuGameIconStrokeVtxCount * Shader::cuColorAttrSize);
}
}
GameIcon::~GameIcon()
{
//! remove image so it can not be drawn anymore from this point on
imageData = NULL;
//! main image vertexes
if(posVtxs)
{
free((void*)posVtxs);
posVtxs = NULL;
}
if(texCoords)
{
free((void*)texCoords);
texCoords = NULL;
}
//! mirror image vertexes
if(texCoordsMirror)
{
free(texCoordsMirror);
texCoordsMirror = NULL;
}
//! stroke image vertexes
if(strokePosVtxs)
{
free(strokePosVtxs);
strokePosVtxs = NULL;
}
if(strokeTexCoords)
{
free(strokeTexCoords);
strokeTexCoords = NULL;
}
if(strokeColorVtxs)
{
free(strokeColorVtxs);
strokeColorVtxs = NULL;
}
}
bool GameIcon::checkRayIntersection(const glm::vec3 & rayOrigin, const glm::vec3 & rayDirFrac)
{
//! since we always face the camera we can just check the AABB intersection
//! otherwise an OOB intersection would be required
f32 currPosX = getCenterX() * Application::instance()->getVideo()->getWidthScaleFactor() * 2.0f;
f32 currPosY = getCenterY() * Application::instance()->getVideo()->getHeightScaleFactor() * 2.0f;
f32 currPosZ = getDepth() * Application::instance()->getVideo()->getDepthScaleFactor() * 2.0f;
f32 currScaleX = getScaleX() * (f32)getWidth() * Application::instance()->getVideo()->getWidthScaleFactor();
f32 currScaleY = getScaleY() * (f32)getHeight() * Application::instance()->getVideo()->getHeightScaleFactor();
f32 currScaleZ = getScaleZ() * (f32)getWidth() * Application::instance()->getVideo()->getDepthScaleFactor();
//! lb is the corner of AABB with minimal coordinates - left bottom, rt is maximal corner
glm::vec3 lb(currPosX - currScaleX, currPosY - currScaleY, currPosZ - currScaleZ);
glm::vec3 rt(currPosX + currScaleX, currPosY + currScaleY, currPosZ + currScaleZ);
float t1 = (lb.x - rayOrigin.x) * rayDirFrac.x;
float t2 = (rt.x - rayOrigin.x) * rayDirFrac.x;
float t3 = (lb.y - rayOrigin.y) * rayDirFrac.y;
float t4 = (rt.y - rayOrigin.y) * rayDirFrac.y;
float t5 = (lb.z - rayOrigin.z) * rayDirFrac.z;
float t6 = (rt.z - rayOrigin.z) * rayDirFrac.z;
float tmin = std::max(std::max(std::min(t1, t2), std::min(t3, t4)), std::min(t5, t6));
float tmax = std::min(std::min(std::max(t1, t2), std::max(t3, t4)), std::max(t5, t6));
//! if tmax < 0, ray (line) is intersecting AABB, but whole AABB is behing us
if (tmax < 0)
{
//t = tmax;
return false;
}
//! if tmin > tmax, ray doesn't intersect AABB
if (tmin > tmax)
{
//t = tmax;
return false;
}
//t = tmin;
return true;
}
void GameIcon::draw(CVideo *pVideo, const glm::mat4 & projectionMtx, const glm::mat4 & viewMtx, const glm::mat4 & modelView)
{
//! first setup 2D GUI positions
f32 currPosX = getCenterX() * pVideo->getWidthScaleFactor() * 2.0f;
f32 currPosY = getCenterY() * pVideo->getHeightScaleFactor() * 2.0f;
f32 currPosZ = getDepth() * pVideo->getDepthScaleFactor() * 2.0f;
f32 currScaleX = getScaleX() * (f32)getWidth() * pVideo->getWidthScaleFactor();
f32 currScaleY = getScaleY() * (f32)getHeight() * pVideo->getHeightScaleFactor();
f32 currScaleZ = getScaleZ() * (f32)getWidth() * pVideo->getDepthScaleFactor();
f32 strokeScaleX = pVideo->getWidthScaleFactor() * strokeWidth * 0.25f + cfIconMirrorScale;
f32 strokeScaleY = pVideo->getHeightScaleFactor() * strokeWidth * 0.25f + cfIconMirrorScale;
for(int iDraw = 0; iDraw < 2; iDraw++)
{
glm::vec4 * alphaFadeOut;
glm::mat4 m_iconView;
glm::mat4 m_mirrorView;
glm::mat4 m_strokeView;
if(iDraw == RENDER_REFLECTION)
{
//! Reflection render
if(!bRenderReflection)
continue;
m_iconView = glm::translate(modelView, glm::vec3(currPosX, -currScaleY * 2.0f - currPosY, currPosZ + cosf(DegToRad(rotationX)) * currScaleZ * 2.0f));
m_iconView = glm::rotate(m_iconView, DegToRad(rotationX), glm::vec3(1.0f, 0.0f, 0.0f));
m_iconView = glm::scale(m_iconView, glm::vec3(currScaleX, -currScaleY, currScaleZ));
colorIntensity[3] = reflectionAlpha * getAlpha();
selectionBlurOuterColorIntensity[3] = colorIntensity[3] * 0.7f;
selectionBlurInnerColorIntensity[3] = colorIntensity[3] * 0.7f;
alphaFadeOut = &alphaFadeOutRefl;
GX2SetCullOnlyControl(GX2_FRONT_FACE_CCW, GX2_ENABLE, GX2_DISABLE);
}
else
{
//! Normal render
m_iconView = glm::translate(modelView, glm::vec3(currPosX,currPosY, currPosZ));
m_iconView = glm::rotate(m_iconView, DegToRad(rotationX), glm::vec3(1.0f, 0.0f, 0.0f));
m_iconView = glm::scale(m_iconView, glm::vec3(currScaleX, currScaleY, currScaleZ));
colorIntensity[3] = getAlpha();
selectionBlurOuterColorIntensity[3] = colorIntensity[3];
selectionBlurInnerColorIntensity[3] = colorIntensity[3];
alphaFadeOut = &alphaFadeOutNorm;
}
m_mirrorView = glm::scale(m_iconView, glm::vec3(cfIconMirrorScale, cfIconMirrorScale, cfIconMirrorScale));
colorIntensityMirror[3] = cfIconMirrorAlpha * colorIntensity[3];
if(!bIconLast)
{
Shader3D::instance()->setShaders();
Shader3D::instance()->setProjectionMtx(projectionMtx);
Shader3D::instance()->setViewMtx(viewMtx);
Shader3D::instance()->setTextureAndSampler(imageData->getTexture(), imageData->getSampler());
Shader3D::instance()->setAlphaFadeOut(*alphaFadeOut);
Shader3D::instance()->setDistanceFadeOut(distanceFadeout);
//! render the real symbol
Shader3D::instance()->setModelViewMtx(m_iconView);
Shader3D::instance()->setColorIntensity(colorIntensity);
Shader3D::instance()->setAttributeBuffer(vtxCount, posVtxs, texCoords);
Shader3D::instance()->draw(GX2_PRIMITIVE_MODE_QUADS, vtxCount);
}
if(bSelected)
{
strokeFractalEnable = 0;
GX2SetDepthOnlyControl(GX2_ENABLE, GX2_DISABLE, GX2_COMPARE_FUNC_LEQUAL);
m_strokeView = glm::scale(m_iconView, glm::vec3(selectionBlurOuterSize, selectionBlurOuterSize, 0.0f));
ShaderFractalColor::instance()->setShaders();
ShaderFractalColor::instance()->setProjectionMtx(projectionMtx);
ShaderFractalColor::instance()->setViewMtx(viewMtx);
ShaderFractalColor::instance()->setModelViewMtx(m_strokeView);
ShaderFractalColor::instance()->setFractalColor(strokeFractalEnable);
ShaderFractalColor::instance()->setBlurBorder(selectionBlurOuterBorderSize);
ShaderFractalColor::instance()->setColorIntensity(selectionBlurOuterColorIntensity);
ShaderFractalColor::instance()->setAlphaFadeOut(*alphaFadeOut);
ShaderFractalColor::instance()->setAttributeBuffer();
ShaderFractalColor::instance()->draw();
m_strokeView = glm::scale(m_iconView, glm::vec3(selectionBlurInnerSize, selectionBlurInnerSize, 0.0f));
ShaderFractalColor::instance()->setBlurBorder(selectionBlurInnerBorderSize);
ShaderFractalColor::instance()->setColorIntensity(selectionBlurInnerColorIntensity);
ShaderFractalColor::instance()->draw();
GX2SetDepthOnlyControl(GX2_ENABLE, GX2_ENABLE, GX2_COMPARE_FUNC_LEQUAL);
}
if(iDraw == RENDER_NORMAL && bRenderStroke)
{
strokeFractalEnable = 1;
//! now render the icon stroke
//! make the stroke a little bigger than the mirror, just by the line width on each side
m_strokeView = glm::scale(m_iconView, glm::vec3(strokeScaleX, strokeScaleY, cfIconMirrorScale));
ShaderFractalColor::instance()->setShaders();
ShaderFractalColor::instance()->setLineWidth(strokeWidth);
ShaderFractalColor::instance()->setProjectionMtx(projectionMtx);
ShaderFractalColor::instance()->setViewMtx(viewMtx);
ShaderFractalColor::instance()->setModelViewMtx(m_strokeView);
ShaderFractalColor::instance()->setFractalColor(strokeFractalEnable);
ShaderFractalColor::instance()->setBlurBorder(strokeBlurBorder);
ShaderFractalColor::instance()->setColorIntensity(colorIntensity);
ShaderFractalColor::instance()->setAlphaFadeOut(*alphaFadeOut);
ShaderFractalColor::instance()->setAttributeBuffer(cuGameIconStrokeVtxCount, strokePosVtxs, strokeTexCoords, strokeColorVtxs);
ShaderFractalColor::instance()->draw(GX2_PRIMITIVE_MODE_LINE_STRIP, cuGameIconStrokeVtxCount);
}
//! render the background mirror frame
Shader3D::instance()->setShaders();
Shader3D::instance()->setProjectionMtx(projectionMtx);
Shader3D::instance()->setViewMtx(viewMtx);
Shader3D::instance()->setTextureAndSampler(imageData->getTexture(), imageData->getSampler());
Shader3D::instance()->setAlphaFadeOut(*alphaFadeOut);
Shader3D::instance()->setDistanceFadeOut(distanceFadeout);
Shader3D::instance()->setModelViewMtx(m_mirrorView);
Shader3D::instance()->setColorIntensity(colorIntensityMirror);
Shader3D::instance()->setAttributeBuffer(vtxCount, posVtxs, texCoordsMirror);
Shader3D::instance()->draw(GX2_PRIMITIVE_MODE_QUADS, vtxCount);
if(bIconLast)
{
Shader3D::instance()->setShaders();
Shader3D::instance()->setProjectionMtx(projectionMtx);
Shader3D::instance()->setViewMtx(viewMtx);
Shader3D::instance()->setTextureAndSampler(imageData->getTexture(), imageData->getSampler());
Shader3D::instance()->setAlphaFadeOut(*alphaFadeOut);
Shader3D::instance()->setDistanceFadeOut(distanceFadeout);
//! render the real symbol
Shader3D::instance()->setModelViewMtx(m_iconView);
Shader3D::instance()->setColorIntensity(colorIntensity);
Shader3D::instance()->setAttributeBuffer(vtxCount, posVtxs, texCoords);
Shader3D::instance()->draw(GX2_PRIMITIVE_MODE_QUADS, vtxCount);
}
//! return back normal culling
if(iDraw == RENDER_REFLECTION)
{
GX2SetCullOnlyControl(GX2_FRONT_FACE_CCW, GX2_DISABLE, GX2_ENABLE);
}
}
}

View File

@ -1,85 +0,0 @@
#ifndef _GAME_ICON_H_
#define _GAME_ICON_H_
#include "GuiImageAsync.h"
#include "video/shaders/Shader3D.h"
class GameIcon : public GuiImageAsync
{
public:
GameIcon(const std::string & filename, GuiImageData *preloadImage);
virtual ~GameIcon();
void setRotationX(f32 r) {
rotationX = r;
}
void setColorIntensity(const glm::vec4 & color) {
colorIntensity = color;
colorIntensityMirror = colorIntensity;
selectionBlurOuterColorIntensity = color * glm::vec4(0.09411764f * 1.15f, 0.56862745f * 1.15f, 0.96862745098f * 1.15f, 1.0f);
selectionBlurInnerColorIntensity = color * glm::vec4(0.46666667f, 0.90588235f, 1.0f, 1.0f);
}
const glm::vec4 & getColorIntensity() const {
return colorIntensity;
}
void setAlphaFadeOutNorm(const glm::vec4 & a) {
alphaFadeOutNorm = a;
}
void setAlphaFadeOutRefl(const glm::vec4 & a) {
alphaFadeOutRefl = a;
}
void setRenderReflection(bool enable) {
bRenderReflection = enable;
}
void setSelected(bool enable) {
bSelected = enable;
}
void setStrokeRender(bool enable) {
bRenderStroke = enable;
}
void setRenderIconLast(bool enable) {
bIconLast = enable;
}
void draw(CVideo *pVideo) {
static const glm::mat4 identity(1.0f);
draw(pVideo, identity, identity, identity);
}
void draw(CVideo *pVideo, const glm::mat4 & projection, const glm::mat4 & view, const glm::mat4 & modelView);
bool checkRayIntersection(const glm::vec3 & rayOrigin, const glm::vec3 & rayDirFrac);
private:
enum eRenderState
{
RENDER_REFLECTION,
RENDER_NORMAL
};
bool bSelected;
bool bRenderStroke;
bool bRenderReflection;
bool bIconLast;
glm::vec4 colorIntensity;
glm::vec4 colorIntensityMirror;
glm::vec4 alphaFadeOutNorm;
glm::vec4 alphaFadeOutRefl;
f32 reflectionAlpha;
f32 strokeWidth;
f32 rotationX;
f32 rgbReduction;
f32 distanceFadeout;
f32 *texCoordsMirror;
f32 *strokePosVtxs;
f32 *strokeTexCoords;
u8 *strokeColorVtxs;
int strokeFractalEnable;
f32 strokeBlurBorder;
glm::vec4 selectionBlurOuterColorIntensity;
f32 selectionBlurOuterSize;
f32 selectionBlurOuterBorderSize;
glm::vec4 selectionBlurInnerColorIntensity;
f32 selectionBlurInnerSize;
f32 selectionBlurInnerBorderSize;
};
#endif // _GAME_ICON_H_

View File

@ -1,760 +0,0 @@
#ifndef ICON_MODEL_H_
#define ICON_MODEL_H_
static const float cfGameIconPosVtxs[] = {
-0.844501f,-0.861263f,0.050154f,-0.802664f,-0.8797f,0.054004f,-0.809968f,-0.828995f,0.061777f,-0.864233f,-0.822169f,0.054004f,
-0.802664f,-0.8797f,0.054004f,-0.726455f,-0.89991f,0.058224f,-0.730326f,-0.842312f,0.067487f,-0.809968f,-0.828995f,0.061777f,
-0.809968f,-0.828995f,0.061777f,-0.730326f,-0.842312f,0.067487f,-0.738488f,-0.760488f,0.074426f,-0.824221f,-0.752861f,0.067487f,
-0.864233f,-0.822169f,0.054004f,-0.809968f,-0.828995f,0.061777f,-0.824221f,-0.752861f,0.067487f,-0.885862f,-0.749245f,0.058224f,
-0.726455f,-0.89991f,0.058224f,-0.612405f,-0.916988f,0.061789f,-0.614352f,-0.854962f,0.071886f,-0.730326f,-0.842312f,0.067487f,
-0.612405f,-0.916988f,0.061789f,-0.392243f,-0.928623f,0.064218f,-0.39312f,-0.8642f,0.074693f,-0.614352f,-0.854962f,0.071886f,
-0.614352f,-0.854962f,0.071886f,-0.39312f,-0.8642f,0.074693f,-0.395094f,-0.775509f,0.082561f,-0.618732f,-0.768902f,0.079479f,
-0.730326f,-0.842312f,0.067487f,-0.614352f,-0.854962f,0.071886f,-0.618732f,-0.768902f,0.079479f,-0.738488f,-0.760488f,0.074426f,
-0.738488f,-0.760488f,0.074426f,-0.618732f,-0.768902f,0.079479f,-0.624085f,-0.648442f,0.084918f,-0.747494f,-0.64344f,0.079479f,
-0.618732f,-0.768902f,0.079479f,-0.395094f,-0.775509f,0.082561f,-0.397505f,-0.652534f,0.088189f,-0.624085f,-0.648442f,0.084918f,
-0.624085f,-0.648442f,0.084918f,-0.397505f,-0.652534f,0.088189f,-0.399478f,-0.422739f,0.09157f,-0.628465f,-0.420911f,0.088189f,
-0.747494f,-0.64344f,0.079479f,-0.624085f,-0.648442f,0.084918f,-0.628465f,-0.420911f,0.088189f,-0.754564f,-0.418675f,0.082561f,
-0.885862f,-0.749245f,0.058224f,-0.824221f,-0.752861f,0.067487f,-0.837759f,-0.639347f,0.071886f,-0.90414f,-0.637528f,0.061789f,
-0.824221f,-0.752861f,0.067487f,-0.738488f,-0.760488f,0.074426f,-0.747494f,-0.64344f,0.079479f,-0.837759f,-0.639347f,0.071886f,
-0.837759f,-0.639347f,0.071886f,-0.747494f,-0.64344f,0.079479f,-0.754564f,-0.418675f,0.082561f,-0.847646f,-0.416846f,0.074693f,
-0.90414f,-0.637528f,0.061789f,-0.837759f,-0.639347f,0.071886f,-0.847646f,-0.416846f,0.074693f,-0.916591f,-0.416033f,0.064218f,
-0.399478f,-0.422739f,0.09157f,-0.397505f,-0.652534f,0.088189f,0.002274f,-0.653898f,0.089279f,0.002265f,-0.423349f,0.092698f,
-0.397505f,-0.652534f,0.088189f,-0.395094f,-0.775509f,0.082561f,0.002284f,-0.777711f,0.083588f,0.002274f,-0.653898f,0.089279f,
0.002274f,-0.653898f,0.089279f,0.002284f,-0.777711f,0.083588f,0.399509f,-0.775509f,0.082561f,0.401892f,-0.652534f,0.088189f,
0.002265f,-0.423349f,0.092698f,0.002274f,-0.653898f,0.089279f,0.401892f,-0.652534f,0.088189f,0.403842f,-0.422739f,0.09157f,
-0.395094f,-0.775509f,0.082561f,-0.39312f,-0.8642f,0.074693f,0.002293f,-0.867279f,0.075629f,0.002284f,-0.777711f,0.083588f,
-0.39312f,-0.8642f,0.074693f,-0.392243f,-0.928623f,0.064218f,0.002297f,-0.932501f,0.065028f,0.002293f,-0.867279f,0.075629f,
0.002293f,-0.867279f,0.075629f,0.002297f,-0.932501f,0.065028f,0.396693f,-0.928623f,0.064218f,0.397559f,-0.8642f,0.074693f,
0.002284f,-0.777711f,0.083588f,0.002293f,-0.867279f,0.075629f,0.397559f,-0.8642f,0.074693f,0.399509f,-0.775509f,0.082561f,
-0.399478f,-0.422739f,0.09157f,0.002265f,-0.423349f,0.092698f,0.002263f,-0.013572f,0.093837f,-0.400136f,-0.013589f,0.092698f,
0.002265f,-0.423349f,0.092698f,0.403842f,-0.422739f,0.09157f,0.404492f,-0.013589f,0.092698f,0.002263f,-0.013572f,0.093837f,
0.002263f,-0.013572f,0.093837f,0.404492f,-0.013589f,0.092698f,0.403842f,0.396564f,0.09157f,0.002265f,0.397221f,0.092698f,
-0.400136f,-0.013589f,0.092698f,0.002263f,-0.013572f,0.093837f,0.002265f,0.397221f,0.092698f,-0.399478f,0.396564f,0.09157f,
-0.754564f,0.392188f,0.082561f,-0.847646f,0.390218f,0.074693f,-0.850941f,-0.013754f,0.075629f,-0.756921f,-0.013703f,0.083588f,
-0.847646f,0.390218f,0.074693f,-0.916591f,0.389343f,0.064218f,-0.920742f,-0.013776f,0.065028f,-0.850941f,-0.013754f,0.075629f,
-0.850941f,-0.013754f,0.075629f,-0.920742f,-0.013776f,0.065028f,-0.916591f,-0.416033f,0.064218f,-0.847646f,-0.416846f,0.074693f,
-0.756921f,-0.013703f,0.083588f,-0.850941f,-0.013754f,0.075629f,-0.847646f,-0.416846f,0.074693f,-0.754564f,-0.418675f,0.082561f,
-0.754564f,0.392188f,0.082561f,-0.756921f,-0.013703f,0.083588f,-0.629925f,-0.01364f,0.089279f,-0.628465f,0.394595f,0.088189f,
-0.756921f,-0.013703f,0.083588f,-0.754564f,-0.418675f,0.082561f,-0.628465f,-0.420911f,0.088189f,-0.629925f,-0.01364f,0.089279f,
-0.629925f,-0.01364f,0.089279f,-0.628465f,-0.420911f,0.088189f,-0.399478f,-0.422739f,0.09157f,-0.400136f,-0.013589f,0.092698f,
-0.628465f,0.394595f,0.088189f,-0.629925f,-0.01364f,0.089279f,-0.400136f,-0.013589f,0.092698f,-0.399478f,0.396564f,0.09157f,
-0.844501f,0.846382f,0.050154f,-0.802664f,0.865969f,0.054004f,-0.814648f,0.914535f,0.037876f,-0.871108f,0.872793f,0.036675f,
-0.802664f,0.865969f,0.054004f,-0.726455f,0.887439f,0.058224f,-0.733131f,0.94538f,0.040237f,-0.814648f,0.914535f,0.037876f,
-0.814648f,0.914535f,0.037876f,-0.733131f,0.94538f,0.040237f,-0.74278f,0.982563f,0.019733f,-0.830745f,0.945555f,0.018815f,
-0.871108f,0.872793f,0.036675f,-0.814648f,0.914535f,0.037876f,-0.830745f,0.945555f,0.018815f,-0.894756f,0.896267f,0.018385f,
-0.726455f,0.887439f,0.058224f,-0.612405f,0.905582f,0.061789f,-0.615909f,0.968735f,0.042517f,-0.733131f,0.94538f,0.040237f,
-0.612405f,0.905582f,0.061789f,-0.392243f,0.917941f,0.064218f,-0.393822f,0.983443f,0.044197f,-0.615909f,0.968735f,0.042517f,
-0.615909f,0.968735f,0.042517f,-0.393822f,0.983443f,0.044197f,-0.396235f,1.025424f,0.021594f,-0.621266f,1.009264f,0.020771f,
-0.733131f,0.94538f,0.040237f,-0.615909f,0.968735f,0.042517f,-0.621266f,1.009264f,0.020771f,-0.74278f,0.982563f,0.019733f,
-0.621266f,1.009264f,0.020771f,-0.396235f,1.025424f,0.021594f,-0.398382f,1.047552f,0.0f,-0.626031f,1.030658f,0.0f,
-0.74278f,0.982563f,0.019733f,-0.621266f,1.009264f,0.020771f,-0.626031f,1.030658f,0.0f,-0.750636f,1.002556f,0.0f,
-0.830745f,0.945555f,0.018815f,-0.74278f,0.982563f,0.019733f,-0.750636f,1.002556f,0.0f,-0.842153f,0.963302f,0.0f,
-0.894756f,0.896267f,0.018385f,-0.830745f,0.945555f,0.018815f,-0.842153f,0.963302f,0.0f,-0.909674f,0.911075f,0.0f,
-0.398382f,1.047552f,0.0f,-0.396235f,1.025424f,0.021594f,0.002279f,1.030811f,0.021869f,0.00227f,1.053183f,0.0f,
0.002279f,1.030811f,0.021869f,-0.396235f,1.025424f,0.021594f,-0.393822f,0.983443f,0.044197f,0.00229f,0.988345f,0.044757f,
0.400637f,1.025424f,0.021594f,0.002279f,1.030811f,0.021869f,0.00229f,0.988345f,0.044757f,0.398253f,0.983443f,0.044197f,
0.00227f,1.053183f,0.0f,0.002279f,1.030811f,0.021869f,0.400637f,1.025424f,0.021594f,0.402758f,1.047552f,0.0f,
-0.393822f,0.983443f,0.044197f,-0.392243f,0.917941f,0.064218f,0.002297f,0.922061f,0.065028f,0.00229f,0.988345f,0.044757f,
0.00229f,0.988345f,0.044757f,0.002297f,0.922061f,0.065028f,0.396693f,0.917941f,0.064218f,0.398253f,0.983443f,0.044197f,
0.396693f,-0.928623f,0.064218f,0.002297f,-0.932501f,0.065028f,0.00229f,-0.994896f,0.044757f,0.398253f,-0.990281f,0.044197f,
0.002297f,-0.932501f,0.065028f,-0.392243f,-0.928623f,0.064218f,-0.393822f,-0.990281f,0.044197f,0.00229f,-0.994896f,0.044757f,
0.00229f,-0.994896f,0.044757f,-0.393822f,-0.990281f,0.044197f,-0.396235f,-1.0298f,0.021594f,0.002279f,-1.034871f,0.021869f,
0.398253f,-0.990281f,0.044197f,0.00229f,-0.994896f,0.044757f,0.002279f,-1.034871f,0.021869f,0.400637f,-1.0298f,0.021594f,
-0.396235f,-1.0298f,0.021594f,-0.398382f,-1.050629f,0.0f,0.00227f,-1.05593f,0.0f,0.002279f,-1.034871f,0.021869f,
0.002279f,-1.034871f,0.021869f,0.00227f,-1.05593f,0.0f,0.402758f,-1.050629f,0.0f,0.400637f,-1.0298f,0.021594f,
-0.909674f,-0.922159f,0.0f,-0.842153f,-0.971323f,0.0f,-0.830745f,-0.954616f,0.018815f,-0.894756f,-0.90822f,0.018385f,
-0.842153f,-0.971323f,0.0f,-0.750636f,-1.008273f,0.0f,-0.74278f,-0.989453f,0.019733f,-0.830745f,-0.954616f,0.018815f,
-0.830745f,-0.954616f,0.018815f,-0.74278f,-0.989453f,0.019733f,-0.733131f,-0.954452f,0.040237f,-0.814648f,-0.925416f,0.037876f,
-0.894756f,-0.90822f,0.018385f,-0.830745f,-0.954616f,0.018815f,-0.814648f,-0.925416f,0.037876f,-0.871108f,-0.886124f,0.036675f,
-0.750636f,-1.008273f,0.0f,-0.626031f,-1.034726f,0.0f,-0.621266f,-1.014588f,0.020771f,-0.74278f,-0.989453f,0.019733f,
-0.626031f,-1.034726f,0.0f,-0.398382f,-1.050629f,0.0f,-0.396235f,-1.0298f,0.021594f,-0.621266f,-1.014588f,0.020771f,
-0.621266f,-1.014588f,0.020771f,-0.396235f,-1.0298f,0.021594f,-0.393822f,-0.990281f,0.044197f,-0.615909f,-0.976437f,0.042517f,
-0.74278f,-0.989453f,0.019733f,-0.621266f,-1.014588f,0.020771f,-0.615909f,-0.976437f,0.042517f,-0.733131f,-0.954452f,0.040237f,
-0.615909f,-0.976437f,0.042517f,-0.393822f,-0.990281f,0.044197f,-0.392243f,-0.928623f,0.064218f,-0.612405f,-0.916988f,0.061789f,
-0.733131f,-0.954452f,0.040237f,-0.615909f,-0.976437f,0.042517f,-0.612405f,-0.916988f,0.061789f,-0.726455f,-0.89991f,0.058224f,
-0.814648f,-0.925416f,0.037876f,-0.733131f,-0.954452f,0.040237f,-0.726455f,-0.89991f,0.058224f,-0.802664f,-0.8797f,0.054004f,
-0.871108f,-0.886124f,0.036675f,-0.814648f,-0.925416f,0.037876f,-0.802664f,-0.8797f,0.054004f,-0.844501f,-0.861263f,0.050154f,
0.846982f,-0.861263f,0.050154f,0.87333f,-0.886124f,0.036675f,0.914973f,-0.833367f,0.037876f,0.866523f,-0.822169f,0.054004f,
0.914973f,-0.833367f,0.037876f,0.87333f,-0.886124f,0.036675f,0.896749f,-0.90822f,0.018385f,0.94592f,-0.848408f,0.018815f,
0.945745f,-0.755482f,0.040237f,0.914973f,-0.833367f,0.037876f,0.94592f,-0.848408f,0.018815f,0.982841f,-0.764498f,0.019733f,
0.866523f,-0.822169f,0.054004f,0.914973f,-0.833367f,0.037876f,0.945745f,-0.755482f,0.040237f,0.887941f,-0.749245f,0.058224f,
0.896749f,-0.90822f,0.018385f,0.911522f,-0.922159f,0.0f,0.963626f,-0.859068f,0.0f,0.94592f,-0.848408f,0.018815f,
0.94592f,-0.848408f,0.018815f,0.963626f,-0.859068f,0.0f,1.002787f,-0.771839f,0.0f,0.982841f,-0.764498f,0.019733f,
0.945745f,-0.755482f,0.040237f,0.982841f,-0.764498f,0.019733f,1.009478f,-0.645808f,0.020771f,0.969045f,-0.640802f,0.042517f,
0.982841f,-0.764498f,0.019733f,1.002787f,-0.771839f,0.0f,1.030822f,-0.650261f,0.0f,1.009478f,-0.645808f,0.020771f,
1.009478f,-0.645808f,0.020771f,1.030822f,-0.650261f,0.0f,1.047675f,-0.421723f,0.0f,1.025601f,-0.419734f,0.021594f,
1.009478f,-0.645808f,0.020771f,1.025601f,-0.419734f,0.021594f,0.983719f,-0.417497f,0.044197f,0.969045f,-0.640802f,0.042517f,
0.887941f,-0.749245f,0.058224f,0.945745f,-0.755482f,0.040237f,0.969045f,-0.640802f,0.042517f,0.906041f,-0.637528f,0.061789f,
0.906041f,-0.637528f,0.061789f,0.969045f,-0.640802f,0.042517f,0.983719f,-0.417497f,0.044197f,0.918372f,-0.416033f,0.064218f,
0.918372f,-0.416033f,0.064218f,0.983719f,-0.417497f,0.044197f,0.98861f,-0.013736f,0.044757f,0.922482f,-0.013776f,0.065028f,
0.98861f,-0.013736f,0.044757f,0.983719f,-0.417497f,0.044197f,1.025601f,-0.419734f,0.021594f,1.030975f,-0.013673f,0.021869f,
0.983719f,0.390919f,0.044197f,0.98861f,-0.013736f,0.044757f,1.030975f,-0.013673f,0.021869f,1.025601f,0.393327f,0.021594f,
0.922482f,-0.013776f,0.065028f,0.98861f,-0.013736f,0.044757f,0.983719f,0.390919f,0.044197f,0.918372f,0.389343f,0.064218f,
1.025601f,-0.419734f,0.021594f,1.047675f,-0.421723f,0.0f,1.053293f,-0.013618f,0.0f,1.030975f,-0.013673f,0.021869f,
1.030975f,-0.013673f,0.021869f,1.053293f,-0.013618f,0.0f,1.047675f,0.39547f,0.0f,1.025601f,0.393327f,0.021594f,
-0.909674f,-0.922159f,0.0f,-0.894756f,-0.90822f,0.018385f,-0.944409f,-0.848408f,0.018815f,-0.962289f,-0.859068f,0.0f,
-0.944409f,-0.848408f,0.018815f,-0.894756f,-0.90822f,0.018385f,-0.871108f,-0.886124f,0.036675f,-0.913159f,-0.833367f,0.037876f,
-0.981692f,-0.764498f,0.019733f,-0.944409f,-0.848408f,0.018815f,-0.913159f,-0.833367f,0.037876f,-0.944233f,-0.755482f,0.040237f,
-0.962289f,-0.859068f,0.0f,-0.944409f,-0.848408f,0.018815f,-0.981692f,-0.764498f,0.019733f,-1.001834f,-0.771839f,0.0f,
-0.871108f,-0.886124f,0.036675f,-0.844501f,-0.861263f,0.050154f,-0.864233f,-0.822169f,0.054004f,-0.913159f,-0.833367f,0.037876f,
-0.913159f,-0.833367f,0.037876f,-0.864233f,-0.822169f,0.054004f,-0.885862f,-0.749245f,0.058224f,-0.944233f,-0.755482f,0.040237f,
-0.981692f,-0.764498f,0.019733f,-0.944233f,-0.755482f,0.040237f,-0.967761f,-0.640802f,0.042517f,-1.008591f,-0.645808f,0.020771f,
-0.944233f,-0.755482f,0.040237f,-0.885862f,-0.749245f,0.058224f,-0.90414f,-0.637528f,0.061789f,-0.967761f,-0.640802f,0.042517f,
-0.967761f,-0.640802f,0.042517f,-0.90414f,-0.637528f,0.061789f,-0.916591f,-0.416033f,0.064218f,-0.982578f,-0.417497f,0.044197f,
-0.967761f,-0.640802f,0.042517f,-0.982578f,-0.417497f,0.044197f,-1.024871f,-0.419734f,0.021594f,-1.008591f,-0.645808f,0.020771f,
-1.001834f,-0.771839f,0.0f,-0.981692f,-0.764498f,0.019733f,-1.008591f,-0.645808f,0.020771f,-1.030143f,-0.650261f,0.0f,
-1.030143f,-0.650261f,0.0f,-1.008591f,-0.645808f,0.020771f,-1.024871f,-0.419734f,0.021594f,-1.047163f,-0.421723f,0.0f,
-1.047163f,0.39547f,0.0f,-1.052836f,-0.013618f,0.0f,-1.030298f,-0.013673f,0.021869f,-1.024871f,0.393327f,0.021594f,
-1.052836f,-0.013618f,0.0f,-1.047163f,-0.421723f,0.0f,-1.024871f,-0.419734f,0.021594f,-1.030298f,-0.013673f,0.021869f,
-1.030298f,-0.013673f,0.021869f,-1.024871f,-0.419734f,0.021594f,-0.982578f,-0.417497f,0.044197f,-0.987517f,-0.013736f,0.044757f,
-1.024871f,0.393327f,0.021594f,-1.030298f,-0.013673f,0.021869f,-0.987517f,-0.013736f,0.044757f,-0.982578f,0.390919f,0.044197f,
-0.982578f,-0.417497f,0.044197f,-0.916591f,-0.416033f,0.064218f,-0.920742f,-0.013776f,0.065028f,-0.987517f,-0.013736f,0.044757f,
-0.987517f,-0.013736f,0.044757f,-0.920742f,-0.013776f,0.065028f,-0.916591f,0.389343f,0.064218f,-0.982578f,0.390919f,0.044197f,
0.396693f,0.917941f,0.064218f,0.616423f,0.905582f,0.061789f,0.619893f,0.968735f,0.042517f,0.398253f,0.983443f,0.044197f,
0.616423f,0.905582f,0.061789f,0.729904f,0.887439f,0.058224f,0.736514f,0.94538f,0.040237f,0.619893f,0.968735f,0.042517f,
0.619893f,0.968735f,0.042517f,0.736514f,0.94538f,0.040237f,0.746069f,0.982563f,0.019733f,0.625198f,1.009264f,0.020771f,
0.400637f,1.025424f,0.021594f,0.398253f,0.983443f,0.044197f,0.619893f,0.968735f,0.042517f,0.625198f,1.009264f,0.020771f,
0.729904f,0.887439f,0.058224f,0.805551f,0.865969f,0.054004f,0.817418f,0.914535f,0.037876f,0.736514f,0.94538f,0.040237f,
0.805551f,0.865969f,0.054004f,0.846982f,0.846382f,0.050154f,0.87333f,0.872793f,0.036675f,0.817418f,0.914535f,0.037876f,
0.817418f,0.914535f,0.037876f,0.87333f,0.872793f,0.036675f,0.896749f,0.896267f,0.018385f,0.833359f,0.945555f,0.018815f,
0.736514f,0.94538f,0.040237f,0.817418f,0.914535f,0.037876f,0.833359f,0.945555f,0.018815f,0.746069f,0.982563f,0.019733f,
0.833359f,0.945555f,0.018815f,0.896749f,0.896267f,0.018385f,0.911522f,0.911075f,0.0f,0.844656f,0.963302f,0.0f,
0.746069f,0.982563f,0.019733f,0.833359f,0.945555f,0.018815f,0.844656f,0.963302f,0.0f,0.753849f,1.002556f,0.0f,
0.625198f,1.009264f,0.020771f,0.746069f,0.982563f,0.019733f,0.753849f,1.002556f,0.0f,0.629917f,1.030658f,0.0f,
0.400637f,1.025424f,0.021594f,0.625198f,1.009264f,0.020771f,0.629917f,1.030658f,0.0f,0.402758f,1.047552f,0.0f,
0.396693f,-0.928623f,0.064218f,0.398253f,-0.990281f,0.044197f,0.619893f,-0.976437f,0.042517f,0.616423f,-0.916988f,0.061789f,
0.619893f,-0.976437f,0.042517f,0.398253f,-0.990281f,0.044197f,0.400637f,-1.0298f,0.021594f,0.625198f,-1.014588f,0.020771f,
0.736514f,-0.954452f,0.040237f,0.619893f,-0.976437f,0.042517f,0.625198f,-1.014588f,0.020771f,0.746069f,-0.989453f,0.019733f,
0.616423f,-0.916988f,0.061789f,0.619893f,-0.976437f,0.042517f,0.736514f,-0.954452f,0.040237f,0.729904f,-0.89991f,0.058224f,
0.400637f,-1.0298f,0.021594f,0.402758f,-1.050629f,0.0f,0.629917f,-1.034726f,0.0f,0.625198f,-1.014588f,0.020771f,
0.625198f,-1.014588f,0.020771f,0.629917f,-1.034726f,0.0f,0.753849f,-1.008273f,0.0f,0.746069f,-0.989453f,0.019733f,
0.736514f,-0.954452f,0.040237f,0.746069f,-0.989453f,0.019733f,0.833359f,-0.954616f,0.018815f,0.817418f,-0.925416f,0.037876f,
0.746069f,-0.989453f,0.019733f,0.753849f,-1.008273f,0.0f,0.844656f,-0.971323f,0.0f,0.833359f,-0.954616f,0.018815f,
0.833359f,-0.954616f,0.018815f,0.844656f,-0.971323f,0.0f,0.911522f,-0.922159f,0.0f,0.896749f,-0.90822f,0.018385f,
0.833359f,-0.954616f,0.018815f,0.896749f,-0.90822f,0.018385f,0.87333f,-0.886124f,0.036675f,0.817418f,-0.925416f,0.037876f,
0.729904f,-0.89991f,0.058224f,0.736514f,-0.954452f,0.040237f,0.817418f,-0.925416f,0.037876f,0.805551f,-0.8797f,0.054004f,
0.805551f,-0.8797f,0.054004f,0.817418f,-0.925416f,0.037876f,0.87333f,-0.886124f,0.036675f,0.846982f,-0.861263f,0.050154f,
0.403842f,-0.422739f,0.09157f,0.401892f,-0.652534f,0.088189f,0.62799f,-0.648441f,0.084918f,0.632327f,-0.420911f,0.088189f,
0.401892f,-0.652534f,0.088189f,0.399509f,-0.775509f,0.082561f,0.622688f,-0.768902f,0.079479f,0.62799f,-0.648441f,0.084918f,
0.62799f,-0.648441f,0.084918f,0.622688f,-0.768902f,0.079479f,0.741819f,-0.760488f,0.074426f,0.750737f,-0.64344f,0.079479f,
0.632327f,-0.420911f,0.088189f,0.62799f,-0.648441f,0.084918f,0.750737f,-0.64344f,0.079479f,0.757739f,-0.418675f,0.082561f,
0.399509f,-0.775509f,0.082561f,0.397559f,-0.8642f,0.074693f,0.618351f,-0.854962f,0.071886f,0.622688f,-0.768902f,0.079479f,
0.397559f,-0.8642f,0.074693f,0.396693f,-0.928623f,0.064218f,0.616423f,-0.916988f,0.061789f,0.618351f,-0.854962f,0.071886f,
0.618351f,-0.854962f,0.071886f,0.616423f,-0.916988f,0.061789f,0.729904f,-0.89991f,0.058224f,0.733736f,-0.842312f,0.067487f,
0.622688f,-0.768902f,0.079479f,0.618351f,-0.854962f,0.071886f,0.733736f,-0.842312f,0.067487f,0.741819f,-0.760488f,0.074426f,
0.741819f,-0.760488f,0.074426f,0.733736f,-0.842312f,0.067487f,0.812784f,-0.828995f,0.061777f,0.826898f,-0.752861f,0.067487f,
0.733736f,-0.842312f,0.067487f,0.729904f,-0.89991f,0.058224f,0.805551f,-0.8797f,0.054004f,0.812784f,-0.828995f,0.061777f,
0.812784f,-0.828995f,0.061777f,0.805551f,-0.8797f,0.054004f,0.846982f,-0.861263f,0.050154f,0.866523f,-0.822169f,0.054004f,
0.826898f,-0.752861f,0.067487f,0.812784f,-0.828995f,0.061777f,0.866523f,-0.822169f,0.054004f,0.887941f,-0.749245f,0.058224f,
0.757739f,-0.418675f,0.082561f,0.750737f,-0.64344f,0.079479f,0.840305f,-0.639347f,0.071886f,0.850096f,-0.416846f,0.074693f,
0.750737f,-0.64344f,0.079479f,0.741819f,-0.760488f,0.074426f,0.826898f,-0.752861f,0.067487f,0.840305f,-0.639347f,0.071886f,
0.840305f,-0.639347f,0.071886f,0.826898f,-0.752861f,0.067487f,0.887941f,-0.749245f,0.058224f,0.906041f,-0.637528f,0.061789f,
0.850096f,-0.416846f,0.074693f,0.840305f,-0.639347f,0.071886f,0.906041f,-0.637528f,0.061789f,0.918372f,-0.416033f,0.064218f,
0.403842f,0.396564f,0.09157f,0.404492f,-0.013589f,0.092698f,0.633773f,-0.01364f,0.08928f,0.632327f,0.394595f,0.088189f,
0.404492f,-0.013589f,0.092698f,0.403842f,-0.422739f,0.09157f,0.632327f,-0.420911f,0.088189f,0.633773f,-0.01364f,0.08928f,
0.633773f,-0.01364f,0.08928f,0.632327f,-0.420911f,0.088189f,0.757739f,-0.418675f,0.082561f,0.760073f,-0.013703f,0.083588f,
0.632327f,0.394595f,0.088189f,0.633773f,-0.01364f,0.08928f,0.760073f,-0.013703f,0.083588f,0.757739f,0.392188f,0.082561f,
0.757739f,-0.418675f,0.082561f,0.850096f,-0.416846f,0.074693f,0.853359f,-0.013754f,0.075629f,0.760073f,-0.013703f,0.083588f,
0.850096f,-0.416846f,0.074693f,0.918372f,-0.416033f,0.064218f,0.922482f,-0.013776f,0.065028f,0.853359f,-0.013754f,0.075629f,
0.853359f,-0.013754f,0.075629f,0.922482f,-0.013776f,0.065028f,0.918372f,0.389343f,0.064218f,0.850096f,0.390218f,0.074693f,
0.760073f,-0.013703f,0.083588f,0.853359f,-0.013754f,0.075629f,0.850096f,0.390218f,0.074693f,0.757739f,0.392188f,0.082561f,
-1.047163f,0.39547f,0.0f,-1.024871f,0.393327f,0.021594f,-1.008591f,0.622221f,0.020771f,-1.030143f,0.626951f,0.0f,
-1.008591f,0.622221f,0.020771f,-1.024871f,0.393327f,0.021594f,-0.982578f,0.390919f,0.044197f,-0.967761f,0.616903f,0.042517f,
-0.981692f,0.744767f,0.019733f,-1.008591f,0.622221f,0.020771f,-0.967761f,0.616903f,0.042517f,-0.944233f,0.735189f,0.040237f,
-1.030143f,0.626951f,0.0f,-1.008591f,0.622221f,0.020771f,-0.981692f,0.744767f,0.019733f,-1.001834f,0.752565f,0.0f,
-0.982578f,0.390919f,0.044197f,-0.916591f,0.389343f,0.064218f,-0.90414f,0.613425f,0.061789f,-0.967761f,0.616903f,0.042517f,
-0.967761f,0.616903f,0.042517f,-0.90414f,0.613425f,0.061789f,-0.885862f,0.728563f,0.058224f,-0.944233f,0.735189f,0.040237f,
-0.981692f,0.744767f,0.019733f,-0.944233f,0.735189f,0.040237f,-0.913159f,0.816749f,0.037876f,-0.944409f,0.832727f,0.018815f,
-0.944233f,0.735189f,0.040237f,-0.885862f,0.728563f,0.058224f,-0.864233f,0.804853f,0.054004f,-0.913159f,0.816749f,0.037876f,
-0.913159f,0.816749f,0.037876f,-0.864233f,0.804853f,0.054004f,-0.844501f,0.846382f,0.050154f,-0.871108f,0.872793f,0.036675f,
-0.913159f,0.816749f,0.037876f,-0.871108f,0.872793f,0.036675f,-0.894756f,0.896267f,0.018385f,-0.944409f,0.832727f,0.018815f,
-1.001834f,0.752565f,0.0f,-0.981692f,0.744767f,0.019733f,-0.944409f,0.832727f,0.018815f,-0.962289f,0.844051f,0.0f,
-0.962289f,0.844051f,0.0f,-0.944409f,0.832727f,0.018815f,-0.894756f,0.896267f,0.018385f,-0.909674f,0.911075f,0.0f,
0.918372f,0.389343f,0.064218f,0.983719f,0.390919f,0.044197f,0.969045f,0.616903f,0.042517f,0.906041f,0.613425f,0.061789f,
0.969045f,0.616903f,0.042517f,0.983719f,0.390919f,0.044197f,1.025601f,0.393327f,0.021594f,1.009478f,0.622221f,0.020771f,
0.945745f,0.735189f,0.040237f,0.969045f,0.616903f,0.042517f,1.009478f,0.622221f,0.020771f,0.982841f,0.744767f,0.019733f,
0.906041f,0.613425f,0.061789f,0.969045f,0.616903f,0.042517f,0.945745f,0.735189f,0.040237f,0.887941f,0.728563f,0.058224f,
1.025601f,0.393327f,0.021594f,1.047675f,0.39547f,0.0f,1.030822f,0.626951f,0.0f,1.009478f,0.622221f,0.020771f,
1.009478f,0.622221f,0.020771f,1.030822f,0.626951f,0.0f,1.002787f,0.752565f,0.0f,0.982841f,0.744767f,0.019733f,
0.945745f,0.735189f,0.040237f,0.982841f,0.744767f,0.019733f,0.94592f,0.832727f,0.018815f,0.914973f,0.816749f,0.037876f,
0.982841f,0.744767f,0.019733f,1.002787f,0.752565f,0.0f,0.963626f,0.844051f,0.0f,0.94592f,0.832727f,0.018815f,
0.94592f,0.832727f,0.018815f,0.963626f,0.844051f,0.0f,0.911522f,0.911075f,0.0f,0.896749f,0.896267f,0.018385f,
0.94592f,0.832727f,0.018815f,0.896749f,0.896267f,0.018385f,0.87333f,0.872793f,0.036675f,0.914973f,0.816749f,0.037876f,
0.887941f,0.728563f,0.058224f,0.945745f,0.735189f,0.040237f,0.914973f,0.816749f,0.037876f,0.866523f,0.804853f,0.054004f,
0.866523f,0.804853f,0.054004f,0.914973f,0.816749f,0.037876f,0.87333f,0.872793f,0.036675f,0.846982f,0.846382f,0.050154f,
0.396693f,0.917941f,0.064218f,0.397559f,0.849503f,0.074693f,0.618351f,0.83969f,0.071886f,0.616423f,0.905582f,0.061789f,
0.397559f,0.849503f,0.074693f,0.399509f,0.756465f,0.082561f,0.622688f,0.749446f,0.079479f,0.618351f,0.83969f,0.071886f,
0.618351f,0.83969f,0.071886f,0.622688f,0.749446f,0.079479f,0.741819f,0.740507f,0.074426f,0.733736f,0.826251f,0.067487f,
0.616423f,0.905582f,0.061789f,0.618351f,0.83969f,0.071886f,0.733736f,0.826251f,0.067487f,0.729904f,0.887439f,0.058224f,
0.399509f,0.756465f,0.082561f,0.401892f,0.629367f,0.088189f,0.62799f,0.625019f,0.084918f,0.622688f,0.749446f,0.079479f,
0.401892f,0.629367f,0.088189f,0.403842f,0.396564f,0.09157f,0.632327f,0.394595f,0.088189f,0.62799f,0.625019f,0.084918f,
0.62799f,0.625019f,0.084918f,0.632327f,0.394595f,0.088189f,0.757739f,0.392188f,0.082561f,0.750737f,0.619705f,0.079479f,
0.622688f,0.749446f,0.079479f,0.62799f,0.625019f,0.084918f,0.750737f,0.619705f,0.079479f,0.741819f,0.740507f,0.074426f,
0.741819f,0.740507f,0.074426f,0.750737f,0.619705f,0.079479f,0.840305f,0.615357f,0.071886f,0.826898f,0.732405f,0.067487f,
0.750737f,0.619705f,0.079479f,0.757739f,0.392188f,0.082561f,0.850096f,0.390218f,0.074693f,0.840305f,0.615357f,0.071886f,
0.840305f,0.615357f,0.071886f,0.850096f,0.390218f,0.074693f,0.918372f,0.389343f,0.064218f,0.906041f,0.613425f,0.061789f,
0.826898f,0.732405f,0.067487f,0.840305f,0.615357f,0.071886f,0.906041f,0.613425f,0.061789f,0.887941f,0.728563f,0.058224f,
0.729904f,0.887439f,0.058224f,0.733736f,0.826251f,0.067487f,0.812784f,0.812104f,0.061777f,0.805551f,0.865969f,0.054004f,
0.733736f,0.826251f,0.067487f,0.741819f,0.740507f,0.074426f,0.826898f,0.732405f,0.067487f,0.812784f,0.812104f,0.061777f,
0.812784f,0.812104f,0.061777f,0.826898f,0.732405f,0.067487f,0.887941f,0.728563f,0.058224f,0.866523f,0.804853f,0.054004f,
0.805551f,0.865969f,0.054004f,0.812784f,0.812104f,0.061777f,0.866523f,0.804853f,0.054004f,0.846982f,0.846382f,0.050154f,
0.399509f,0.756465f,0.082561f,0.397559f,0.849503f,0.074693f,0.002293f,0.852774f,0.075629f,0.002284f,0.758804f,0.083588f,
0.397559f,0.849503f,0.074693f,0.396693f,0.917941f,0.064218f,0.002297f,0.922061f,0.065028f,0.002293f,0.852774f,0.075629f,
0.002293f,0.852774f,0.075629f,0.002297f,0.922061f,0.065028f,-0.392243f,0.917941f,0.064218f,-0.39312f,0.849503f,0.074693f,
0.002284f,0.758804f,0.083588f,0.002293f,0.852774f,0.075629f,-0.39312f,0.849503f,0.074693f,-0.395094f,0.756465f,0.082561f,
0.399509f,0.756465f,0.082561f,0.002284f,0.758804f,0.083588f,0.002274f,0.630816f,0.089279f,0.401892f,0.629367f,0.088189f,
0.002284f,0.758804f,0.083588f,-0.395094f,0.756465f,0.082561f,-0.397505f,0.629367f,0.088189f,0.002274f,0.630816f,0.089279f,
0.002274f,0.630816f,0.089279f,-0.397505f,0.629367f,0.088189f,-0.399478f,0.396564f,0.09157f,0.002265f,0.397221f,0.092698f,
0.401892f,0.629367f,0.088189f,0.002274f,0.630816f,0.089279f,0.002265f,0.397221f,0.092698f,0.403842f,0.396564f,0.09157f,
-0.916591f,0.389343f,0.064218f,-0.847646f,0.390218f,0.074693f,-0.837759f,0.615357f,0.071886f,-0.90414f,0.613425f,0.061789f,
-0.847646f,0.390218f,0.074693f,-0.754564f,0.392188f,0.082561f,-0.747494f,0.619705f,0.079479f,-0.837759f,0.615357f,0.071886f,
-0.837759f,0.615357f,0.071886f,-0.747494f,0.619705f,0.079479f,-0.738488f,0.740507f,0.074426f,-0.824221f,0.732405f,0.067487f,
-0.90414f,0.613425f,0.061789f,-0.837759f,0.615357f,0.071886f,-0.824221f,0.732405f,0.067487f,-0.885862f,0.728563f,0.058224f,
-0.754564f,0.392188f,0.082561f,-0.628465f,0.394595f,0.088189f,-0.624085f,0.625019f,0.084918f,-0.747494f,0.619705f,0.079479f,
-0.628465f,0.394595f,0.088189f,-0.399478f,0.396564f,0.09157f,-0.397505f,0.629367f,0.088189f,-0.624085f,0.625019f,0.084918f,
-0.624085f,0.625019f,0.084918f,-0.397505f,0.629367f,0.088189f,-0.395094f,0.756465f,0.082561f,-0.618732f,0.749446f,0.079479f,
-0.747494f,0.619705f,0.079479f,-0.624085f,0.625019f,0.084918f,-0.618732f,0.749446f,0.079479f,-0.738488f,0.740507f,0.074426f,
-0.738488f,0.740507f,0.074426f,-0.618732f,0.749446f,0.079479f,-0.614352f,0.83969f,0.071886f,-0.730326f,0.826251f,0.067487f,
-0.618732f,0.749446f,0.079479f,-0.395094f,0.756465f,0.082561f,-0.39312f,0.849503f,0.074693f,-0.614352f,0.83969f,0.071886f,
-0.614352f,0.83969f,0.071886f,-0.39312f,0.849503f,0.074693f,-0.392243f,0.917941f,0.064218f,-0.612405f,0.905582f,0.061789f,
-0.730326f,0.826251f,0.067487f,-0.614352f,0.83969f,0.071886f,-0.612405f,0.905582f,0.061789f,-0.726455f,0.887439f,0.058224f,
-0.885862f,0.728563f,0.058224f,-0.824221f,0.732405f,0.067487f,-0.809968f,0.812104f,0.061777f,-0.864233f,0.804853f,0.054004f,
-0.824221f,0.732405f,0.067487f,-0.738488f,0.740507f,0.074426f,-0.730326f,0.826251f,0.067487f,-0.809968f,0.812104f,0.061777f,
-0.809968f,0.812104f,0.061777f,-0.730326f,0.826251f,0.067487f,-0.726455f,0.887439f,0.058224f,-0.802664f,0.865969f,0.054004f,
-0.864233f,0.804853f,0.054004f,-0.809968f,0.812104f,0.061777f,-0.802664f,0.865969f,0.054004f,-0.844501f,0.846382f,0.050154f,
};
static const float cfGameIconTexCoords[] = {
0.098918f,0.907702f,0.118783f,0.916444f,0.115314f,0.892403f,0.089549f,0.889167f,
0.118783f,0.916444f,0.154967f,0.926026f,0.153129f,0.898717f,0.115314f,0.892403f,
0.115314f,0.892403f,0.153129f,0.898717f,0.149254f,0.859921f,0.108547f,0.856305f,
0.089549f,0.889167f,0.115314f,0.892403f,0.108547f,0.856305f,0.07928f,0.854591f,
0.154967f,0.926026f,0.209119f,0.934124f,0.208194f,0.904715f,0.153129f,0.898717f,
0.209119f,0.934124f,0.313652f,0.93964f,0.313236f,0.909095f,0.208194f,0.904715f,
0.208194f,0.904715f,0.313236f,0.909095f,0.312299f,0.867044f,0.206115f,0.863911f,
0.153129f,0.898717f,0.208194f,0.904715f,0.206115f,0.863911f,0.149254f,0.859921f,
0.149254f,0.859921f,0.206115f,0.863911f,0.203573f,0.806797f,0.144978f,0.804425f,
0.206115f,0.863911f,0.312299f,0.867044f,0.311154f,0.808737f,0.203573f,0.806797f,
0.203573f,0.806797f,0.311154f,0.808737f,0.310217f,0.699784f,0.201493f,0.698917f,
0.144978f,0.804425f,0.203573f,0.806797f,0.201493f,0.698917f,0.141621f,0.697857f,
0.07928f,0.854591f,0.108547f,0.856305f,0.102119f,0.802484f,0.070602f,0.801622f,
0.108547f,0.856305f,0.149254f,0.859921f,0.144978f,0.804425f,0.102119f,0.802484f,
0.102119f,0.802484f,0.144978f,0.804425f,0.141621f,0.697857f,0.097425f,0.69699f,
0.070602f,0.801622f,0.102119f,0.802484f,0.097425f,0.69699f,0.064689f,0.696604f,
0.310217f,0.699784f,0.311154f,0.808737f,0.500971f,0.809384f,0.500967f,0.700073f,
0.311154f,0.808737f,0.312299f,0.867044f,0.500976f,0.868088f,0.500971f,0.809384f,
0.500971f,0.809384f,0.500976f,0.868088f,0.68958f,0.867044f,0.690711f,0.808737f,
0.500967f,0.700073f,0.500971f,0.809384f,0.690711f,0.808737f,0.691637f,0.699784f,
0.312299f,0.867044f,0.313236f,0.909095f,0.50098f,0.910555f,0.500976f,0.868088f,
0.313236f,0.909095f,0.313652f,0.93964f,0.500982f,0.941479f,0.50098f,0.910555f,
0.50098f,0.910555f,0.500982f,0.941479f,0.688243f,0.93964f,0.688654f,0.909095f,
0.500976f,0.868088f,0.50098f,0.910555f,0.688654f,0.909095f,0.68958f,0.867044f,
0.310217f,0.699784f,0.500967f,0.700073f,0.500965f,0.505784f,0.309905f,0.505792f,
0.500967f,0.700073f,0.691637f,0.699784f,0.691946f,0.505792f,0.500965f,0.505784f,
0.500965f,0.505784f,0.691946f,0.505792f,0.691637f,0.311325f,0.500967f,0.311013f,
0.309905f,0.505792f,0.500965f,0.505784f,0.500967f,0.311013f,0.310217f,0.311325f,
0.141621f,0.3134f,0.097425f,0.314333f,0.09586f,0.50587f,0.140502f,0.505846f,
0.097425f,0.314333f,0.064689f,0.314748f,0.062719f,0.505881f,0.09586f,0.50587f,
0.09586f,0.50587f,0.062719f,0.505881f,0.064689f,0.696604f,0.097425f,0.69699f,
0.140502f,0.505846f,0.09586f,0.50587f,0.097425f,0.69699f,0.141621f,0.697857f,
0.141621f,0.3134f,0.140502f,0.505846f,0.2008f,0.505816f,0.201493f,0.312259f,
0.140502f,0.505846f,0.141621f,0.697857f,0.201493f,0.698917f,0.2008f,0.505816f,
0.2008f,0.505816f,0.201493f,0.698917f,0.310217f,0.699784f,0.309905f,0.505792f,
0.201493f,0.312259f,0.2008f,0.505816f,0.309905f,0.505792f,0.310217f,0.311325f,
0.098918f,0.098051f,0.118783f,0.088764f,0.115314f,0.070013f,0.089549f,0.088764f,
0.118783f,0.088764f,0.154967f,0.078585f,0.153129f,0.056238f,0.115314f,0.070013f,
0.115314f,0.070013f,0.153129f,0.056238f,0.14647f,0.030613f,0.104205f,0.048635f,
0.089549f,0.088764f,0.115314f,0.070013f,0.104205f,0.048635f,0.073229f,0.072587f,
0.154967f,0.078585f,0.209119f,0.069983f,0.208194f,0.045626f,0.153129f,0.056238f,
0.209119f,0.069983f,0.313652f,0.064123f,0.313236f,0.038853f,0.208194f,0.045626f,
0.208194f,0.045626f,0.313236f,0.038853f,0.31157f,0.009921f,0.204497f,0.017695f,
0.153129f,0.056238f,0.208194f,0.045626f,0.204497f,0.017695f,0.14647f,0.030613f,
0.204497f,0.017695f,0.31157f,0.009921f,0.269666f,0.0f,0.202648f,0.01068f,
0.14647f,0.030613f,0.204497f,0.017695f,0.202648f,0.01068f,0.135631f,0.02136f,
0.104205f,0.048635f,0.14647f,0.030613f,0.135631f,0.02136f,0.100033f,0.042615f,
0.073229f,0.072587f,0.104205f,0.048635f,0.100033f,0.042615f,0.064435f,0.06387f,
0.269666f,0.0f,0.31157f,0.009921f,0.500973f,0.007329f,0.500969f,0.0f,
0.500973f,0.007329f,0.31157f,0.009921f,0.313236f,0.038853f,0.50098f,0.036595f,
0.6903f,0.009921f,0.500973f,0.007329f,0.50098f,0.036595f,0.688654f,0.038853f,
0.500969f,0.0f,0.500973f,0.007329f,0.6903f,0.009921f,0.732272f,0.0f,
0.313236f,0.038853f,0.313652f,0.064123f,0.500982f,0.062169f,0.50098f,0.036595f,
0.50098f,0.036595f,0.500982f,0.062169f,0.688243f,0.064123f,0.688654f,0.038853f,
0.688243f,0.93964f,0.500982f,0.941479f,0.50098f,0.965553f,0.688654f,0.963427f,
0.500982f,0.941479f,0.313652f,0.93964f,0.313236f,0.963427f,0.50098f,0.965553f,
0.50098f,0.965553f,0.313236f,0.963427f,0.31157f,0.990661f,0.500973f,0.993101f,
0.688654f,0.963427f,0.50098f,0.965553f,0.500973f,0.993101f,0.6903f,0.990661f,
0.31157f,0.990661f,0.269666f,1.0f,0.500969f,1.0f,0.500973f,0.993101f,
0.500973f,0.993101f,0.500969f,1.0f,0.732272f,1.0f,0.6903f,0.990661f,
0.064435f,0.939877f,0.100033f,0.959885f,0.104205f,0.954218f,0.073229f,0.931672f,
0.100033f,0.959885f,0.135631f,0.979893f,0.14647f,0.971183f,0.104205f,0.954218f,
0.104205f,0.954218f,0.14647f,0.971183f,0.153129f,0.947062f,0.115314f,0.934095f,
0.073229f,0.931672f,0.104205f,0.954218f,0.115314f,0.934095f,0.089549f,0.916444f,
0.135631f,0.979893f,0.202648f,0.989946f,0.204497f,0.983343f,0.14647f,0.971183f,
0.202648f,0.989946f,0.269666f,1.0f,0.31157f,0.990661f,0.204497f,0.983343f,
0.204497f,0.983343f,0.31157f,0.990661f,0.313236f,0.963427f,0.208194f,0.957052f,
0.14647f,0.971183f,0.204497f,0.983343f,0.208194f,0.957052f,0.153129f,0.947062f,
0.208194f,0.957052f,0.313236f,0.963427f,0.313652f,0.93964f,0.209119f,0.934124f,
0.153129f,0.947062f,0.208194f,0.957052f,0.209119f,0.934124f,0.154967f,0.926026f,
0.115314f,0.934095f,0.153129f,0.947062f,0.154967f,0.926026f,0.118783f,0.916444f,
0.089549f,0.916444f,0.115314f,0.934095f,0.118783f,0.916444f,0.098918f,0.907702f,
0.902043f,0.907702f,0.91132f,0.916444f,0.930054f,0.892403f,0.91132f,0.889167f,
0.930054f,0.892403f,0.91132f,0.916444f,0.927482f,0.931672f,0.951411f,0.902768f,
0.943816f,0.856305f,0.930054f,0.892403f,0.951411f,0.902768f,0.969416f,0.862518f,
0.91132f,0.889167f,0.930054f,0.892403f,0.943816f,0.856305f,0.92149f,0.854591f,
0.927482f,0.931672f,0.93619f,0.939877f,0.957425f,0.906662f,0.951411f,0.902768f,
0.951411f,0.902768f,0.957425f,0.906662f,0.97866f,0.873446f,0.969416f,0.862518f,
0.943816f,0.856305f,0.969416f,0.862518f,0.982322f,0.805934f,0.954418f,0.802484f,
0.969416f,0.862518f,0.97866f,0.873446f,0.98933f,0.807659f,0.982322f,0.805934f,
0.982322f,0.805934f,0.98933f,0.807659f,1.0f,0.741872f,0.990089f,0.698531f,
0.982322f,0.805934f,0.990089f,0.698531f,0.961185f,0.69699f,0.954418f,0.802484f,
0.92149f,0.854591f,0.943816f,0.856305f,0.954418f,0.802484f,0.930084f,0.801622f,
0.930084f,0.801622f,0.954418f,0.802484f,0.961185f,0.69699f,0.935938f,0.696604f,
0.935938f,0.696604f,0.961185f,0.69699f,0.96344f,0.50587f,0.93789f,0.505881f,
0.96344f,0.50587f,0.961185f,0.69699f,0.990089f,0.698531f,0.992677f,0.505827f,
0.961185f,0.314333f,0.96344f,0.50587f,0.992677f,0.505827f,0.990089f,0.312674f,
0.93789f,0.505881f,0.96344f,0.50587f,0.961185f,0.314333f,0.935938f,0.314748f,
0.990089f,0.698531f,1.0f,0.741872f,1.0f,0.505805f,0.992677f,0.505827f,
0.992677f,0.505827f,1.0f,0.505805f,1.0f,0.269739f,0.990089f,0.312674f,
0.064435f,0.939877f,0.073229f,0.931672f,0.049066f,0.902768f,0.042992f,0.906662f,
0.049066f,0.902768f,0.073229f,0.931672f,0.089549f,0.916444f,0.070633f,0.892403f,
0.030884f,0.862518f,0.049066f,0.902768f,0.070633f,0.892403f,0.056735f,0.856305f,
0.042992f,0.906662f,0.049066f,0.902768f,0.030884f,0.862518f,0.021549f,0.873446f,
0.089549f,0.916444f,0.098918f,0.907702f,0.089549f,0.889167f,0.070633f,0.892403f,
0.070633f,0.892403f,0.089549f,0.889167f,0.07928f,0.854591f,0.056735f,0.856305f,
0.030884f,0.862518f,0.056735f,0.856305f,0.046029f,0.802484f,0.017852f,0.805934f,
0.056735f,0.856305f,0.07928f,0.854591f,0.070602f,0.801622f,0.046029f,0.802484f,
0.046029f,0.802484f,0.070602f,0.801622f,0.064689f,0.696604f,0.039196f,0.69699f,
0.046029f,0.802484f,0.039196f,0.69699f,0.010008f,0.698531f,0.017852f,0.805934f,
0.021549f,0.873446f,0.030884f,0.862518f,0.017852f,0.805934f,0.010774f,0.807659f,
0.010774f,0.807659f,0.017852f,0.805934f,0.010008f,0.698531f,0.0f,0.741872f,
0.0f,0.269739f,0.0f,0.505805f,0.007394f,0.505827f,0.010008f,0.312673f,
0.0f,0.505805f,0.0f,0.741872f,0.010008f,0.698531f,0.007394f,0.505827f,
0.007394f,0.505827f,0.010008f,0.698531f,0.039196f,0.69699f,0.036918f,0.50587f,
0.010008f,0.312673f,0.007394f,0.505827f,0.036918f,0.50587f,0.039196f,0.314333f,
0.039196f,0.69699f,0.064689f,0.696604f,0.062719f,0.505881f,0.036918f,0.50587f,
0.036918f,0.50587f,0.062719f,0.505881f,0.064689f,0.314748f,0.039196f,0.314333f,
0.688243f,0.064123f,0.792572f,0.069983f,0.793487f,0.045626f,0.688654f,0.038853f,
0.792572f,0.069983f,0.846453f,0.078585f,0.848273f,0.056238f,0.793487f,0.045626f,
0.793487f,0.045626f,0.848273f,0.056238f,0.854867f,0.030613f,0.797148f,0.017695f,
0.6903f,0.009921f,0.688654f,0.038853f,0.793487f,0.045626f,0.797148f,0.017695f,
0.846453f,0.078585f,0.882371f,0.088764f,0.885805f,0.070013f,0.848273f,0.056238f,
0.882371f,0.088764f,0.902043f,0.098051f,0.91132f,0.088764f,0.885805f,0.070013f,
0.885805f,0.070013f,0.91132f,0.088764f,0.927482f,0.072587f,0.896806f,0.048635f,
0.848273f,0.056238f,0.885805f,0.070013f,0.896806f,0.048635f,0.854867f,0.030613f,
0.896806f,0.048635f,0.927482f,0.072587f,0.93619f,0.06387f,0.900938f,0.042615f,
0.854867f,0.030613f,0.896806f,0.048635f,0.900938f,0.042615f,0.865686f,0.02136f,
0.797148f,0.017695f,0.854867f,0.030613f,0.865686f,0.02136f,0.798979f,0.01068f,
0.6903f,0.009921f,0.797148f,0.017695f,0.798979f,0.01068f,0.732272f,0.0f,
0.688243f,0.93964f,0.688654f,0.963427f,0.793487f,0.957052f,0.792572f,0.934124f,
0.793487f,0.957052f,0.688654f,0.963427f,0.6903f,0.990661f,0.797148f,0.983343f,
0.848273f,0.947062f,0.793487f,0.957052f,0.797148f,0.983343f,0.854867f,0.971183f,
0.792572f,0.934124f,0.793487f,0.957052f,0.848273f,0.947062f,0.846453f,0.926026f,
0.6903f,0.990661f,0.732272f,1.0f,0.798979f,0.989946f,0.797148f,0.983343f,
0.797148f,0.983343f,0.798979f,0.989946f,0.865686f,0.979893f,0.854867f,0.971183f,
0.848273f,0.947062f,0.854867f,0.971183f,0.896806f,0.954218f,0.885805f,0.934095f,
0.854867f,0.971183f,0.865686f,0.979893f,0.900938f,0.959885f,0.896806f,0.954218f,
0.896806f,0.954218f,0.900938f,0.959885f,0.93619f,0.939877f,0.927482f,0.931672f,
0.896806f,0.954218f,0.927482f,0.931672f,0.91132f,0.916444f,0.885805f,0.934095f,
0.846453f,0.926026f,0.848273f,0.947062f,0.885805f,0.934095f,0.882371f,0.916444f,
0.882371f,0.916444f,0.885805f,0.934095f,0.91132f,0.916444f,0.902043f,0.907702f,
0.691637f,0.699784f,0.690711f,0.808737f,0.798063f,0.806796f,0.800123f,0.698917f,
0.690711f,0.808737f,0.68958f,0.867044f,0.795546f,0.863911f,0.798063f,0.806796f,
0.798063f,0.806796f,0.795546f,0.863911f,0.85211f,0.859921f,0.856345f,0.804425f,
0.800123f,0.698917f,0.798063f,0.806796f,0.856345f,0.804425f,0.859669f,0.697857f,
0.68958f,0.867044f,0.688654f,0.909095f,0.793487f,0.904715f,0.795546f,0.863911f,
0.688654f,0.909095f,0.688243f,0.93964f,0.792572f,0.934124f,0.793487f,0.904715f,
0.793487f,0.904715f,0.792572f,0.934124f,0.846453f,0.926026f,0.848273f,0.898717f,
0.795546f,0.863911f,0.793487f,0.904715f,0.848273f,0.898717f,0.85211f,0.859921f,
0.85211f,0.859921f,0.848273f,0.898717f,0.885805f,0.892403f,0.892507f,0.856305f,
0.848273f,0.898717f,0.846453f,0.926026f,0.882371f,0.916444f,0.885805f,0.892403f,
0.885805f,0.892403f,0.882371f,0.916444f,0.902043f,0.907702f,0.91132f,0.889167f,
0.892507f,0.856305f,0.885805f,0.892403f,0.91132f,0.889167f,0.92149f,0.854591f,
0.859669f,0.697857f,0.856345f,0.804425f,0.898872f,0.802484f,0.903521f,0.69699f,
0.856345f,0.804425f,0.85211f,0.859921f,0.892507f,0.856305f,0.898872f,0.802484f,
0.898872f,0.802484f,0.892507f,0.856305f,0.92149f,0.854591f,0.930084f,0.801622f,
0.903521f,0.69699f,0.898872f,0.802484f,0.930084f,0.801622f,0.935938f,0.696604f,
0.691637f,0.311325f,0.691946f,0.505792f,0.800809f,0.505816f,0.800123f,0.312259f,
0.691946f,0.505792f,0.691637f,0.699784f,0.800123f,0.698917f,0.800809f,0.505816f,
0.800809f,0.505816f,0.800123f,0.698917f,0.859669f,0.697857f,0.860777f,0.505846f,
0.800123f,0.312259f,0.800809f,0.505816f,0.860777f,0.505846f,0.859669f,0.3134f,
0.859669f,0.697857f,0.903521f,0.69699f,0.90507f,0.50587f,0.860777f,0.505846f,
0.903521f,0.69699f,0.935938f,0.696604f,0.93789f,0.505881f,0.90507f,0.50587f,
0.90507f,0.50587f,0.93789f,0.505881f,0.935938f,0.314748f,0.903521f,0.314333f,
0.860777f,0.505846f,0.90507f,0.50587f,0.903521f,0.314333f,0.859669f,0.3134f,
0.0f,0.269739f,0.010008f,0.312673f,0.017852f,0.203923f,0.010774f,0.202091f,
0.017852f,0.203923f,0.010008f,0.312673f,0.039196f,0.314333f,0.046029f,0.207588f,
0.030884f,0.14549f,0.017852f,0.203923f,0.046029f,0.207588f,0.056735f,0.152091f,
0.010774f,0.202091f,0.017852f,0.203923f,0.030884f,0.14549f,0.021549f,0.134442f,
0.039196f,0.314333f,0.064689f,0.314748f,0.070602f,0.208504f,0.046029f,0.207588f,
0.046029f,0.207588f,0.070602f,0.208504f,0.07928f,0.153913f,0.056735f,0.152091f,
0.030884f,0.14549f,0.056735f,0.152091f,0.070632f,0.114303f,0.049066f,0.103292f,
0.056735f,0.152091f,0.07928f,0.153913f,0.089549f,0.117742f,0.070632f,0.114303f,
0.070632f,0.114303f,0.089549f,0.117742f,0.098918f,0.098051f,0.089549f,0.088764f,
0.070632f,0.114303f,0.089549f,0.088764f,0.073229f,0.072587f,0.049066f,0.103292f,
0.021549f,0.134442f,0.030884f,0.14549f,0.049066f,0.103292f,0.042992f,0.099156f,
0.042992f,0.099156f,0.049066f,0.103292f,0.073229f,0.072587f,0.064435f,0.06387f,
0.935938f,0.314748f,0.961185f,0.314333f,0.954418f,0.207588f,0.930084f,0.208504f,
0.954418f,0.207588f,0.961185f,0.314333f,0.990089f,0.312674f,0.982322f,0.203923f,
0.943816f,0.152092f,0.954418f,0.207588f,0.982322f,0.203923f,0.969416f,0.145491f,
0.930084f,0.208504f,0.954418f,0.207588f,0.943816f,0.152092f,0.92149f,0.153913f,
0.990089f,0.312674f,1.0f,0.269739f,0.98933f,0.202091f,0.982322f,0.203923f,
0.982322f,0.203923f,0.98933f,0.202091f,0.97866f,0.134442f,0.969416f,0.145491f,
0.943816f,0.152092f,0.969416f,0.145491f,0.951411f,0.103292f,0.930054f,0.114304f,
0.969416f,0.145491f,0.97866f,0.134442f,0.957425f,0.099156f,0.951411f,0.103292f,
0.951411f,0.103292f,0.957425f,0.099156f,0.93619f,0.06387f,0.927482f,0.072587f,
0.951411f,0.103292f,0.927482f,0.072587f,0.91132f,0.088764f,0.930054f,0.114304f,
0.92149f,0.153913f,0.943816f,0.152092f,0.930054f,0.114304f,0.91132f,0.117742f,
0.91132f,0.117742f,0.930054f,0.114304f,0.91132f,0.088764f,0.902043f,0.098051f,
0.688243f,0.064123f,0.688654f,0.096571f,0.793487f,0.101224f,0.792572f,0.069983f,
0.688654f,0.096571f,0.68958f,0.140684f,0.795546f,0.144012f,0.793487f,0.101224f,
0.793487f,0.101224f,0.795546f,0.144012f,0.85211f,0.14825f,0.848273f,0.107596f,
0.792572f,0.069983f,0.793487f,0.101224f,0.848273f,0.107596f,0.846453f,0.078585f,
0.68958f,0.140684f,0.690711f,0.200945f,0.798063f,0.203007f,0.795546f,0.144012f,
0.690711f,0.200945f,0.691637f,0.311325f,0.800123f,0.312259f,0.798063f,0.203007f,
0.798063f,0.203007f,0.800123f,0.312259f,0.859669f,0.3134f,0.856345f,0.205526f,
0.795546f,0.144012f,0.798063f,0.203007f,0.856345f,0.205526f,0.85211f,0.14825f,
0.85211f,0.14825f,0.856345f,0.205526f,0.898872f,0.207588f,0.892507f,0.152092f,
0.856345f,0.205526f,0.859669f,0.3134f,0.903521f,0.314333f,0.898872f,0.207588f,
0.898872f,0.207588f,0.903521f,0.314333f,0.935938f,0.314748f,0.930084f,0.208504f,
0.892507f,0.152092f,0.898872f,0.207588f,0.930084f,0.208504f,0.92149f,0.153913f,
0.846453f,0.078585f,0.848273f,0.107596f,0.885805f,0.114304f,0.882371f,0.088764f,
0.848273f,0.107596f,0.85211f,0.14825f,0.892507f,0.152092f,0.885805f,0.114304f,
0.885805f,0.114304f,0.892507f,0.152092f,0.92149f,0.153913f,0.91132f,0.117742f,
0.882371f,0.088764f,0.885805f,0.114304f,0.91132f,0.117742f,0.902043f,0.098051f,
0.68958f,0.140684f,0.688654f,0.096571f,0.50098f,0.095021f,0.500976f,0.139575f,
0.688654f,0.096571f,0.688243f,0.064123f,0.500982f,0.062169f,0.50098f,0.095021f,
0.50098f,0.095021f,0.500982f,0.062169f,0.313652f,0.064123f,0.313236f,0.096571f,
0.500976f,0.139575f,0.50098f,0.095021f,0.313236f,0.096571f,0.312299f,0.140684f,
0.68958f,0.140684f,0.500976f,0.139575f,0.500971f,0.200258f,0.690711f,0.200945f,
0.500976f,0.139575f,0.312299f,0.140684f,0.311154f,0.200945f,0.500971f,0.200258f,
0.500971f,0.200258f,0.311154f,0.200945f,0.310217f,0.311325f,0.500967f,0.311013f,
0.690711f,0.200945f,0.500971f,0.200258f,0.500967f,0.311013f,0.691637f,0.311325f,
0.064689f,0.314748f,0.097425f,0.314333f,0.102119f,0.207588f,0.070602f,0.208504f,
0.097425f,0.314333f,0.141621f,0.3134f,0.144978f,0.205526f,0.102119f,0.207588f,
0.102119f,0.207588f,0.144978f,0.205526f,0.149254f,0.14825f,0.108547f,0.152092f,
0.070602f,0.208504f,0.102119f,0.207588f,0.108547f,0.152092f,0.07928f,0.153913f,
0.141621f,0.3134f,0.201493f,0.312259f,0.203573f,0.203007f,0.144978f,0.205526f,
0.201493f,0.312259f,0.310217f,0.311325f,0.311154f,0.200945f,0.203573f,0.203007f,
0.203573f,0.203007f,0.311154f,0.200945f,0.312299f,0.140684f,0.206115f,0.144012f,
0.144978f,0.205526f,0.203573f,0.203007f,0.206115f,0.144012f,0.149254f,0.14825f,
0.149254f,0.14825f,0.206115f,0.144012f,0.208194f,0.101224f,0.153129f,0.107596f,
0.206115f,0.144012f,0.312299f,0.140684f,0.313236f,0.096571f,0.208194f,0.101224f,
0.208194f,0.101224f,0.313236f,0.096571f,0.313652f,0.064123f,0.209119f,0.069983f,
0.153129f,0.107596f,0.208194f,0.101224f,0.209119f,0.069983f,0.154967f,0.078585f,
0.07928f,0.153913f,0.108547f,0.152092f,0.115314f,0.114304f,0.089549f,0.117742f,
0.108547f,0.152092f,0.149254f,0.14825f,0.153129f,0.107596f,0.115314f,0.114304f,
0.115314f,0.114304f,0.153129f,0.107596f,0.154967f,0.078585f,0.118783f,0.088764f,
0.089549f,0.117742f,0.115314f,0.114304f,0.118783f,0.088764f,0.098918f,0.098051f,
};
static const float cfGameIconNormals[] = {
-0.210457f,-0.226211f,0.951071f,-0.137777f,-0.231234f,0.963093f,-0.113627f,-0.120055f,0.986243f,-0.216181f,-0.146015f,0.965373f,
-0.137777f,-0.231234f,0.963093f,-0.083714f,-0.234126f,0.968595f,-0.06603f,-0.119508f,0.990635f,-0.113627f,-0.120055f,0.986243f,
-0.113627f,-0.120055f,0.986243f,-0.06603f,-0.119508f,0.990635f,-0.062379f,-0.064577f,0.995961f,-0.113032f,-0.068284f,0.991242f,
-0.216181f,-0.146015f,0.965373f,-0.113627f,-0.120055f,0.986243f,-0.113032f,-0.068284f,0.991242f,-0.219508f,-0.086774f,0.971744f,
-0.083714f,-0.234126f,0.968595f,-0.036722f,-0.235389f,0.971207f,-0.028482f,-0.119193f,0.992463f,-0.06603f,-0.119508f,0.990635f,
-0.036722f,-0.235389f,0.971207f,-0.010823f,-0.235649f,0.971778f,-0.008321f,-0.119124f,0.992845f,-0.028482f,-0.119193f,0.992463f,
-0.028482f,-0.119193f,0.992463f,-0.008321f,-0.119124f,0.992845f,-0.007465f,-0.063717f,0.99794f,-0.026099f,-0.06375f,0.997625f,
-0.06603f,-0.119508f,0.990635f,-0.028482f,-0.119193f,0.992463f,-0.026099f,-0.06375f,0.997625f,-0.062379f,-0.064577f,0.995961f,
-0.062379f,-0.064577f,0.995961f,-0.026099f,-0.06375f,0.997625f,-0.025391f,-0.025563f,0.999351f,-0.061589f,-0.026301f,0.997755f,
-0.026099f,-0.06375f,0.997625f,-0.007465f,-0.063717f,0.99794f,-0.007172f,-0.02556f,0.999648f,-0.025391f,-0.025563f,0.999351f,
-0.025391f,-0.025563f,0.999351f,-0.007172f,-0.02556f,0.999648f,-0.007161f,-0.00707f,0.999949f,-0.025395f,-0.007088f,0.999652f,
-0.061589f,-0.026301f,0.997755f,-0.025391f,-0.025563f,0.999351f,-0.025395f,-0.007088f,0.999652f,-0.061548f,-0.00739f,0.998077f,
-0.219508f,-0.086774f,0.971744f,-0.113032f,-0.068284f,0.991242f,-0.112752f,-0.028685f,0.993209f,-0.22077f,-0.037047f,0.974622f,
-0.113032f,-0.068284f,0.991242f,-0.062379f,-0.064577f,0.995961f,-0.061589f,-0.026301f,0.997755f,-0.112752f,-0.028685f,0.993209f,
-0.112752f,-0.028685f,0.993209f,-0.061589f,-0.026301f,0.997755f,-0.061548f,-0.00739f,0.998077f,-0.112673f,-0.008234f,0.993598f,
-0.22077f,-0.037047f,0.974622f,-0.112752f,-0.028685f,0.993209f,-0.112673f,-0.008234f,0.993598f,-0.221f,-0.010721f,0.975215f,
-0.007161f,-0.00707f,0.999949f,-0.007172f,-0.02556f,0.999648f,0.0f,-0.025624f,0.999672f,0.0f,-0.007089f,0.999975f,
-0.007172f,-0.02556f,0.999648f,-0.007465f,-0.063717f,0.99794f,0.0f,-0.06378f,0.997964f,0.0f,-0.025624f,0.999672f,
0.0f,-0.025624f,0.999672f,0.0f,-0.06378f,0.997964f,0.007472f,-0.063716f,0.99794f,0.007179f,-0.025559f,0.999648f,
0.0f,-0.007089f,0.999975f,0.0f,-0.025624f,0.999672f,0.007179f,-0.025559f,0.999648f,0.007169f,-0.00707f,0.999949f,
-0.007465f,-0.063717f,0.99794f,-0.008321f,-0.119124f,0.992845f,0.0f,-0.119133f,0.992878f,0.0f,-0.06378f,0.997964f,
-0.008321f,-0.119124f,0.992845f,-0.010823f,-0.235649f,0.971778f,0.0f,-0.235564f,0.971859f,0.0f,-0.119133f,0.992878f,
0.0f,-0.119133f,0.992878f,0.0f,-0.235564f,0.971859f,0.010835f,-0.23565f,0.971778f,0.008329f,-0.119124f,0.992845f,
0.0f,-0.06378f,0.997964f,0.0f,-0.119133f,0.992878f,0.008329f,-0.119124f,0.992845f,0.007472f,-0.063716f,0.99794f,
-0.007161f,-0.00707f,0.999949f,0.0f,-0.007089f,0.999975f,0.0f,0.0f,1.0f,-0.007181f,0.0f,0.999974f,
0.0f,-0.007089f,0.999975f,0.007169f,-0.00707f,0.999949f,0.007189f,0.0f,0.999974f,0.0f,0.0f,1.0f,
0.0f,0.0f,1.0f,0.007189f,0.0f,0.999974f,0.00717f,0.007027f,0.99995f,0.0f,0.007045f,0.999975f,
-0.007181f,0.0f,0.999974f,0.0f,0.0f,1.0f,0.0f,0.007045f,0.999975f,-0.007163f,0.007027f,0.99995f,
-0.061553f,0.007347f,0.998077f,-0.112675f,0.008187f,0.993598f,-0.112665f,0.0f,0.993633f,-0.061598f,0.0f,0.998101f,
-0.112675f,0.008187f,0.993598f,-0.220997f,0.010655f,0.975216f,-0.220914f,-1.0E-6f,0.975293f,-0.112665f,0.0f,0.993633f,
-0.112665f,0.0f,0.993633f,-0.220914f,-1.0E-6f,0.975293f,-0.221f,-0.010721f,0.975215f,-0.112673f,-0.008234f,0.993598f,
-0.061598f,0.0f,0.998101f,-0.112665f,0.0f,0.993633f,-0.112673f,-0.008234f,0.993598f,-0.061548f,-0.00739f,0.998077f,
-0.061553f,0.007347f,0.998077f,-0.061598f,0.0f,0.998101f,-0.025456f,0.0f,0.999676f,-0.025398f,0.007046f,0.999653f,
-0.061598f,0.0f,0.998101f,-0.061548f,-0.00739f,0.998077f,-0.025395f,-0.007088f,0.999652f,-0.025456f,0.0f,0.999676f,
-0.025456f,0.0f,0.999676f,-0.025395f,-0.007088f,0.999652f,-0.007161f,-0.00707f,0.999949f,-0.007181f,0.0f,0.999974f,
-0.025398f,0.007046f,0.999653f,-0.025456f,0.0f,0.999676f,-0.007181f,0.0f,0.999974f,-0.007163f,0.007027f,0.99995f,
-0.211482f,0.213152f,0.953856f,-0.138447f,0.218126f,0.966051f,-0.198978f,0.347214f,0.916433f,-0.296456f,0.298724f,0.907126f,
-0.138447f,0.218126f,0.966051f,-0.084089f,0.221062f,0.971628f,-0.117212f,0.361162f,0.925107f,-0.198978f,0.347214f,0.916433f,
-0.198978f,0.347214f,0.916433f,-0.117212f,0.361162f,0.925107f,-0.168084f,0.541107f,0.823985f,-0.282777f,0.494303f,0.822011f,
-0.296456f,0.298724f,0.907126f,-0.198978f,0.347214f,0.916433f,-0.282777f,0.494303f,0.822011f,-0.402197f,0.405178f,0.821017f,
-0.084089f,0.221062f,0.971628f,-0.036885f,0.222305f,0.974279f,-0.050723f,0.367918f,0.928474f,-0.117212f,0.361162f,0.925107f,
-0.036885f,0.222305f,0.974279f,-0.010867f,0.22256f,0.974858f,-0.014805f,0.369601f,0.929073f,-0.050723f,0.367918f,0.928474f,
-0.050723f,0.367918f,0.928474f,-0.014805f,0.369601f,0.929073f,-0.020782f,0.568602f,0.822351f,-0.072149f,0.563165f,0.823189f,
-0.117212f,0.361162f,0.925107f,-0.050723f,0.367918f,0.928474f,-0.072149f,0.563165f,0.823189f,-0.168084f,0.541107f,0.823985f,
-0.072149f,0.563165f,0.823189f,-0.020782f,0.568602f,0.822351f,-0.025372f,0.696348f,0.717256f,-0.088478f,0.684053f,0.724047f,
-0.168084f,0.541107f,0.823985f,-0.072149f,0.563165f,0.823189f,-0.088478f,0.684053f,0.724047f,-0.20294f,0.64707f,0.734926f,
-0.282777f,0.494303f,0.822011f,-0.168084f,0.541107f,0.823985f,-0.20294f,0.64707f,0.734926f,-0.333245f,0.577074f,0.745609f,
-0.402197f,0.405178f,0.821017f,-0.282777f,0.494303f,0.822011f,-0.333245f,0.577074f,0.745609f,-0.466013f,0.469045f,0.75022f,
-0.025372f,0.696348f,0.717256f,-0.020782f,0.568602f,0.822351f,0.0f,0.568694f,0.822549f,-2.0E-6f,0.698486f,0.715623f,
0.0f,0.568694f,0.822549f,-0.020782f,0.568602f,0.822351f,-0.014805f,0.369601f,0.929073f,0.0f,0.369504f,0.929229f,
0.020804f,0.568602f,0.82235f,0.0f,0.568694f,0.822549f,0.0f,0.369504f,0.929229f,0.01482f,0.369601f,0.929072f,
-2.0E-6f,0.698486f,0.715623f,0.0f,0.568694f,0.822549f,0.020804f,0.568602f,0.82235f,0.025388f,0.696365f,0.717239f,
-0.014805f,0.369601f,0.929073f,-0.010867f,0.22256f,0.974858f,0.0f,0.222477f,0.974938f,0.0f,0.369504f,0.929229f,
0.0f,0.369504f,0.929229f,0.0f,0.222477f,0.974938f,0.010878f,0.222561f,0.974858f,0.01482f,0.369601f,0.929072f,
0.010835f,-0.23565f,0.971778f,0.0f,-0.235564f,0.971859f,0.0f,-0.389089f,0.9212f,0.014687f,-0.38921f,0.921032f,
0.0f,-0.235564f,0.971859f,-0.010823f,-0.235649f,0.971778f,-0.014671f,-0.38921f,0.921032f,0.0f,-0.389089f,0.9212f,
0.0f,-0.389089f,0.9212f,-0.014671f,-0.38921f,0.921032f,-0.020367f,-0.591835f,0.805802f,0.0f,-0.591896f,0.806014f,
0.014687f,-0.38921f,0.921032f,0.0f,-0.389089f,0.9212f,0.0f,-0.591896f,0.806014f,0.020387f,-0.591837f,0.8058f,
-0.020367f,-0.591835f,0.805802f,-0.024675f,-0.717705f,0.69591f,-2.0E-6f,-0.719788f,0.694194f,0.0f,-0.591896f,0.806014f,
0.0f,-0.591896f,0.806014f,-2.0E-6f,-0.719788f,0.694194f,0.02469f,-0.717725f,0.695889f,0.020387f,-0.591837f,0.8058f,
-0.46128f,-0.48965f,0.739908f,-0.32814f,-0.599132f,0.730319f,-0.27855f,-0.517113f,0.809323f,-0.397988f,-0.425903f,0.812534f,
-0.32814f,-0.599132f,0.730319f,-0.198659f,-0.669215f,0.716021f,-0.165045f,-0.564346f,0.808872f,-0.27855f,-0.517113f,0.809323f,
-0.27855f,-0.517113f,0.809323f,-0.165045f,-0.564346f,0.808872f,-0.116165f,-0.380579f,0.917423f,-0.197289f,-0.366449f,0.909281f,
-0.397988f,-0.425903f,0.812534f,-0.27855f,-0.517113f,0.809323f,-0.197289f,-0.366449f,0.909281f,-0.294472f,-0.315809f,0.901971f,
-0.198659f,-0.669215f,0.716021f,-0.086339f,-0.705672f,0.703258f,-0.070739f,-0.586438f,0.806899f,-0.165045f,-0.564346f,0.808872f,
-0.086339f,-0.705672f,0.703258f,-0.024675f,-0.717705f,0.69591f,-0.020367f,-0.591835f,0.805802f,-0.070739f,-0.586438f,0.806899f,
-0.070739f,-0.586438f,0.806899f,-0.020367f,-0.591835f,0.805802f,-0.014671f,-0.38921f,0.921032f,-0.050259f,-0.387507f,0.920496f,
-0.165045f,-0.564346f,0.808872f,-0.070739f,-0.586438f,0.806899f,-0.050259f,-0.387507f,0.920496f,-0.116165f,-0.380579f,0.917423f,
-0.050259f,-0.387507f,0.920496f,-0.014671f,-0.38921f,0.921032f,-0.010823f,-0.235649f,0.971778f,-0.036722f,-0.235389f,0.971207f,
-0.116165f,-0.380579f,0.917423f,-0.050259f,-0.387507f,0.920496f,-0.036722f,-0.235389f,0.971207f,-0.083714f,-0.234126f,0.968595f,
-0.197289f,-0.366449f,0.909281f,-0.116165f,-0.380579f,0.917423f,-0.083714f,-0.234126f,0.968595f,-0.137777f,-0.231234f,0.963093f,
-0.294472f,-0.315809f,0.901971f,-0.197289f,-0.366449f,0.909281f,-0.137777f,-0.231234f,0.963093f,-0.210457f,-0.226211f,0.951071f,
0.212501f,-0.226048f,0.950655f,0.297154f,-0.315494f,0.901201f,0.347306f,-0.209845f,0.913971f,0.218237f,-0.145906f,0.964927f,
0.347306f,-0.209845f,0.913971f,0.297154f,-0.315494f,0.901201f,0.401261f,-0.425239f,0.811271f,0.493682f,-0.297695f,0.817102f,
0.362206f,-0.121013f,0.924209f,0.347306f,-0.209845f,0.913971f,0.493682f,-0.297695f,0.817102f,0.542487f,-0.173678f,0.821915f,
0.218237f,-0.145906f,0.964927f,0.347306f,-0.209845f,0.913971f,0.362206f,-0.121013f,0.924209f,0.221558f,-0.086713f,0.971284f,
0.401261f,-0.425239f,0.811271f,0.464547f,-0.488911f,0.738351f,0.57643f,-0.348399f,0.739153f,0.493682f,-0.297695f,0.817102f,
0.493682f,-0.297695f,0.817102f,0.57643f,-0.348399f,0.739153f,0.648687f,-0.208869f,0.731832f,0.542487f,-0.173678f,0.821915f,
0.362206f,-0.121013f,0.924209f,0.542487f,-0.173678f,0.821915f,0.564441f,-0.072486f,0.822285f,0.368823f,-0.050932f,0.928103f,
0.542487f,-0.173678f,0.821915f,0.648687f,-0.208869f,0.731832f,0.685633f,-0.08861f,0.722534f,0.564441f,-0.072486f,0.822285f,
0.564441f,-0.072486f,0.822285f,0.685633f,-0.08861f,0.722534f,0.697362f,-0.024953f,0.716285f,0.569527f,-0.020487f,0.821717f,
0.564441f,-0.072486f,0.822285f,0.569527f,-0.020487f,0.821717f,0.370348f,-0.014597f,0.928778f,0.368823f,-0.050932f,0.928103f,
0.221558f,-0.086713f,0.971284f,0.362206f,-0.121013f,0.924209f,0.368823f,-0.050932f,0.928103f,0.222823f,-0.037022f,0.974156f,
0.222823f,-0.037022f,0.974156f,0.368823f,-0.050932f,0.928103f,0.370348f,-0.014597f,0.928778f,0.223053f,-0.010715f,0.974747f,
0.223053f,-0.010715f,0.974747f,0.370348f,-0.014597f,0.928778f,0.37024f,-1.0E-6f,0.928936f,0.222967f,-1.0E-6f,0.974826f,
0.37024f,-1.0E-6f,0.928936f,0.370348f,-0.014597f,0.928778f,0.569527f,-0.020487f,0.821717f,0.569586f,-1.0E-6f,0.821932f,
0.37035f,0.014508f,0.928779f,0.37024f,-1.0E-6f,0.928936f,0.569586f,-1.0E-6f,0.821932f,0.569522f,0.020364f,0.821724f,
0.222967f,-1.0E-6f,0.974826f,0.37024f,-1.0E-6f,0.928936f,0.37035f,0.014508f,0.928779f,0.223051f,0.010649f,0.974749f,
0.569527f,-0.020487f,0.821717f,0.697362f,-0.024953f,0.716285f,0.699353f,1.1E-5f,0.714776f,0.569586f,-1.0E-6f,0.821932f,
0.569586f,-1.0E-6f,0.821932f,0.699353f,1.1E-5f,0.714776f,0.697248f,0.024864f,0.716398f,0.569522f,0.020364f,0.821724f,
-0.46128f,-0.48965f,0.739908f,-0.397988f,-0.425903f,0.812534f,-0.490028f,-0.298377f,0.819051f,-0.572885f,-0.349196f,0.741529f,
-0.490028f,-0.298377f,0.819051f,-0.397988f,-0.425903f,0.812534f,-0.294472f,-0.315809f,0.901971f,-0.344264f,-0.210118f,0.915059f,
-0.538747f,-0.174169f,0.824268f,-0.490028f,-0.298377f,0.819051f,-0.344264f,-0.210118f,0.915059f,-0.359131f,-0.12118f,0.925386f,
-0.572885f,-0.349196f,0.741529f,-0.490028f,-0.298377f,0.819051f,-0.538747f,-0.174169f,0.824268f,-0.645088f,-0.209547f,0.734814f,
-0.294472f,-0.315809f,0.901971f,-0.210457f,-0.226211f,0.951071f,-0.216181f,-0.146015f,0.965373f,-0.344264f,-0.210118f,0.915059f,
-0.344264f,-0.210118f,0.915059f,-0.216181f,-0.146015f,0.965373f,-0.219508f,-0.086774f,0.971744f,-0.359131f,-0.12118f,0.925386f,
-0.538747f,-0.174169f,0.824268f,-0.359131f,-0.12118f,0.925386f,-0.365721f,-0.051004f,0.929326f,-0.560687f,-0.072708f,0.82483f,
-0.359131f,-0.12118f,0.925386f,-0.219508f,-0.086774f,0.971744f,-0.22077f,-0.037047f,0.974622f,-0.365721f,-0.051004f,0.929326f,
-0.365721f,-0.051004f,0.929326f,-0.22077f,-0.037047f,0.974622f,-0.221f,-0.010721f,0.975215f,-0.367244f,-0.014617f,0.93001f,
-0.365721f,-0.051004f,0.929326f,-0.367244f,-0.014617f,0.93001f,-0.565774f,-0.020551f,0.824304f,-0.560687f,-0.072708f,0.82483f,
-0.645088f,-0.209547f,0.734814f,-0.538747f,-0.174169f,0.824268f,-0.560687f,-0.072708f,0.82483f,-0.682094f,-0.088945f,0.725836f,
-0.682094f,-0.088945f,0.725836f,-0.560687f,-0.072708f,0.82483f,-0.565774f,-0.020551f,0.824304f,-0.69385f,-0.025062f,0.719683f,
-0.693736f,0.024972f,0.719796f,-0.695847f,1.1E-5f,0.71819f,-0.565837f,-1.0E-6f,0.824517f,-0.565768f,0.020427f,0.824311f,
-0.695847f,1.1E-5f,0.71819f,-0.69385f,-0.025062f,0.719683f,-0.565774f,-0.020551f,0.824304f,-0.565837f,-1.0E-6f,0.824517f,
-0.565837f,-1.0E-6f,0.824517f,-0.565774f,-0.020551f,0.824304f,-0.367244f,-0.014617f,0.93001f,-0.36714f,-1.0E-6f,0.930166f,
-0.565768f,0.020427f,0.824311f,-0.565837f,-1.0E-6f,0.824517f,-0.36714f,-1.0E-6f,0.930166f,-0.367245f,0.014528f,0.930011f,
-0.367244f,-0.014617f,0.93001f,-0.221f,-0.010721f,0.975215f,-0.220914f,-1.0E-6f,0.975293f,-0.36714f,-1.0E-6f,0.930166f,
-0.36714f,-1.0E-6f,0.930166f,-0.220914f,-1.0E-6f,0.975293f,-0.220997f,0.010655f,0.975216f,-0.367245f,0.014528f,0.930011f,
0.010878f,0.222561f,0.974858f,0.037001f,0.222307f,0.974274f,0.050884f,0.367932f,0.92846f,0.01482f,0.369601f,0.929072f,
0.037001f,0.222307f,0.974274f,0.084603f,0.221056f,0.971585f,0.117939f,0.361173f,0.92501f,0.050884f,0.367932f,0.92846f,
0.050884f,0.367932f,0.92846f,0.117939f,0.361173f,0.92501f,0.169134f,0.541105f,0.823771f,0.072381f,0.563194f,0.823149f,
0.020804f,0.568602f,0.82235f,0.01482f,0.369601f,0.929072f,0.050884f,0.367932f,0.92846f,0.072381f,0.563194f,0.823149f,
0.084603f,0.221056f,0.971585f,0.139597f,0.218066f,0.965898f,0.200629f,0.347092f,0.91612f,0.117939f,0.361173f,0.92501f,
0.139597f,0.218066f,0.965898f,0.213531f,0.212993f,0.953435f,0.299149f,0.298419f,0.906342f,0.200629f,0.347092f,0.91612f,
0.200629f,0.347092f,0.91612f,0.299149f,0.298419f,0.906342f,0.405489f,0.404531f,0.819716f,0.285031f,0.494036f,0.821393f,
0.117939f,0.361173f,0.92501f,0.200629f,0.347092f,0.91612f,0.285031f,0.494036f,0.821393f,0.169134f,0.541105f,0.823771f,
0.285031f,0.494036f,0.821393f,0.405489f,0.404531f,0.819716f,0.4693f,0.468325f,0.748619f,0.335556f,0.576804f,0.744781f,
0.169134f,0.541105f,0.823771f,0.285031f,0.494036f,0.821393f,0.335556f,0.576804f,0.744781f,0.204073f,0.64709f,0.734595f,
0.072381f,0.563194f,0.823149f,0.169134f,0.541105f,0.823771f,0.204073f,0.64709f,0.734595f,0.088715f,0.684119f,0.723955f,
0.020804f,0.568602f,0.82235f,0.072381f,0.563194f,0.823149f,0.088715f,0.684119f,0.723955f,0.025388f,0.696365f,0.717239f,
0.010835f,-0.23565f,0.971778f,0.014687f,-0.38921f,0.921032f,0.050418f,-0.38752f,0.920482f,0.036837f,-0.235391f,0.971203f,
0.050418f,-0.38752f,0.920482f,0.014687f,-0.38921f,0.921032f,0.020387f,-0.591837f,0.8058f,0.070967f,-0.586467f,0.806858f,
0.116885f,-0.380591f,0.917327f,0.050418f,-0.38752f,0.920482f,0.070967f,-0.586467f,0.806858f,0.166076f,-0.564345f,0.808662f,
0.036837f,-0.235391f,0.971203f,0.050418f,-0.38752f,0.920482f,0.116885f,-0.380591f,0.917327f,0.084225f,-0.234121f,0.968552f,
0.020387f,-0.591837f,0.8058f,0.02469f,-0.717725f,0.695889f,0.086571f,-0.705739f,0.703163f,0.070967f,-0.586467f,0.806858f,
0.070967f,-0.586467f,0.806858f,0.086571f,-0.705739f,0.703163f,0.199773f,-0.669232f,0.715695f,0.166076f,-0.564345f,0.808662f,
0.116885f,-0.380591f,0.917327f,0.166076f,-0.564345f,0.808662f,0.280776f,-0.516844f,0.808725f,0.198928f,-0.366325f,0.908974f,
0.166076f,-0.564345f,0.808662f,0.199773f,-0.669232f,0.715695f,0.33043f,-0.598851f,0.729516f,0.280776f,-0.516844f,0.808725f,
0.280776f,-0.516844f,0.808725f,0.33043f,-0.598851f,0.729516f,0.464547f,-0.488911f,0.738351f,0.401261f,-0.425239f,0.811271f,
0.280776f,-0.516844f,0.808725f,0.401261f,-0.425239f,0.811271f,0.297154f,-0.315494f,0.901201f,0.198928f,-0.366325f,0.908974f,
0.084225f,-0.234121f,0.968552f,0.116885f,-0.380591f,0.917327f,0.198928f,-0.366325f,0.908974f,0.138923f,-0.231173f,0.962943f,
0.138923f,-0.231173f,0.962943f,0.198928f,-0.366325f,0.908974f,0.297154f,-0.315494f,0.901201f,0.212501f,-0.226048f,0.950655f,
0.007169f,-0.00707f,0.999949f,0.007179f,-0.025559f,0.999648f,0.025473f,-0.02556f,0.999349f,0.025479f,-0.007087f,0.99965f,
0.007179f,-0.025559f,0.999648f,0.007472f,-0.063716f,0.99794f,0.02618f,-0.063744f,0.997623f,0.025473f,-0.02556f,0.999349f,
0.025473f,-0.02556f,0.999349f,0.02618f,-0.063744f,0.997623f,0.062764f,-0.064559f,0.995938f,0.061979f,-0.026292f,0.997731f,
0.025479f,-0.007087f,0.99965f,0.025473f,-0.02556f,0.999349f,0.061979f,-0.026292f,0.997731f,0.061944f,-0.007387f,0.998052f,
0.007472f,-0.063716f,0.99794f,0.008329f,-0.119124f,0.992845f,0.028568f,-0.119188f,0.992461f,0.02618f,-0.063744f,0.997623f,
0.008329f,-0.119124f,0.992845f,0.010835f,-0.23565f,0.971778f,0.036837f,-0.235391f,0.971203f,0.028568f,-0.119188f,0.992461f,
0.028568f,-0.119188f,0.992461f,0.036837f,-0.235391f,0.971203f,0.084225f,-0.234121f,0.968552f,0.066426f,-0.119489f,0.990611f,
0.02618f,-0.063744f,0.997623f,0.028568f,-0.119188f,0.992461f,0.066426f,-0.119489f,0.990611f,0.062764f,-0.064559f,0.995938f,
0.062764f,-0.064559f,0.995938f,0.066426f,-0.119489f,0.990611f,0.114563f,-0.120018f,0.98614f,0.113981f,-0.068259f,0.991135f,
0.066426f,-0.119489f,0.990611f,0.084225f,-0.234121f,0.968552f,0.138923f,-0.231173f,0.962943f,0.114563f,-0.120018f,0.98614f,
0.114563f,-0.120018f,0.98614f,0.138923f,-0.231173f,0.962943f,0.212501f,-0.226048f,0.950655f,0.218237f,-0.145906f,0.964927f,
0.113981f,-0.068259f,0.991135f,0.114563f,-0.120018f,0.98614f,0.218237f,-0.145906f,0.964927f,0.221558f,-0.086713f,0.971284f,
0.061944f,-0.007387f,0.998052f,0.061979f,-0.026292f,0.997731f,0.113708f,-0.028673f,0.9931f,0.113635f,-0.008231f,0.993489f,
0.061979f,-0.026292f,0.997731f,0.062764f,-0.064559f,0.995938f,0.113981f,-0.068259f,0.991135f,0.113708f,-0.028673f,0.9931f,
0.113708f,-0.028673f,0.9931f,0.113981f,-0.068259f,0.991135f,0.221558f,-0.086713f,0.971284f,0.222823f,-0.037022f,0.974156f,
0.113635f,-0.008231f,0.993489f,0.113708f,-0.028673f,0.9931f,0.222823f,-0.037022f,0.974156f,0.223053f,-0.010715f,0.974747f,
0.00717f,0.007027f,0.99995f,0.007189f,0.0f,0.999974f,0.025542f,0.0f,0.999674f,0.025482f,0.007044f,0.999651f,
0.007189f,0.0f,0.999974f,0.007169f,-0.00707f,0.999949f,0.025479f,-0.007087f,0.99965f,0.025542f,0.0f,0.999674f,
0.025542f,0.0f,0.999674f,0.025479f,-0.007087f,0.99965f,0.061944f,-0.007387f,0.998052f,0.061996f,0.0f,0.998076f,
0.025482f,0.007044f,0.999651f,0.025542f,0.0f,0.999674f,0.061996f,0.0f,0.998076f,0.061948f,0.007344f,0.998052f,
0.061944f,-0.007387f,0.998052f,0.113635f,-0.008231f,0.993489f,0.11363f,0.0f,0.993523f,0.061996f,0.0f,0.998076f,
0.113635f,-0.008231f,0.993489f,0.223053f,-0.010715f,0.974747f,0.222967f,-1.0E-6f,0.974826f,0.11363f,0.0f,0.993523f,
0.11363f,0.0f,0.993523f,0.222967f,-1.0E-6f,0.974826f,0.223051f,0.010649f,0.974749f,0.113637f,0.008184f,0.993489f,
0.061996f,0.0f,0.998076f,0.11363f,0.0f,0.993523f,0.113637f,0.008184f,0.993489f,0.061948f,0.007344f,0.998052f,
-0.693736f,0.024972f,0.719796f,-0.565768f,0.020427f,0.824311f,-0.560511f,0.071322f,0.82507f,-0.681667f,0.087549f,0.726406f,
-0.560511f,0.071322f,0.82507f,-0.565768f,0.020427f,0.824311f,-0.367245f,0.014528f,0.930011f,-0.365644f,0.050051f,0.929408f,
-0.53875f,0.167715f,0.825603f,-0.560511f,0.071322f,0.82507f,-0.365644f,0.050051f,0.929408f,-0.359059f,0.116722f,0.925987f,
-0.681667f,0.087549f,0.726406f,-0.560511f,0.071322f,0.82507f,-0.53875f,0.167715f,0.825603f,-0.644943f,0.202621f,0.736881f,
-0.367245f,0.014528f,0.930011f,-0.220997f,0.010655f,0.975216f,-0.220758f,0.036362f,0.974651f,-0.365644f,0.050051f,0.929408f,
-0.365644f,0.050051f,0.929408f,-0.220758f,0.036362f,0.974651f,-0.219543f,0.083629f,0.972012f,-0.359059f,0.116722f,0.925987f,
-0.53875f,0.167715f,0.825603f,-0.359059f,0.116722f,0.925987f,-0.34505f,0.199733f,0.917086f,-0.491757f,0.284219f,0.82304f,
-0.359059f,0.116722f,0.925987f,-0.219543f,0.083629f,0.972012f,-0.216564f,0.138788f,0.966353f,-0.34505f,0.199733f,0.917086f,
-0.34505f,0.199733f,0.917086f,-0.216564f,0.138788f,0.966353f,-0.211482f,0.213152f,0.953856f,-0.296456f,0.298724f,0.907126f,
-0.34505f,0.199733f,0.917086f,-0.296456f,0.298724f,0.907126f,-0.402197f,0.405178f,0.821017f,-0.491757f,0.284219f,0.82304f,
-0.644943f,0.202621f,0.736881f,-0.53875f,0.167715f,0.825603f,-0.491757f,0.284219f,0.82304f,-0.574618f,0.33479f,0.746813f,
-0.574618f,0.33479f,0.746813f,-0.491757f,0.284219f,0.82304f,-0.402197f,0.405178f,0.821017f,-0.466013f,0.469045f,0.75022f,
0.223051f,0.010649f,0.974749f,0.37035f,0.014508f,0.928779f,0.368745f,0.04998f,0.928186f,0.222811f,0.036337f,0.974184f,
0.368745f,0.04998f,0.928186f,0.37035f,0.014508f,0.928779f,0.569522f,0.020364f,0.821724f,0.564266f,0.071105f,0.822525f,
0.362133f,0.116561f,0.92481f,0.368745f,0.04998f,0.928186f,0.564266f,0.071105f,0.822525f,0.54249f,0.167243f,0.823246f,
0.222811f,0.036337f,0.974184f,0.368745f,0.04998f,0.928186f,0.362133f,0.116561f,0.92481f,0.221593f,0.083571f,0.971552f,
0.569522f,0.020364f,0.821724f,0.697248f,0.024864f,0.716398f,0.685209f,0.08722f,0.723105f,0.564266f,0.071105f,0.822525f,
0.564266f,0.071105f,0.822525f,0.685209f,0.08722f,0.723105f,0.648546f,0.20196f,0.733894f,0.54249f,0.167243f,0.823246f,
0.362133f,0.116561f,0.92481f,0.54249f,0.167243f,0.823246f,0.495412f,0.283564f,0.821071f,0.348093f,0.199473f,0.915992f,
0.54249f,0.167243f,0.823246f,0.648546f,0.20196f,0.733894f,0.578173f,0.334012f,0.744414f,0.495412f,0.283564f,0.821071f,
0.495412f,0.283564f,0.821071f,0.578173f,0.334012f,0.744414f,0.4693f,0.468325f,0.748619f,0.405489f,0.404531f,0.819716f,
0.495412f,0.283564f,0.821071f,0.405489f,0.404531f,0.819716f,0.299149f,0.298419f,0.906342f,0.348093f,0.199473f,0.915992f,
0.221593f,0.083571f,0.971552f,0.362133f,0.116561f,0.92481f,0.348093f,0.199473f,0.915992f,0.218621f,0.138683f,0.965905f,
0.218621f,0.138683f,0.965905f,0.348093f,0.199473f,0.915992f,0.299149f,0.298419f,0.906342f,0.213531f,0.212993f,0.953435f,
0.010878f,0.222561f,0.974858f,0.008351f,0.113056f,0.993554f,0.028645f,0.113157f,0.993164f,0.037001f,0.222307f,0.974274f,
0.008351f,0.113056f,0.993554f,0.007491f,0.061287f,0.998092f,0.026239f,0.061352f,0.997771f,0.028645f,0.113157f,0.993164f,
0.028645f,0.113157f,0.993164f,0.026239f,0.061352f,0.997771f,0.062873f,0.062197f,0.996082f,0.066588f,0.113508f,0.991303f,
0.037001f,0.222307f,0.974274f,0.028645f,0.113157f,0.993164f,0.066588f,0.113508f,0.991303f,0.084603f,0.221056f,0.971585f,
0.007491f,0.061287f,0.998092f,0.007187f,0.025058f,0.99966f,0.025494f,0.025072f,0.999361f,0.026239f,0.061352f,0.997771f,
0.007187f,0.025058f,0.99966f,0.00717f,0.007027f,0.99995f,0.025482f,0.007044f,0.999651f,0.025494f,0.025072f,0.999361f,
0.025494f,0.025072f,0.999361f,0.025482f,0.007044f,0.999651f,0.061948f,0.007344f,0.998052f,0.062015f,0.025807f,0.997742f,
0.026239f,0.061352f,0.997771f,0.025494f,0.025072f,0.999361f,0.062015f,0.025807f,0.997742f,0.062873f,0.062197f,0.996082f,
0.062873f,0.062197f,0.996082f,0.062015f,0.025807f,0.997742f,0.113738f,0.028159f,0.993112f,0.114097f,0.065833f,0.991286f,
0.062015f,0.025807f,0.997742f,0.061948f,0.007344f,0.998052f,0.113637f,0.008184f,0.993489f,0.113738f,0.028159f,0.993112f,
0.113738f,0.028159f,0.993112f,0.113637f,0.008184f,0.993489f,0.223051f,0.010649f,0.974749f,0.222811f,0.036337f,0.974184f,
0.114097f,0.065833f,0.991286f,0.113738f,0.028159f,0.993112f,0.222811f,0.036337f,0.974184f,0.221593f,0.083571f,0.971552f,
0.084603f,0.221056f,0.971585f,0.066588f,0.113508f,0.991303f,0.114794f,0.114134f,0.986811f,0.139597f,0.218066f,0.965898f,
0.066588f,0.113508f,0.991303f,0.062873f,0.062197f,0.996082f,0.114097f,0.065833f,0.991286f,0.114794f,0.114134f,0.986811f,
0.114794f,0.114134f,0.986811f,0.114097f,0.065833f,0.991286f,0.221593f,0.083571f,0.971552f,0.218621f,0.138683f,0.965905f,
0.139597f,0.218066f,0.965898f,0.114794f,0.114134f,0.986811f,0.218621f,0.138683f,0.965905f,0.213531f,0.212993f,0.953435f,
0.007491f,0.061287f,0.998092f,0.008351f,0.113056f,0.993554f,0.0f,0.113048f,0.99359f,0.0f,0.061335f,0.998117f,
0.008351f,0.113056f,0.993554f,0.010878f,0.222561f,0.974858f,0.0f,0.222477f,0.974938f,0.0f,0.113048f,0.99359f,
0.0f,0.113048f,0.99359f,0.0f,0.222477f,0.974938f,-0.010867f,0.22256f,0.974858f,-0.008343f,0.113057f,0.993554f,
0.0f,0.061335f,0.998117f,0.0f,0.113048f,0.99359f,-0.008343f,0.113057f,0.993554f,-0.007484f,0.061287f,0.998092f,
0.007491f,0.061287f,0.998092f,0.0f,0.061335f,0.998117f,0.0f,0.025116f,0.999685f,0.007187f,0.025058f,0.99966f,
0.0f,0.061335f,0.998117f,-0.007484f,0.061287f,0.998092f,-0.00718f,0.025059f,0.99966f,0.0f,0.025116f,0.999685f,
0.0f,0.025116f,0.999685f,-0.00718f,0.025059f,0.99966f,-0.007163f,0.007027f,0.99995f,0.0f,0.007045f,0.999975f,
0.007187f,0.025058f,0.99966f,0.0f,0.025116f,0.999685f,0.0f,0.007045f,0.999975f,0.00717f,0.007027f,0.99995f,
-0.220997f,0.010655f,0.975216f,-0.112675f,0.008187f,0.993598f,-0.112781f,0.02817f,0.993221f,-0.220758f,0.036362f,0.974651f,
-0.112675f,0.008187f,0.993598f,-0.061553f,0.007347f,0.998077f,-0.061625f,0.025816f,0.997765f,-0.112781f,0.02817f,0.993221f,
-0.112781f,0.02817f,0.993221f,-0.061625f,0.025816f,0.997765f,-0.062487f,0.062214f,0.996105f,-0.113147f,0.065858f,0.991393f,
-0.220758f,0.036362f,0.974651f,-0.112781f,0.02817f,0.993221f,-0.113147f,0.065858f,0.991393f,-0.219543f,0.083629f,0.972012f,
-0.061553f,0.007347f,0.998077f,-0.025398f,0.007046f,0.999653f,-0.025412f,0.025076f,0.999363f,-0.061625f,0.025816f,0.997765f,
-0.025398f,0.007046f,0.999653f,-0.007163f,0.007027f,0.99995f,-0.00718f,0.025059f,0.99966f,-0.025412f,0.025076f,0.999363f,
-0.025412f,0.025076f,0.999363f,-0.00718f,0.025059f,0.99966f,-0.007484f,0.061287f,0.998092f,-0.026157f,0.061358f,0.997773f,
-0.061625f,0.025816f,0.997765f,-0.025412f,0.025076f,0.999363f,-0.026157f,0.061358f,0.997773f,-0.062487f,0.062214f,0.996105f,
-0.062487f,0.062214f,0.996105f,-0.026157f,0.061358f,0.997773f,-0.028558f,0.113162f,0.993166f,-0.066192f,0.113526f,0.991328f,
-0.026157f,0.061358f,0.997773f,-0.007484f,0.061287f,0.998092f,-0.008343f,0.113057f,0.993554f,-0.028558f,0.113162f,0.993166f,
-0.028558f,0.113162f,0.993166f,-0.008343f,0.113057f,0.993554f,-0.010867f,0.22256f,0.974858f,-0.036885f,0.222305f,0.974279f,
-0.066192f,0.113526f,0.991328f,-0.028558f,0.113162f,0.993166f,-0.036885f,0.222305f,0.974279f,-0.084089f,0.221062f,0.971628f,
-0.219543f,0.083629f,0.972012f,-0.113147f,0.065858f,0.991393f,-0.113857f,0.11417f,0.986915f,-0.216564f,0.138788f,0.966353f,
-0.113147f,0.065858f,0.991393f,-0.062487f,0.062214f,0.996105f,-0.066192f,0.113526f,0.991328f,-0.113857f,0.11417f,0.986915f,
-0.113857f,0.11417f,0.986915f,-0.066192f,0.113526f,0.991328f,-0.084089f,0.221062f,0.971628f,-0.138447f,0.218126f,0.966051f,
-0.216564f,0.138788f,0.966353f,-0.113857f,0.11417f,0.986915f,-0.138447f,0.218126f,0.966051f,-0.211482f,0.213152f,0.953856f,
};
const float cfGameIconStrokeVtxs[] =
{
-0.376756459475,1.046143651009f,0.0f,
-0.512206375599f,1.039104461670f,0.0f,
-0.613150417805f,1.029256582260f,0.0f,
-0.688333272934f,1.016606807709f,0.0f,
-0.746499598026f,1.001162052155f,0.0f,
-0.796394228935f,0.982929229736,0.0f,
-0.839153468609,0.961680650711,0.0f,
-0.875913500786,0.93718868494,0.0f,
-0.907810747623,0.909225344658,0.0f,
-0.93598151207,0.877562940121,0.0f,
-0.960655272007,0.840993285179,0.0f,
-0.982061386108,0.79830801487,0.0f,
-1.00042927265,0.748299062252,0.0f,
-1.015988588333,0.689758002758,0.0f,
-1.028732180595,0.613717556,0.0f,
-1.038653135300,0.511210441589,0.0f,
-1.045744538307,0.373269081116,0.0f,
-1.049999356270,0.190926194191,0.0f,
-1.051417708397,-1.349482312799E-002,0.0f,
-1.049999356270,-0.217670500278,0.0f,
-1.04574441910,-0.399277359247,0.0f,
-1.038653135300,-0.535992026329,0.0f,
-1.028732180595,-0.636890649796,0.0f,
-1.015988588333,-0.711049556732,0.0f,
-1.00042927265,-0.767545044422,0.0f,
-0.982061386108,-0.815453350544,0.0f,
-0.960655212402,-0.856050789356,0.0f,
-0.93598151207,-0.890613555908,0.0f,
-0.907810747623,-0.920418143272,0.0f,
-0.875913500786,-0.946740865707,0.0f,
-0.839153468609,-0.969795942307,0.0f,
-0.796394228935,-0.989797830582,0.0f,
-0.746499598026,-1.006960868835,0.0f,
-0.688333272934,-1.021499633789,0.0f,
-0.613150477409,-1.033407211304,0.0f,
-0.512206375599,-1.042677521706,0.0f,
-0.376756429672,-1.049303770065,0.0f,
-0.19805586338,-1.053279519081,0.0f,
2.249561250210E-003,-1.054604768753,0.0f,
0.202514111996,-1.053279519081,0.0f,
0.381092041731,-1.049303770065,0.0f,
0.516337633133,-1.042677521706,0.0f,
0.617013633251,-1.033407211304,0.0f,
0.691882967949,-1.021499633789,0.0f,
0.749708354473,-1.006960868835,0.0f,
0.79925262928,-0.989797830582,0.0f,
0.841663658619,-0.969795942307,0.0f,
0.87808907032,-0.946740865707,0.0f,
0.909676492214,-0.920418143272,0.0f,
0.93757379055,-0.890613555908,0.0f,
0.962008118629,-0.856050789356,0.0f,
0.983206510544,-0.815453350544,0.0f,
1.001396179199,-0.767545044422,0.0f,
1.016804218292,-0.711049556732,0.0f,
1.029423952103,-0.636890649796,0.0f,
1.039248347282,-0.535992026329,0.0f,
1.046270728111,-0.399277359247,0.0f,
1.050484061241,-0.217670500278,0.0f,
1.051888465881,-1.349482685328E-002,0.0f,
1.050484061241,0.190926194191,0.0f,
1.046270728111,0.373269081116,0.0f,
1.039248347282,0.511210441589,0.0f,
1.029423952103,0.613717556,0.0f,
1.016804218292,0.689758002758,0.0f,
1.001396059990,0.748299002647,0.0f,
0.983206450939,0.79830801487,0.0f,
0.962008118629,0.840993225574,0.0f,
0.93757379055,0.877562940121,0.0f,
0.909676492214,0.909225344658,0.0f,
0.87808907032,0.93718868494,0.0f,
0.841663658619,0.961680650711,0.0f,
0.79925262928,0.982929229736,0.0f,
0.749708354473,1.001162052155,0.0f,
0.691882967949,1.016606807709,0.0f,
0.617013692856,1.029256582260,0.0f,
0.516337633133,1.039104580879,0.0f,
0.381092071533,1.046143770218,0.0f,
0.202514111996,1.050367355347,0.0f,
2.249561250210E-003,1.051775097847,0.0f,
-0.19805586338,1.050367236137,0.0f,
-0.376756459475,1.046143651009,0.0f
};
const unsigned int cuGameIconStrokeVtxCount = sizeof(cfGameIconStrokeVtxs) / (sizeof(float) * 3);
#endif

View File

@ -1,100 +0,0 @@
#include "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
f32 *m_posVtxs = (f32*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, vtxCount * Shader3D::cuVertexAttrSize);
f32 *m_texCoords = (f32*)memalign(GX2_VERTEX_BUFFER_ALIGNMENT, vtxCount * Shader3D::cuTexCoordAttrSize);
if(m_posVtxs)
{
int 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(int 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 = NULL;
//! main image vertexes
if(posVtxs)
{
free((void*)posVtxs);
posVtxs = NULL;
}
if(texCoords)
{
free((void*)texCoords);
texCoords = NULL;
}
}
void GridBackground::draw(CVideo *pVideo, const glm::mat4 & modelView)
{
//! first setup 2D GUI positions
f32 currScaleX = bgRepeat * scaleX * (f32)getWidth() * pVideo->getWidthScaleFactor();
f32 currScaleY = 1.0f;
f32 currScaleZ = bgRepeat * scaleZ * (f32)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);
}

View File

@ -1,30 +0,0 @@
#ifndef _GRID_BACKGROUND_H_
#define _GRID_BACKGROUND_H_
#include "GuiImage.h"
#include "video/shaders/Shader.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 draw(CVideo *pVideo, const glm::mat4 & modelView);
private:
glm::mat4 m_modelView;
glm::vec4 colorIntensity;
glm::vec4 alphaFadeOut;
float distanceFadeOut;
};
#endif // _GRID_BACKGROUND_H_

View File

@ -1,30 +0,0 @@
/****************************************************************************
* 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 "GuiElement.h"
#include "GuiImageData.h"
#include "GuiImage.h"
#include "GuiFrame.h"
#include "GuiController.h"
#include "GuiText.h"
#include "GuiSound.h"
#include "GuiButton.h"
#include "GuiTrigger.h"
#endif

View File

@ -1,290 +0,0 @@
/****************************************************************************
* 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 "GuiButton.h"
#include "GuiController.h"
/**
* Constructor for the GuiButton class.
*/
GuiButton::GuiButton(f32 w, f32 h)
{
width = w;
height = h;
image = NULL;
imageOver = NULL;
imageHold = NULL;
imageClick = NULL;
icon = NULL;
iconOver = NULL;
for(int i = 0; i < 4; i++)
{
label[i] = NULL;
labelOver[i] = NULL;
labelHold[i] = NULL;
labelClick[i] = NULL;
}
for(int 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, int n)
{
label[n] = txt;
if(txt) txt->setParent(this);
}
void GuiButton::setLabelOver(GuiText* txt, int n)
{
labelOver[n] = txt;
if(txt) txt->setParent(this);
}
void GuiButton::setLabelHold(GuiText* txt, int n)
{
labelHold[n] = txt;
if(txt) txt->setParent(this);
}
void GuiButton::setLabelClick(GuiText* txt, int 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, int idx)
{
if(idx >= 0 && idx < iMaxGuiTriggers)
{
trigger[idx] = t;
}
else
{
for(int 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(isStateSet(STATE_OVER | STATE_SELECTED | STATE_CLICKED | STATE_HELD) && imageOver)
imageOver->draw(v);
else if(image)
image->draw(v);
if(isStateSet(STATE_OVER | STATE_SELECTED | STATE_CLICKED | STATE_HELD) && iconOver)
iconOver->draw(v);
else if(icon)
icon->draw(v);
// draw text
for(int 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, c->chan) || isStateSet(STATE_HIDDEN, c->chan))
return;
else if(parentElement && (parentElement->isStateSet(STATE_DISABLED, c->chan) || parentElement->isStateSet(STATE_HIDDEN, c->chan)))
return;
if(selectable)
{
if(c->data.validPointer && this->isInside(c->data.x, c->data.y))
{
if(!isStateSet(STATE_OVER, c->chan))
{
setState(STATE_OVER, c->chan);
//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->chan))
{
this->clearState(STATE_OVER, c->chan);
pointedOff(this, c);
if(effectTarget == effectTargetOver && effectAmount == effectAmountOver)
{
// initiate effects (in reverse)
effects = effectsOver;
effectAmount = -effectAmountOver;
effectTarget = 100;
}
}
}
for(int i = 0; i < iMaxGuiTriggers; i++)
{
if(!trigger[i])
continue;
// button triggers
if(clickable)
{
bool isClicked = trigger[i]->clicked(c);
if( !clickedTrigger && isClicked
&& (trigger[i]->isClickEverywhere() || (isStateSet(STATE_SELECTED | STATE_OVER, c->chan) && trigger[i]->isSelectionClickEverywhere()) || this->isInside(c->data.x, c->data.y)))
{
if(soundClick)
soundClick->Play();
clickedTrigger = trigger[i];
if(!isStateSet(STATE_CLICKED, c->chan))
setState(STATE_CLICKED, c->chan);
clicked(this, c, trigger[i]);
}
else if(isStateSet(STATE_CLICKED, c->chan) && (clickedTrigger == trigger[i]) && !isStateSet(STATE_HELD, c->chan) && !trigger[i]->held(c) && (!isClicked || trigger[i]->released(c)))
{
clickedTrigger = NULL;
clearState(STATE_CLICKED, c->chan);
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->chan) && trigger[i]->isSelectionClickEverywhere()) || this->isInside(c->data.x, c->data.y)))
{
heldTrigger = trigger[i];
if(!isStateSet(STATE_HELD, c->chan))
setState(STATE_HELD, c->chan);
held(this, c, trigger[i]);
}
else if(isStateSet(STATE_HELD, c->chan) && (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->chan);
}
heldTrigger = NULL;
clearState(STATE_HELD, c->chan);
released(this, c, trigger[i]);
}
}
}
}

View File

@ -1,117 +0,0 @@
/****************************************************************************
* 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 "GuiElement.h"
#include "GuiText.h"
#include "GuiController.h"
#include "GuiImage.h"
#include "GuiSound.h"
#include "GuiTrigger.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(f32 w, f32 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, int 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, int 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, int 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, int 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, int idx = -1);
//!
void resetState(void);
//!Constantly called to draw the GuiButton
void draw(CVideo *video);
//!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 int iMaxGuiTriggers = 7;
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

View File

@ -1,63 +0,0 @@
/****************************************************************************
* 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 "GuiCheckBox.h"
#include "GuiImage.h"
#include "GuiImageData.h"
/**
* Constructor for the GuiCheckBox class.
*/
GuiCheckBox::GuiCheckBox(bool checked)
: GuiToggle(checked,50,50)
,checkbox_imgdata(Resources::GetImageData("checkbox.png"))
,checkbox_img(checkbox_imgdata)
,checkbox_selected_imgdata(Resources::GetImageData("checkbox_selected.png"))
,checkbox_selected_img(checkbox_selected_imgdata)
,highlighted_imgdata(Resources::GetImageData("checkbox_highlighted.png"))
,highlighted_img(highlighted_imgdata)
{
checkbox_selected_img.setScale(height/checkbox_selected_img.getHeight());
checkbox_img.setScale(height/checkbox_img.getHeight());
highlighted_img.setScale(height/highlighted_img.getHeight());
setImage(&checkbox_img);
setIconOver(&highlighted_img);
}
/**
* Destructor for the GuiButton class.
*/
GuiCheckBox::~GuiCheckBox()
{
Resources::RemoveImageData(checkbox_imgdata);
Resources::RemoveImageData(checkbox_selected_imgdata);
Resources::RemoveImageData(highlighted_imgdata);
}
void GuiCheckBox::update(GuiController * c){
if(bChanged){
if(selected){
GuiButton::setImage(&checkbox_selected_img);
}else{
GuiButton::setImage(&checkbox_img);
}
bChanged = false;
}
GuiToggle::update(c);
}

View File

@ -1,47 +0,0 @@
/****************************************************************************
* 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_CHECKBOX_H_
#define GUI_CHECKBOX_H_
#include "GuiToggle.h"
#include "GuiImage.h"
#include "GuiImageData.h"
//!A simple CheckBox
class GuiCheckBox : public GuiToggle
{
public:
//!Constructor
//!\param checked Checked
GuiCheckBox(bool checked);
//!Destructor
virtual ~GuiCheckBox();
protected:
GuiImageData * checkbox_imgdata;
GuiImage checkbox_img;
GuiImageData * checkbox_selected_imgdata;
GuiImage checkbox_selected_img;
GuiImageData * highlighted_imgdata;
GuiImage highlighted_img;
void update(GuiController * c);
};
#endif

View File

@ -1,78 +0,0 @@
/****************************************************************************
* 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 <string.h>
#include "GuiTrigger.h"
class GuiController
{
public:
//!Constructor
GuiController(int 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(int width, int height) = 0;
typedef struct
{
unsigned int buttons_h;
unsigned int buttons_d;
unsigned int buttons_r;
bool validPointer;
bool touched;
float pointerAngle;
int x;
int y;
} PadData;
int chan;
int chanIdx;
PadData data;
PadData lastData;
};
#endif

View File

@ -1,82 +0,0 @@
/****************************************************************************
* 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 "GuiDragListener.h"
#include "GuiController.h"
#include "utils/logger.h"
/**
* Constructor for the GuiDragListener class.
*/
GuiDragListener::GuiDragListener(f32 w,f32 h){
width = w;
height = h;
for(int i = 0; i < iMaxGuiTriggers; i++)
{
trigger[i] = NULL;
}
}
/**
* Destructor for the GuiDragListener class.
*/
GuiDragListener::~GuiDragListener(){
}
void GuiDragListener::setTrigger(GuiTrigger * t, int idx){
if(idx >= 0 && idx < iMaxGuiTriggers)
{
trigger[idx] = t;
}
else
{
for(int 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->chan))
return;
else if(parentElement && (parentElement->isStateSet(STATE_DISABLED|STATE_HIDDEN|STATE_DISABLE_INPUT, c->chan)))
return;
for(int 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)){
int dx = c->data.x - c->lastData.x;
int dy = c->data.y - c->lastData.y;
if(dx == 0 && dy == 0) continue;
dragged(this, c, trigger[i],dx,dy);
}
}
}

View File

@ -1,50 +0,0 @@
/****************************************************************************
* 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 "GuiElement.h"
#include "GuiController.h"
#include "GuiTrigger.h"
#include "GuiButton.h"
class GuiDragListener : public GuiElement
{
public:
//!Constructor
//!\param w Width
//!\param h Height
GuiDragListener(f32 w,f32 h);
//!Destructor
virtual ~GuiDragListener();
//!Set a new GuiTrigger for the element
//!\param i Index of trigger array to set
//!\param t Pointer to GuiTrigger
void setTrigger(GuiTrigger * t, int 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 *,int,int> dragged;
protected:
static const int iMaxGuiTriggers = 10;
GuiTrigger * trigger[iMaxGuiTriggers]; //!< GuiTriggers (input actions) that this element responds to
};
#endif

View File

@ -1,342 +0,0 @@
/****************************************************************************
* 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 "GuiElement.h"
//! TODO remove this!
static int screenwidth = 1280;
static int 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(int i = 0; i < 4; i++)
state[i] = STATE_DEFAULT;
stateChan = -1;
parentElement = NULL;
rumble = true;
selectable = false;
clickable = false;
holdable = 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.
*/
f32 GuiElement::getLeft()
{
f32 pWidth = 0;
f32 pLeft = 0;
f32 pScaleX = 1.0f;
if(parentElement)
{
pWidth = parentElement->getWidth();
pLeft = parentElement->getLeft();
pScaleX = parentElement->getScaleX();
}
pLeft += xoffsetDyn;
f32 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.
*/
f32 GuiElement::getTop()
{
f32 pHeight = 0;
f32 pTop = 0;
f32 pScaleY = 1.0f;
if(parentElement)
{
pHeight = parentElement->getHeight();
pTop = parentElement->getTop();
pScaleY = parentElement->getScaleY();
}
pTop += yoffsetDyn;
f32 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 - height * 0.5f * getScaleY();
}
else if(alignment & ALIGN_BOTTOM)
{
y = pTop + pHeight * pScaleY - height * getScaleY();
}
return y + yoffset;
}
void GuiElement::setEffect(int eff, int amount, int target)
{
if(eff & EFFECT_SLIDE_IN)
{
// these calculations overcompensate a little
if(eff & EFFECT_SLIDE_TOP)
{
if(eff & EFFECT_SLIDE_FROM)
yoffsetDyn = (int) -getHeight()*scaleY;
else
yoffsetDyn = -screenheight;
}
else if(eff & EFFECT_SLIDE_LEFT)
{
if(eff & EFFECT_SLIDE_FROM)
xoffsetDyn = (int) -getWidth()*scaleX;
else
xoffsetDyn = -screenwidth;
}
else if(eff & EFFECT_SLIDE_BOTTOM)
{
if(eff & EFFECT_SLIDE_FROM)
yoffsetDyn = (int) getHeight()*scaleY;
else
yoffsetDyn = screenheight;
}
else if(eff & EFFECT_SLIDE_RIGHT)
{
if(eff & EFFECT_SLIDE_FROM)
xoffsetDyn = (int) 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(int e, int a, int 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);
}
}
}

View File

@ -1,528 +0,0 @@
/****************************************************************************
* 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <wchar.h>
#include <math.h>
#include "common/types.h"
#include "sigslot.h"
#include "glm/glm.hpp"
#include "glm/gtc/matrix_transform.hpp"
#include "resources/Resources.h"
#include "system/AsyncDeleter.h"
#include "utils/logger.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 AsyncDeleter::Element
{
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 f32 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 f32 getTop();
//!Gets the current Z coordinate of the element
//!\return Z coordinate
virtual f32 getDepth()
{
f32 zParent = 0.0f;
if(parentElement)
zParent = parentElement->getDepth();
return zParent+zoffset;
}
virtual f32 getCenterX(void)
{
f32 pCenterX = 0.0f;
if(parentElement)
pCenterX = parentElement->getCenterX();
pCenterX += xoffset + xoffsetDyn;
if(alignment & ALIGN_LEFT)
{
f32 pWidth = 0.0f;
f32 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)
{
f32 pWidth = 0.0f;
f32 pScale = 0.0f;
if(parentElement)
{
pWidth = parentElement->getWidth();
pScale = parentElement->getScaleX();
}
pCenterX += pWidth * 0.5f * pScale - width * 0.5f * getScaleX();
}
return pCenterX;
}
virtual f32 getCenterY(void)
{
f32 pCenterY = 0.0f;
if(parentElement)
pCenterY = parentElement->getCenterY();
pCenterY += yoffset + yoffsetDyn;
if(alignment & ALIGN_TOP)
{
f32 pHeight = 0.0f;
f32 pScale = 0.0f;
if(parentElement)
{
pHeight = parentElement->getHeight();
pScale = parentElement->getScaleY();
}
pCenterY += pHeight * 0.5f * pScale - height * 0.5f * getScaleY();
}
else if(alignment & ALIGN_BOTTOM)
{
f32 pHeight = 0.0f;
f32 pScale = 0.0f;
if(parentElement)
{
pHeight = parentElement->getHeight();
pScale = parentElement->getScaleY();
}
pCenterY -= pHeight * 0.5f * pScale - height * 0.5f * getScaleY();
}
return pCenterY;
}
//!Gets elements xoffset
virtual f32 getOffsetX() { return xoffset; }
//!Gets elements yoffset
virtual f32 getOffsetY() { return yoffset; }
//!Gets the current width of the element. Does not currently consider the scale
//!\return width
virtual f32 getWidth() { return width; };
//!Gets the height of the element. Does not currently consider the scale
//!\return height
virtual f32 getHeight() { return height; }
//!Sets the size (width/height) of the element
//!\param w Width of element
//!\param h Height of element
virtual void setSize(f32 w, f32 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(int s, int c = -1)
{
if(c >= 0 && c < 4)
{
state[c] |= s;
}
else
{
for(int i = 0; i < 4; i++)
state[i] |= s;
}
stateChan = c;
stateChanged(this, s, c);
}
virtual void clearState(int s, int c = -1)
{
if(c >= 0 && c < 4)
{
state[c] &= ~s;
}
else
{
for(int i = 0; i < 4; i++)
state[i] &= ~s;
}
stateChan = c;
stateChanged(this, s, c);
}
virtual bool isStateSet(int s, int c = -1) const
{
if(c >= 0 && c < 4)
{
return (state[c] & s) != 0;
}
else
{
for(int i = 0; i < 4; i++)
if((state[i] & s) != 0)
return true;
return false;
}
}
//!Gets the element's current state
//!\return state
virtual int getState(int 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 int getStateChan() { return stateChan; };
//!Resets the element's state to STATE_DEFAULT
virtual void resetState()
{
for(int i = 0; i < 4; i++)
state[i] = STATE_DEFAULT;
stateChan = -1;
}
//!Sets the element's alpha value
//!\param a alpha value
virtual void setAlpha(f32 a) { alpha = a; }
//!Gets the element's alpha value
//!Considers alpha, alphaDyn, and the parent element's getAlpha() value
//!\return alpha
virtual f32 getAlpha()
{
f32 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(int e, int a, int 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(int e, int a, int 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 int 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(f32 x, f32 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(f32 x, f32 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(f32 x, f32 y, f32 z)
{
xoffset = x;
yoffset = y;
zoffset = z;
}
//!Gets whether or not the element is in STATE_SELECTED
//!\return true if selected, false otherwise
virtual int 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(int a) { alignment = a; }
//!Gets the element's alignment
virtual int getAlignment() const { return alignment; }
//!Angle of the object
virtual void setAngle(f32 a) { angle = a; }
//!Angle of the object
virtual f32 getAngle() const { f32 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 {
s32 x;
s32 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 *, int, int> stateChanged;
sigslot::signal1<GuiElement *> effectFinished;
protected:
f32 xoffset; //!< Element X offset
f32 yoffset; //!< Element Y offset
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)
f32 width; //!< Element width
f32 height; //!< Element height
f32 zoffset; //!< Element Z offset
f32 alpha; //!< Element alpha value (0-255)
f32 angle; //!< Angle of the object (0-360)
f32 scaleX; //!< Element scale (1 = 100%)
f32 scaleY; //!< Element scale (1 = 100%)
f32 scaleZ; //!< Element scale (1 = 100%)
int alignment; //!< Horizontal element alignment, respective to parent element
int state[4]; //!< Element state (DEFAULT, SELECTED, CLICKED, DISABLED)
int stateChan; //!< Which controller channel is responsible for the last change in state
GuiElement * parentElement; //!< Parent element
//! TODO: Move me to some Animator class
int xoffsetDyn; //!< Element X offset, dynamic (added to xoffset value for animation effects)
int yoffsetDyn; //!< Element Y offset, dynamic (added to yoffset value for animation effects)
f32 alphaDyn; //!< Element alpha, dynamic (multiplied by alpha value for blending/fading effects)
f32 scaleDyn; //!< Element scale, dynamic (multiplied by alpha value for blending/fading effects)
int effects; //!< Currently enabled effect(s). 0 when no effects are enabled
int effectAmount; //!< Effect amount. Used by different effects for different purposes
int effectTarget; //!< Effect target amount. Used by different effects for different purposes
int effectsOver; //!< Effects to enable when wiimote cursor is over this element. Copied to effects variable on over event
int effectAmountOver; //!< EffectAmount to set when wiimote cursor is over this element
int effectTargetOver; //!< EffectTarget to set when wiimote cursor is over this element
};
#endif

View File

@ -1,267 +0,0 @@
/****************************************************************************
* 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 "GuiFrame.h"
GuiFrame::GuiFrame(GuiFrame *p)
{
parent = p;
width = 0;
height = 0;
dim = false;
if(parent)
parent->append(this);
}
GuiFrame::GuiFrame(f32 w, f32 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;
e->setParent(this);
ListChangeElement elem;
elem.addElement = true;
elem.position = -1;
elem.element = e;
queueMutex.lock();
listChangeQueue.push(elem);
queueMutex.unlock();
}
void GuiFrame::insert(GuiElement* e, u32 index)
{
if (e == NULL || (index >= elements.size()))
return;
e->setParent(this);
ListChangeElement elem;
elem.addElement = true;
elem.position = index;
elem.element = e;
queueMutex.lock();
listChangeQueue.push(elem);
queueMutex.unlock();
}
void GuiFrame::remove(GuiElement* e)
{
if (e == NULL)
return;
ListChangeElement elem;
elem.addElement = false;
elem.position = -1;
elem.element = e;
queueMutex.lock();
listChangeQueue.push(elem);
queueMutex.unlock();
}
void GuiFrame::removeAll()
{
elements.clear();
}
void GuiFrame::close()
{
//Application::instance()->pushForDelete(this);
}
void GuiFrame::dimBackground(bool d)
{
dim = d;
}
GuiElement* GuiFrame::getGuiElementAt(u32 index) const
{
if (index >= elements.size())
return NULL;
return elements[index];
}
u32 GuiFrame::getSize()
{
return elements.size();
}
void GuiFrame::resetState()
{
GuiElement::resetState();
for (u32 i = 0; i < elements.size(); ++i)
{
elements[i]->resetState();
}
}
void GuiFrame::setState(int s, int c)
{
GuiElement::setState(s, c);
for (u32 i = 0; i < elements.size(); ++i)
{
elements[i]->setState(s, c);
}
}
void GuiFrame::clearState(int s, int c)
{
GuiElement::clearState(s, c);
for (u32 i = 0; i < elements.size(); ++i)
{
elements[i]->clearState(s, c);
}
}
void GuiFrame::setVisible(bool v)
{
visible = v;
for (u32 i = 0; i < elements.size(); ++i)
{
elements[i]->setVisible(v);
}
}
int GuiFrame::getSelected()
{
// find selected element
int found = -1;
for (u32 i = 0; i < elements.size(); ++i)
{
if(elements[i]->isStateSet(STATE_SELECTED | STATE_OVER))
{
found = i;
break;
}
}
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);
}
//! render appended items next frame but allow stop of render if size is reached
u32 size = elements.size();
for (u32 i = 0; i < size && i < elements.size(); ++i)
{
elements[i]->draw(v);
}
}
void GuiFrame::updateEffects()
{
if(this->isVisible() || parentElement)
{
GuiElement::updateEffects();
//! render appended items next frame but allow stop of render if size is reached
u32 size = elements.size();
for (u32 i = 0; i < size && i < elements.size(); ++i)
{
elements[i]->updateEffects();
}
}
//! at the end of main loop which this function represents append pending elements
updateElementList();
}
void GuiFrame::update(GuiController * c)
{
if(isStateSet(STATE_DISABLED) && parentElement)
return;
//! update appended items next frame
u32 size = elements.size();
for (u32 i = 0; i < size && i < elements.size(); ++i)
{
elements[i]->update(c);
}
}
void GuiFrame::updateElementList(void)
{
if(listChangeQueue.empty() == false)
{
queueMutex.lock();
while(!listChangeQueue.empty())
{
ListChangeElement & listChange = listChangeQueue.front();
for (u32 i = 0; i < elements.size(); ++i)
{
if(listChange.element == elements[i])
{
elements.erase(elements.begin()+i);
break;
}
}
if(listChange.addElement)
{
if(listChange.position >= 0)
{
elements.insert(elements.begin()+listChange.position, listChange.element);
}
else
{
elements.push_back(listChange.element);
}
}
listChangeQueue.pop();
}
queueMutex.unlock();
}
}

View File

@ -1,107 +0,0 @@
/****************************************************************************
* 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 <vector>
#include "GuiElement.h"
#include "sigslot.h"
//!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(f32 w, f32 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, u32 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(u32 index) const;
//!Returns the size of the list of elements
//!\return The size of the current element list
u32 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(int s, int c = -1);
void clearState(int s, int c = -1);
//!Gets the index of the GuiElement inside the window that is currently selected
//!\return index of selected GuiElement
int getSelected();
//!Dim the Window's background
void dimBackground(bool d);
//!Draws all the elements in this GuiFrame
void draw(CVideo * v);
//!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();
//! 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
void updateElementList(void);
struct ListChangeElement
{
bool addElement;
int position;
GuiElement *element;
};
std::queue<ListChangeElement> listChangeQueue;
CMutex queueMutex;
};
#endif

View File

@ -1,289 +0,0 @@
/****************************************************************************
* 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 "GuiImage.h"
#include "video/CVideo.h"
#include "video/shaders/Texture2DShader.h"
#include "video/shaders/ColorShader.h"
static const f32 fPiDiv180 = ((f32)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(int w, int h, const GX2Color & c, int type)
{
internalInit(w, h);
imgType = type;
colorCount = ColorShader::cuColorVtxsSize / ColorShader::cuColorAttrSize;
colorVtxs = (u8 *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, colorCount * ColorShader::cuColorAttrSize);
if(colorVtxs)
{
for(u32 i = 0; i < colorCount; i++)
setImageColor(c, i);
}
}
GuiImage::GuiImage(int w, int h, const GX2Color *c, u32 color_count, int type)
{
internalInit(w, h);
imgType = type;
colorCount = ColorShader::cuColorVtxsSize / ColorShader::cuColorAttrSize;
if(colorCount < color_count)
colorCount = color_count;
colorVtxs = (u8 *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, colorCount * ColorShader::cuColorAttrSize);
if(colorVtxs)
{
for(u32 i = 0; i < colorCount; i++)
{
// take the last as reference if not enough colors defined
int 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(int w, int 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(int x, int y)
{
if(!imageData || this->getWidth() <= 0 || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight())
return (GX2Color){0, 0, 0, 0};
u32 pitch = imageData->getTexture()->surface.pitch;
u32 *imagePtr = (u32*)imageData->getTexture()->surface.image;
u32 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(int x, int y, const GX2Color & color)
{
if(!imageData || this->getWidth() <= 0 || x < 0 || y < 0 || x >= this->getWidth() || y >= this->getHeight())
return;
u32 pitch = imageData->getTexture()->surface.pitch;
u32 *imagePtr = (u32*)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, int idx)
{
if(!colorVtxs) {
return;
}
if(idx >= 0 && idx < (int)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(u32 i = 0; i < (ColorShader::cuColorVtxsSize / sizeof(u8)); 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(int w, int h)
{
width = w;
height = h;
}
void GuiImage::setPrimitiveVertex(s32 prim, const f32 *posVtx, const f32 *texCoord, u32 vtxcount)
{
primitive = prim;
vtxCount = vtxcount;
posVtxs = posVtx;
texCoords = texCoord;
if(imgType == IMAGE_COLOR)
{
u8 * newColorVtxs = (u8 *) memalign(0x40, ColorShader::cuColorAttrSize * vtxCount);
for(u32 i = 0; i < vtxCount; i++)
{
int newColorIdx = (i << 2);
int 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;
f32 currScaleX = getScaleX();
f32 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(int n=0; n<tileVertical; n++)
// for(int 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(int i=0; i<tileHorizontal; i++)
// {
// int 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(int 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);
}
}

View File

@ -1,110 +0,0 @@
/****************************************************************************
* 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 "video/shaders/Shader.h"
#include "GuiElement.h"
#include "GuiImageData.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
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(int w, int h, const GX2Color & c, int imgType = IMAGE_COLOR);
GuiImage(int w, int h, const GX2Color * c, u32 colorCount = 1, int imgType = IMAGE_COLOR);
//!Destructor
virtual ~GuiImage();
//!Sets the number of times to draw the image horizontally
//!\param t Number of times to draw the image
void setTileHorizontal(int t) { tileHorizontal = t; }
//!Sets the number of times to draw the image vertically
//!\param t Number of times to draw the image
void setTileVertical(int t) { tileVertical = t; }
//!Constantly called to draw the image
void draw(CVideo *pVideo);
//!Gets the image data
//!\return pointer to image data
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(int x, int 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(int x, int y, const GX2Color & color);
//!Change ImageColor
void setImageColor(const GX2Color & c, int idx = -1);
//!Change ImageColor
void setSize(int w, int h);
void setPrimitiveVertex(s32 prim, const f32 *pos, const f32 *tex, u32 count);
void setBlurDirection(u8 dir, f32 value)
{
if(dir < 2) {
blurDirection[dir] = value;
}
}
void setColorIntensity(const glm::vec4 & col)
{
colorIntensity = col;
}
protected:
void internalInit(int w, int h);
int imgType; //!< Type of image data (IMAGE_TEXTURE, IMAGE_COLOR, IMAGE_DATA)
GuiImageData * imageData; //!< Poiner to image data. May be shared with GuiImageData data
int tileHorizontal; //!< Number of times to draw (tile) the image horizontally
int tileVertical; //!< Number of times to draw (tile) the image vertically
//! Internally used variables for rendering
u8 *colorVtxs;
u32 colorCount;
bool colorVtxsDirty;
glm::vec3 positionOffsets;
glm::vec3 scaleFactor;
glm::vec4 colorIntensity;
f32 imageAngle;
glm::vec3 blurDirection;
const f32 * posVtxs;
const f32 * texCoords;
u32 vtxCount;
s32 primitive;
};
#endif

View File

@ -1,172 +0,0 @@
/****************************************************************************
* 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 <unistd.h>
#include "GuiImageAsync.h"
#include "fs/fs_utils.h"
std::vector<GuiImageAsync *> GuiImageAsync::imageQueue;
CThread * GuiImageAsync::pThread = NULL;
CMutex * GuiImageAsync::pMutex = NULL;
u32 GuiImageAsync::threadRefCounter = 0;
bool GuiImageAsync::bExitRequested = false;
GuiImageAsync * GuiImageAsync::pInUse = NULL;
GuiImageAsync::GuiImageAsync(const u8 *imageBuffer, const u32 & 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)
usleep(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(u32 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
{
u8 *buffer = NULL;
u32 bufferSize = 0;
int iResult = LoadFileToMem(pInUse->filename.c_str(), &buffer, &bufferSize);
if(iResult > 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 = NULL;
}
}
}
void GuiImageAsync::threadInit()
{
if (pThread == NULL)
{
bExitRequested = false;
pMutex = new CMutex();
pThread = CThread::create(GuiImageAsync::guiImageAsyncThread, NULL, CThread::eAttributeAffCore1 | CThread::eAttributePinnedAff, 10);
pThread->resumeThread();
}
++threadRefCounter;
}
void GuiImageAsync::threadExit()
{
--threadRefCounter;
if((threadRefCounter == 0) && (pThread != NULL))
{
bExitRequested = true;
delete pThread;
delete pMutex;
pThread = NULL;
pMutex = NULL;
}
}

View File

@ -1,57 +0,0 @@
/****************************************************************************
* 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 <vector>
#include "GuiImage.h"
#include "system/CThread.h"
#include "system/CMutex.h"
class GuiImageAsync : public GuiImage
{
public:
GuiImageAsync(const u8 *imageBuffer, const u32 & imageBufferSize, GuiImageData * preloadImg);
GuiImageAsync(const std::string & filename, GuiImageData * preloadImg);
virtual ~GuiImageAsync();
static void clearQueue();
static void removeFromQueue(GuiImageAsync * image) {
threadRemoveImage(image);
}
private:
static void threadInit();
static void threadExit();
GuiImageData *imgData;
std::string filename;
const u8 *imgBuffer;
const u32 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 CMutex * pMutex;
static u32 threadRefCounter;
static GuiImageAsync * pInUse;
static bool bExitRequested;
};
#endif /*_GUIIMAGEASYNC_H_*/

View File

@ -1,209 +0,0 @@
/****************************************************************************
* 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 <malloc.h>
#include <string.h>
#include "GuiImageData.h"
#include "system/memory.h"
#include "video/CVideo.h"
#include "common/gx2_ext.h"
/**
* Constructor for the GuiImageData class.
*/
GuiImageData::GuiImageData()
{
texture = NULL;
sampler = NULL;
memoryType = eMemTypeMEM2;
}
/**
* Constructor for the GuiImageData class.
*/
GuiImageData::GuiImageData(const u8 * img, int 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 u8 *img, int 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, (u8*) img);
}
else if (img[0] == 'B' && img[1] == 'M')
{
// IMAGE_BMP
//gdImg = gdImageCreateFromBmpPtr(imgSize, (u8*) img);
}
else if (img[0] == 0x89 && img[1] == 'P' && img[2] == 'N' && img[3] == 'G')
{
// IMAGE_PNG
gdImg = gdImageCreateFromPngPtr(imgSize, (u8*) 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, (u8*) img);
}
if(gdImg == 0)
return;
u32 width = (gdImageSX(gdImg));
u32 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, (u32*)texture->surface.image, texture->surface.width, texture->surface.height, texture->surface.pitch);
break;
case GX2_SURFACE_FORMAT_UNORM_R5_G6_B5:
gdImageToUnormR5G6B5(gdImg, (u16*)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, u32 *imgBuffer, u32 width, u32 height, u32 pitch)
{
for(u32 y = 0; y < height; ++y)
{
for(u32 x = 0; x < width; ++x)
{
u32 pixel = gdImageGetPixel(gdImg, x, y);
u8 a = 254 - 2*((u8)gdImageAlpha(gdImg, pixel));
if(a == 254) a++;
u8 r = gdImageRed(gdImg, pixel);
u8 g = gdImageGreen(gdImg, pixel);
u8 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, u16 *imgBuffer, u32 width, u32 height, u32 pitch)
{
for(u32 y = 0; y < height; ++y)
{
for(u32 x = 0; x < width; ++x)
{
u32 pixel = gdImageGetPixel(gdImg, x, y);
u8 r = gdImageRed(gdImg, pixel);
u8 g = gdImageGreen(gdImg, pixel);
u8 b = gdImageBlue(gdImg, pixel);
imgBuffer[y * pitch + x] = ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);
}
}
}

View File

@ -1,68 +0,0 @@
/****************************************************************************
* 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 <gx2/enum.h>
#include <gx2/texture.h>
#include <gx2/sampler.h>
#include "system/AsyncDeleter.h"
class GuiImageData : public AsyncDeleter::Element
{
public:
//!Constructor
GuiImageData();
//!\param img Image data
//!\param imgSize The image size
GuiImageData(const u8 * img, int 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 u8 * img, int imgSize, GX2TexClampMode textureClamp = GX2_TEX_CLAMP_MODE_CLAMP, GX2SurfaceFormat textureFormat = GX2_SURFACE_FORMAT_UNORM_R8_G8_B8_A8);
//! getter functions
const GX2Texture * getTexture() const { return texture; };
const GX2Sampler * getSampler() const { return sampler; };
//!Gets the image width
//!\return image width
int getWidth() const { if(texture) return texture->surface.width; else return 0; };
//!Gets the image height
//!\return image height
int getHeight() const { if(texture) return texture->surface.height; else return 0; };
//! release memory of the image data
void releaseData(void);
private:
void gdImageToUnormR8G8B8A8(gdImagePtr gdImg, u32 *imgBuffer, u32 width, u32 height, u32 pitch);
void gdImageToUnormR5G6B5(gdImagePtr gdImg, u16 *imgBuffer, u32 width, u32 height, u32 pitch);
GX2Texture *texture;
GX2Sampler *sampler;
enum eMemoryTypes
{
eMemTypeMEM2,
eMemTypeMEM1,
eMemTypeMEMBucket
};
u8 memoryType;
};
#endif

View File

@ -17,8 +17,7 @@
#ifndef GUI_MAIN_WINDOW_SCREEN_H_ #ifndef GUI_MAIN_WINDOW_SCREEN_H_
#define GUI_MAIN_WINDOW_SCREEN_H_ #define GUI_MAIN_WINDOW_SCREEN_H_
#include "Gui.h" #include <gui/Gui.h>
#include "sigslot.h"
class GuiMainWindowScreen : public GuiFrame class GuiMainWindowScreen : public GuiFrame
{ {

View File

@ -1,128 +0,0 @@
/****************************************************************************
* 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 "GuiParticleImage.h"
#include "video/CVideo.h"
#include "video/shaders/ColorShader.h"
#define CIRCLE_VERTEX_COUNT 36
static inline f32 getRandZeroToOneF32()
{
return (rand() % 10000) * 0.0001f;
}
static inline f32 getRandMinusOneToOneF32()
{
return getRandZeroToOneF32() * 2.0f - 1.0f;
}
GuiParticleImage::GuiParticleImage(int w, int h, u32 particleCount)
: GuiImage(NULL)
{
width = w;
height = h;
imgType = IMAGE_COLOR;
posVertexs = (f32 *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ColorShader::cuVertexAttrSize * CIRCLE_VERTEX_COUNT);
colorVertexs = (u8 *) memalign(GX2_VERTEX_BUFFER_ALIGNMENT, ColorShader::cuColorAttrSize * CIRCLE_VERTEX_COUNT);
for(u32 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(u32 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() * 30.0f;
particles[i].speed = (getRandZeroToOneF32() * 0.6f) + 0.2f;
particles[i].direction = getRandMinusOneToOneF32();
}
}
GuiParticleImage::~GuiParticleImage()
{
free(posVertexs);
free(colorVertexs);
}
void GuiParticleImage::draw(CVideo *pVideo)
{
if(!this->isVisible())
return;
f32 currScaleX = getScaleX();
f32 currScaleY = getScaleY();
positionOffsets[2] = getDepth() * pVideo->getDepthScaleFactor() * 2.0f;
scaleFactor[2] = getScaleZ();
//! add other colors intensities parameters
colorIntensity[3] = getAlpha();
for(u32 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() * 30.0f;
particles[i].speed = (getRandZeroToOneF32() * 0.6f) + 0.2f;
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);
}
}

View File

@ -1,45 +0,0 @@
/****************************************************************************
* 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 "GuiImage.h"
class GuiParticleImage : public GuiImage, public sigslot::has_slots<>
{
public:
GuiParticleImage(int w, int h, u32 particleCount);
virtual ~GuiParticleImage();
void draw(CVideo *pVideo);
private:
f32 *posVertexs;
u8 *colorVertexs;
typedef struct
{
glm::vec3 position;
glm::vec4 colors;
f32 radius;
f32 speed;
f32 direction;
} Particle;
std::vector<Particle> particles;
};
#endif // _GUI_ICON_GRID_H_

View File

@ -1,303 +0,0 @@
/****************************************************************************
* 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 <vector>
#include <string>
#include "GuiSelectBox.h"
#include "GuiImage.h"
#include "GuiTrigger.h"
#include "GuiImageData.h"
#include "utils/StringTools.h"
/**
* Constructor for the GuiCheckBox class.
*/
GuiSelectBox::GuiSelectBox(std::string caption,GuiFrame *parent)
: GuiFrame(300,300,parent)
,selected(0)
,captionText(caption)
,topValueImageData(Resources::GetImageData("gameSettingsButton.png"))
,topValueImage(topValueImageData)
,topValueImageSelectedData(Resources::GetImageData("gameSettingsButtonSelected.png"))
,topValueImageSelected(topValueImageSelectedData)
,topValueButton(topValueImage.getWidth(),topValueImage.getHeight())
,valueImageData(Resources::GetImageData("gameSettingsButtonEx.png"))
,valueSelectedImageData(Resources::GetImageData("gameSettingsButtonExSelected.png"))
,valueHighlightedImageData(Resources::GetImageData("gameSettingsButtonExHighlighted.png"))
,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(5,5)
,buttonClickSound(Resources::GetSound("settings_click_2.mp3"))
{
showValues = false;
bChanged = false;
bSelectedChanged = false;
opened = false;
topValueText.setFontSize(32);
topValueText.setAlignment(ALIGN_LEFT);
topValueText.setPosition(10,-7);
topValueButton.setLabel(&topValueText);
topValueButton.setImage(&topValueImage);
topValueButton.setIconOver(&topValueImageSelected);
topValueButton.setTrigger(&touchTrigger);
topValueButton.setTrigger(&wpadTouchTrigger);
topValueButton.setSoundClick(buttonClickSound);
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::OnValueClicked(GuiButton *button, const GuiController *controller, GuiTrigger *trigger)
{
for(u32 i = 0; i < valueButtons.size(); ++i){
if(valueButtons[i].valueButton == button){
selected = i;
SelectValue(i);
break;
}
}
}
void GuiSelectBox::SelectValue(u32 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(getCaptionWithValue(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);
}
}
std::string GuiSelectBox::getCaptionWithValue(std::string value){
u32 pad = (38 - captionText.size() -2);
if(pad > value.size())
value.insert(0, pad - value.size(), ' ');
return strfmt("%s: %s",captionText.c_str(),value.c_str());
}
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, int valueID)
{
if((u32)valueID >= values.size()){
valueID = 0;
}
selected = valueID;
bSelectedChanged = true;
DeleteValueData();
valueButtons.resize(values.size());
int i = 0;
f32 imgScale = 1.0f;
std::map<std::string, std::string>::iterator itr;
for(itr = values.begin(); itr != values.end(); itr++) {
if(i == valueID){
topValueText.setText(getCaptionWithValue(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;
valueButtons[i].valueButton->setPosition(0, (((valueButtons[i].valueButtonImg->getHeight()*getScale()) * (i))+ (topValueImage.getHeight()-5)*getScale())*-1.0f);
valuesFrame.append(valueButtons[i].valueButton);
i++;
}
//Collapse the thing!
showValues = false;
bChanged = true;
}
void GuiSelectBox::DeleteValueData()
{
for(u32 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;
Resources::RemoveSound(buttonClickSound);
Resources::RemoveImageData(topValueImageData);
Resources::RemoveImageData(topValueImageSelectedData);
Resources::RemoveImageData(valueImageData);
Resources::RemoveImageData(valueHighlightedImageData);
Resources::RemoveImageData(valueSelectedImageData);
}
void GuiSelectBox::setState(int s, int c)
{
GuiElement::setState(s, c);
}
void GuiSelectBox::OnValueCloseEffectFinish(GuiElement *element)
{
valuesFrame.effectFinished.disconnect(this);
}
f32 GuiSelectBox::getTopValueHeight() {
return topValueImage.getHeight();
}
f32 GuiSelectBox::getTopValueWidth() {
return topValueImage.getWidth();
}
void GuiSelectBox::OnValueOpenEffectFinish(GuiElement *element)
{
valuesFrame.effectFinished.disconnect(this);
opened = true;
}
void GuiSelectBox::update(GuiController * c){
if(bChanged){
showhide(this,showValues);
if(showValues){
for(u32 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(u32 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);
}

View File

@ -1,104 +0,0 @@
/****************************************************************************
* 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.h"
#include "GuiImage.h"
#include "GuiImageData.h"
//!A simple CheckBox
class GuiSelectBox : public GuiFrame, public sigslot::has_slots<>
{
public:
//!Constructor
//!\param checked Checked
GuiSelectBox(std::string caption,GuiFrame *parent = 0);
//!Destructor
virtual ~GuiSelectBox();
sigslot::signal2<GuiSelectBox *, std::string> valueChanged;
sigslot::signal2<GuiSelectBox *, bool> showhide;
void OnTopValueClicked(GuiButton *button, const GuiController *controller, GuiTrigger *trigger);
void Init(std::map<std::string,std::string> values, int valueID);
void setState(int s, int c = -1);
virtual f32 getTopValueHeight();
virtual f32 getTopValueWidth();
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(u32 value);
u32 selected;
bool bChanged;
bool bSelectedChanged;
bool showValues;
bool opened;
std::string captionText;
GuiFrame valuesFrame;
GuiImageData *topValueImageData;
GuiImage topValueImage;
GuiImageData *topValueImageSelectedData;
GuiImage topValueImageSelected;
GuiButton topValueButton;
GuiImageData * valueImageData;
GuiImageData * valueSelectedImageData;
GuiImageData * valueHighlightedImageData;
GuiText topValueText;
GuiTrigger touchTrigger;
GuiTrigger wpadTouchTrigger;
GuiTrigger buttonATrigger;
GuiTrigger buttonBTrigger;
GuiTrigger buttonLeftTrigger;
GuiTrigger buttonRightTrigger;
GuiTrigger buttonUpTrigger;
GuiTrigger buttonDownTrigger;
GuiButton DPADButtons;
GuiSound* buttonClickSound;
std::string getCaptionWithValue(std::string value);
typedef struct
{
GuiImage *valueButtonImg;
GuiImage *valueButtonCheckedImg;
GuiImage *valueButtonHighlightedImg;
GuiButton *valueButton;
GuiText *valueButtonText;
} SelectBoxValueButton;
std::map<GuiButton * ,std::string> buttonToValue;
std::vector<SelectBoxValueButton> valueButtons;
};
#endif

View File

@ -1,192 +0,0 @@
/****************************************************************************
* 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 "GuiSound.h"
#include "sounds/SoundHandler.hpp"
GuiSound::GuiSound(const char * filepath)
{
voice = -1;
Load(filepath);
}
GuiSound::GuiSound(const u8 * snd, s32 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(int 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 u8 * snd, s32 len)
{
if(voice >= 0)
{
SoundHandler::instance()->RemoveDecoder(voice);
voice = -1;
}
if(!snd)
return false;
//! find next free decoder
for(int 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)
usleep(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(u32 vol)
{
if(vol > 100)
vol = 100;
u32 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();
}

View File

@ -1,60 +0,0 @@
/****************************************************************************
* 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 "common/types.h"
#include "system/AsyncDeleter.h"
//!Sound conversion and playback. A wrapper for other sound libraries - ASND, libmad, ltremor, etc
class GuiSound : public AsyncDeleter::Element
{
public:
//!Constructor
//!\param sound Pointer to the sound data
//!\param filesize Length of sound data
GuiSound(const char * filepath);
GuiSound(const u8 * sound, s32 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 u8 * snd, s32 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(u32 v);
//!\param l Loop (true to loop)
void SetLoop(bool l);
protected:
s32 voice; //!< Currently assigned ASND voice channel
};
#endif

View File

@ -1,72 +0,0 @@
/****************************************************************************
* 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 "GuiSwitch.h"
#include "GuiImage.h"
#include "GuiImageData.h"
/**
* Constructor for the GuiSwitch class.
*/
GuiSwitch::GuiSwitch(bool checked,f32 switchscale)
: GuiToggle(checked,90*switchscale,38*switchscale)
,switchbase_imgdata(Resources::GetImageData("switchIconBase.png"))
,switchbase_img(switchbase_imgdata)
,switchbase_highlighted_imgdata(Resources::GetImageData("switchIconBaseHighlighted.png"))
,switchbase_highlighted_img(switchbase_highlighted_imgdata)
,switchOn_imgdata(Resources::GetImageData("switchIconOn.png"))
,switchOn_img(switchOn_imgdata)
,switchOff_imgdata(Resources::GetImageData("switchIconOff.png"))
,switchOff_img(switchOff_imgdata)
{
f32 scale = 0.0;
if(switchbase_img.getHeight() > switchbase_img.getWidth()){
scale = height*switchscale/switchbase_img.getHeight();
}else{
scale = width/switchbase_img.getWidth();
}
switchbase_img.setScale(scale);
switchbase_highlighted_img.setScale(scale);
switchOn_img.setScale(scale);
switchOff_img.setScale(scale);
switchOn_img.setParent(this);
switchOn_img.setPosition((width/4.0),0);
switchOff_img.setParent(this);
switchOff_img.setPosition(-((width/4.0)),0);
setImage(&switchbase_img);
setIconOver(&switchbase_highlighted_img);
}
/**
* Destructor for the GuiButton class.
*/
GuiSwitch::~GuiSwitch()
{
Resources::RemoveImageData(switchbase_imgdata);
Resources::RemoveImageData(switchbase_highlighted_imgdata);
Resources::RemoveImageData(switchOn_imgdata);
Resources::RemoveImageData(switchOff_imgdata);
}
void GuiSwitch::draw(CVideo *v){
GuiToggle::draw(v);
if(getValue()){
switchOn_img.draw(v);
}else{
switchOff_img.draw(v);
}
}

View File

@ -1,51 +0,0 @@
/****************************************************************************
* 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_SWTICH_H_
#define GUI_SWTICH_H_
#include "GuiToggle.h"
#include "GuiImage.h"
#include "GuiImageData.h"
//!A simple switch
class GuiSwitch : public GuiToggle
{
public:
//!Constructor
//!\param checked Checked
GuiSwitch(bool checked,f32 switchscale = 1.0f);
//!Destructor
virtual ~GuiSwitch();
protected:
GuiImageData * switchbase_imgdata;
GuiImage switchbase_img;
GuiImageData * switchbase_highlighted_imgdata;
GuiImage switchbase_highlighted_img;
GuiImageData * switchOn_imgdata;
GuiImage switchOn_img;
GuiImageData * switchOff_imgdata;
GuiImage switchOff_img;
void draw(CVideo * v);
};
#endif

View File

@ -1,615 +0,0 @@
/****************************************************************************
* 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/CVideo.h"
#include "FreeTypeGX.h"
#include "GuiText.h"
FreeTypeGX * GuiText::presentFont = NULL;
int GuiText::presetSize = 28;
int GuiText::presetInternalRenderingScale = 2.0f; //Lets render the font at the doubled size. This make it even smoother!
int GuiText::presetMaxWidth = 0xFFFF;
int 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;
size = presetSize;
currentSize = size;
color = glm::vec4(presetColor.r, presetColor.g, presetColor.b, presetColor.a);
alpha = presetColor.a;
alignment = presetAlignment;
maxWidth = presetMaxWidth;
wrapMode = 0;
textWidth = 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);
internalRenderingScale = presetInternalRenderingScale;
}
GuiText::GuiText(const char * t, int s, const glm::vec4 & c)
{
text = NULL;
size = s;
currentSize = size;
color = c;
alpha = c[3];
alignment = ALIGN_CENTER | ALIGN_MIDDLE;
maxWidth = presetMaxWidth;
wrapMode = 0;
textWidth = 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);
internalRenderingScale = presetInternalRenderingScale;
if(t)
{
text = FreeTypeGX::charToWideChar(t);
if(!text)
return;
textWidth = font->getWidth(text, currentSize);
}
}
GuiText::GuiText(const wchar_t * t, int s, const glm::vec4 & c)
{
text = NULL;
size = s;
currentSize = size;
color = c;
alpha = c[3];
alignment = ALIGN_CENTER | ALIGN_MIDDLE;
maxWidth = presetMaxWidth;
wrapMode = 0;
textWidth = 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);
internalRenderingScale = presetInternalRenderingScale;
if(t)
{
text = new (std::nothrow) wchar_t[wcslen(t)+1];
if(!text)
return;
wcscpy(text, t);
textWidth = font->getWidth(text, currentSize);
}
}
/**
* Constructor for the GuiText class, uses presets
*/
GuiText::GuiText(const char * t)
{
text = NULL;
size = presetSize;
currentSize = size;
color = glm::vec4(presetColor.r, presetColor.g, presetColor.b, presetColor.a);
alpha = presetColor.a;
alignment = presetAlignment;
maxWidth = presetMaxWidth;
wrapMode = 0;
textWidth = 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);
internalRenderingScale = presetInternalRenderingScale;
if(t)
{
text = FreeTypeGX::charToWideChar(t);
if(!text)
return;
textWidth = font->getWidth(text, currentSize);
}
}
/**
* Destructor for the GuiText class.
*/
GuiText::~GuiText()
{
if(text)
delete [] text;
text = NULL;
clearDynamicText();
}
void GuiText::setText(const char * t)
{
if(text)
delete [] text;
text = NULL;
clearDynamicText();
textScrollPos = 0;
textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
if(t)
{
text = FreeTypeGX::charToWideChar(t);
if(!text)
return;
textWidth = font->getWidth(text, currentSize);
}
}
void GuiText::setTextf(const char *format, ...)
{
if(!format)
{
setText((char *) NULL);
return;
}
int max_len = strlen(format) + 8192;
char *tmp = new 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)
{
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)
return;
wcscpy(text, t);
textWidth = font->getWidth(text, currentSize);
}
}
void GuiText::clearDynamicText()
{
for(u32 i = 0; i < textDyn.size(); i++)
{
if(textDyn[i])
delete [] textDyn[i];
}
textDyn.clear();
textDynWidth.clear();
}
void GuiText::setPresets(int sz, const glm::vec4 & c, int w, int a)
{
presetSize = sz;
presetColor = (GX2ColorF32) { (f32)c.r / 255.0f, (f32)c.g / 255.0f, (f32)c.b / 255.0f, (f32)c.a / 255.0f };
presetMaxWidth = w;
presetAlignment = a;
}
void GuiText::setPresetFont(FreeTypeGX *f)
{
presentFont = f;
}
void GuiText::setFontSize(int s)
{
size = s;
}
void GuiText::setMaxWidth(int width, int 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];
}
int GuiText::getTextWidth(int ind)
{
if(ind < 0 || ind >= (int) textDyn.size())
return this->getTextWidth();
return font->getWidth(textDyn[ind], currentSize);
}
const wchar_t * GuiText::getDynText(int ind)
{
if(ind < 0 || ind >= (int) textDyn.size())
return text;
return textDyn[ind];
}
/**
* Change font
*/
bool GuiText::setFont(FreeTypeGX *f)
{
if(!f)
return false;
font = f;
textWidth = font->getWidth(text, currentSize);
return true;
}
std::string GuiText::toUTF8(void) const
{
if(!text)
return std::string();
char *pUtf8 = FreeTypeGX::wideCharToUTF8(text);
if(!pUtf8)
return std::string();
std::string strOutput(pUtf8);
delete [] pUtf8;
return strOutput;
}
void GuiText::makeDottedText()
{
int pos = textDyn.size();
textDyn.resize(pos + 1);
int i = 0, currentWidth = 0;
textDyn[pos] = new (std::nothrow) wchar_t[maxWidth];
if(!textDyn[pos]) {
textDyn.resize(pos);
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;
}
void GuiText::scrollText(u32 frameCount)
{
if (textDyn.size() == 0)
{
int pos = textDyn.size();
int i = 0, currentWidth = 0;
textDyn.resize(pos + 1);
textDyn[pos] = new (std::nothrow) wchar_t[maxWidth];
if(!textDyn[pos]) {
textDyn.resize(pos);
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;
return;
}
if (frameCount % textScrollDelay != 0)
{
return;
}
if (textScrollInitialDelay)
{
--textScrollInitialDelay;
return;
}
int stringlen = wcslen(text);
++textScrollPos;
if (textScrollPos > stringlen)
{
textScrollPos = 0;
textScrollInitialDelay = TEXT_SCROLL_INITIAL_DELAY;
}
int ch = textScrollPos;
int pos = textDyn.size() - 1;
if (!textDyn[pos])
textDyn[pos] = new (std::nothrow) wchar_t[maxWidth];
if(!textDyn[pos]) {
textDyn.resize(pos);
return;
}
int 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;
}
void GuiText::wrapText()
{
if (textDyn.size() > 0) return;
int i = 0;
int ch = 0;
int linenum = 0;
int lastSpace = -1;
int lastSpaceIndex = -1;
int currentWidth = 0;
while (text[ch] && linenum < linestodraw)
{
if (linenum >= (int) 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;
}
}
/**
* Draw the text on screen
*/
void GuiText::draw(CVideo *pVideo)
{
if(!text)
return;
if(!isVisible())
return;
color[3] = getAlpha();
blurGlowColor[3] = blurAlpha * getAlpha();
float finalRenderingScale = 2.0f * internalRenderingScale;
int newSize = size * getScale() * finalRenderingScale;
int normal_size = size * getScale();
if(newSize != currentSize)
{
currentSize = normal_size;
if(text)
textWidth = font->getWidth(text, normal_size);
}
f32 x_pos = getCenterX() * finalRenderingScale;
f32 y_pos = getCenterY() * finalRenderingScale;
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(u32 i = 0; i < textDynWidth.size(); i++)
textDynWidth[i] = font->getWidth(textDyn[i], newSize);
}
if(textDyn.size() > 0)
font->drawText(pVideo, x_pos, y_pos, getDepth(), textDyn[textDyn.size()-1], newSize, color, alignment, textDynWidth[textDyn.size()-1], defaultBlur, blurGlowIntensity, blurGlowColor,finalRenderingScale);
}
else if(wrapMode == SCROLL_HORIZONTAL)
{
scrollText(pVideo->getFrameCount());
if(textDyn.size() > 0)
font->drawText(pVideo, x_pos, y_pos, getDepth(), textDyn[textDyn.size()-1], newSize, color, alignment, maxWidth*finalRenderingScale, defaultBlur, blurGlowIntensity, blurGlowColor,finalRenderingScale);
}
else if(wrapMode == WRAP)
{
int lineheight = newSize + 6;
int yoffset = 0;
int voffset = 0;
if(textDyn.size() == 0)
wrapText();
if(textDynWidth.size() != textDyn.size())
{
textDynWidth.resize(textDyn.size());
for(u32 i = 0; i < textDynWidth.size(); i++)
textDynWidth[i] = font->getWidth(textDyn[i], newSize);
}
if(alignment & ALIGN_MIDDLE)
voffset = (lineheight * (textDyn.size()-1)) >> 1;
for(u32 i = 0; i < textDyn.size(); i++)
{
font->drawText(pVideo, x_pos, y_pos + voffset + yoffset, getDepth(), textDyn[i], newSize, color, alignment, textDynWidth[i], defaultBlur, blurGlowIntensity, blurGlowColor,finalRenderingScale);
yoffset -= lineheight;
}
}
}
else
{
uint16_t newtextWidth = font->getWidth(text, newSize);
font->drawText(pVideo, x_pos, y_pos, getDepth(), text, newSize, color, alignment, newtextWidth, defaultBlur, blurGlowIntensity, blurGlowColor,finalRenderingScale);
}
}

View File

@ -1,142 +0,0 @@
/****************************************************************************
* 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 "common/gx2_ext.h"
#include "GuiElement.h"
//!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, int s, const glm::vec4 & c);
//!\overload
//!\param t Text
//!\param s Font size
//!\param c Font color
GuiText(const wchar_t * t, int 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(int sz, const glm::vec4 & c, int w, int a);
static void setPresetFont(FreeTypeGX *font);
//!Sets the font size
//!\param s Font size
void setFontSize(int 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(int w = 0, int 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
int getTextWidth() { return textWidth; }
int getTextWidth(int ind);
//!Get the max textwidth
int getTextMaxWidth() { return maxWidth; }
//!Get fontsize
int getFontSize() { return size; };
//!Set max lines to draw
void setLinesToDraw(int l) { linestodraw = l; }
//!Get current Textline (for position calculation)
const wchar_t * getDynText(int ind = 0);
virtual const wchar_t * getTextLine(int ind) { return getDynText(ind); };
//!Change the font
bool setFont(FreeTypeGX *font);
//! virtual function used in child classes
virtual int getStartWidth() { return 0; };
//!Constantly called to draw the text
void draw(CVideo *pVideo);
//! text enums
enum
{
WRAP,
DOTTED,
SCROLL_HORIZONTAL,
SCROLL_NONE
};
protected:
static FreeTypeGX * presentFont;
static int presetSize;
static int presetMaxWidth;
static int presetInternalRenderingScale;
static int 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(u32 frameCount);
//!Wrap the text to several lines
void wrapText();
wchar_t * text;
std::vector<wchar_t *> textDyn;
std::vector<uint16_t> textDynWidth;
int wrapMode; //!< Wrapping toggle
int textScrollPos; //!< Current starting index of text string for scrolling
int textScrollInitialDelay; //!< Delay to wait before starting to scroll
int textScrollDelay; //!< Scrolling speed
int size; //!< Font size
int maxWidth; //!< Maximum width of the generated text object (for text wrapping)
FreeTypeGX *font;
int textWidth;
int currentSize;
int linestodraw;
glm::vec4 color;
float defaultBlur;
float blurGlowIntensity;
float blurAlpha;
glm::vec4 blurGlowColor;
float internalRenderingScale;
};
#endif

View File

@ -1,55 +0,0 @@
/****************************************************************************
* 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 "GuiToggle.h"
/**
* Constructor for the GuiToggle class.
*/
GuiToggle::GuiToggle(bool checked,f32 width,f32 height)
: GuiButton(width,height)
{
bChanged = false;
selected = false;
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)){
log_print("Clicked on Toggle: ");
if(selected){
log_print("Uncheck\n");
setUnchecked();
}else{
log_print("Check\n");
setChecked();
}
}
}
void GuiToggle::update(GuiController * c){
GuiButton::update(c);
}

View File

@ -1,59 +0,0 @@
/****************************************************************************
* 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 "GuiButton.h"
#include "GuiFrame.h"
//!A simple CheckBox
class GuiToggle : public GuiButton, public sigslot::has_slots<>
{
public:
//!Constructor
//!\param checked Checked
GuiToggle(bool checked,f32 width,f32 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

View File

@ -1,174 +0,0 @@
/****************************************************************************
* 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 "GuiElement.h"
#include "GuiController.h"
#include "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(u32 ch, u32 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(u32 ch, u32 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;
}
bool GuiTrigger::clicked(const GuiController *controller) const
{
if((controller->chan & chan) == 0) {
return false;
}
bool bResult = false;
if(controller->data.touched && controller->data.validPointer && (btns & VPAD_TOUCH) && !controller->lastData.touched)
{
bResult = true;
}
if(controller->data.buttons_d & btns)
{
bResult = true;
}
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;
}

View File

@ -1,100 +0,0 @@
/***************************************************************************
* 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 "common/types.h"
//!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 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(u32 ch, u32 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(u32 ch, u32 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;
bool clicked(const GuiController *controller) const;
bool held(const GuiController *controller) const;
bool released(const GuiController *controller) const;
private:
u32 chan;
u32 btns;
bool bClickEverywhere;
bool bHoldEverywhere;
bool bSelectionClickEverywhere;
bool bLastTouched;
};
#endif

View File

@ -1,277 +0,0 @@
/***************************************************************************
* 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 "Scrollbar.h"
#include "resources/Resources.h"
Scrollbar::Scrollbar(int 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;
ScrollSpeed = 15;
ScrollState = 0;
listChanged.connect(this, &Scrollbar::setScrollboxPosition);
btnSoundClick = Resources::GetSound("button_click.mp3");
scrollbarLine = Resources::GetImageData("scrollbarLine.png");
arrowDown = Resources::GetImageData("scrollbarArrowDown.png");
arrowUp = Resources::GetImageData("scrollbarArrowUp.png");
scrollbarBox = Resources::GetImageData("scrollbarButton.png");
height = h;
width = scrollbarBox->getWidth();
MaxHeight = height * 0.5f - (scrollbarBox ? (scrollbarBox->getHeight() * 0.5f) : 0) - (arrowUp ? arrowUp->getHeight() : 0);
MinHeight = -height * 0.5f + (scrollbarBox ? (scrollbarBox->getHeight() * 0.5f) : 0) + (arrowDown ? arrowDown->getHeight() : 0);
scrollbarLineImg = new GuiImage(scrollbarLine);
scrollbarLineImg->setParent(this);
scrollbarLineImg->setAlignment(ALIGN_CENTER | ALIGN_MIDDLE);
scrollbarLineImg->setPosition(0, 0);
arrowDownImg = new GuiImage(arrowDown);
arrowUpImg = new GuiImage(arrowUp);
scrollbarBoxImg = new GuiImage(scrollbarBox);
arrowUpBtn = new GuiButton(arrowUpImg->getWidth(), arrowUpImg->getHeight());
arrowUpBtn->setParent(this);
arrowUpBtn->setImage(arrowUpImg);
arrowUpBtn->setAlignment(ALIGN_CENTER | ALIGN_TOP);
arrowUpBtn->setPosition(0, 0);
arrowUpBtn->setTrigger(&touchTrigger, 0);
arrowUpBtn->setTrigger(&wpadTouchTrigger, 1);
arrowUpBtn->setSoundClick(btnSoundClick);
arrowUpBtn->setEffectGrow();
arrowUpBtn->clicked.connect(this, &Scrollbar::OnUpButtonClick);
arrowDownBtn = new GuiButton(arrowDownImg->getWidth(), arrowDownImg->getHeight());
arrowDownBtn->setParent(this);
arrowDownBtn->setImage(arrowDownImg);
arrowDownBtn->setAlignment(ALIGN_CENTER | ALIGN_BOTTOM);
arrowDownBtn->setPosition(0, 0);
arrowDownBtn->setTrigger(&touchTrigger, 0);
arrowDownBtn->setTrigger(&wpadTouchTrigger, 1);
arrowDownBtn->setSoundClick(btnSoundClick);
arrowDownBtn->setEffectGrow();
arrowDownBtn->clicked.connect(this, &Scrollbar::OnDownButtonClick);
scrollbarBoxBtn = new GuiButton(scrollbarBoxImg->getWidth(), height);
scrollbarBoxBtn->setParent(this);
scrollbarBoxBtn->setImage(scrollbarBoxImg);
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, &Scrollbar::OnBoxButtonHold);
}
Scrollbar::~Scrollbar()
{
Resources::RemoveSound(btnSoundClick);
Resources::RemoveImageData(scrollbarLine);
Resources::RemoveImageData(arrowDown);
Resources::RemoveImageData(arrowUp);
Resources::RemoveImageData(scrollbarBox);
delete arrowUpBtn;
delete arrowDownBtn;
delete scrollbarBoxBtn;
delete scrollbarLineImg;
delete arrowDownImg;
delete arrowUpImg;
delete scrollbarBoxImg;
}
void Scrollbar::ScrollOneUp()
{
if(SelItem == 0 && SelInd > 0)
{
// move list up by 1
--SelInd;
}
else if(SelInd+SelItem > 0)
{
--SelItem;
}
}
void Scrollbar::ScrollOneDown()
{
if(SelInd+SelItem + 1 < EntrieCount)
{
if(SelItem == PageSize-1)
{
// move list down by 1
SelInd++;
}
else
{
SelItem++;
}
}
}
void Scrollbar::OnUpButtonClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger)
{
if(ScrollState < ScrollSpeed)
return;
ScrollOneUp();
ScrollState = 0;
listChanged(SelItem, SelInd);
}
void Scrollbar::OnDownButtonClick(GuiButton *button, const GuiController *controller, GuiTrigger *trigger)
{
if(ScrollState < ScrollSpeed)
return;
ScrollOneDown();
ScrollState = 0;
listChanged(SelItem, SelInd);
}
void Scrollbar::OnBoxButtonHold(GuiButton *button, const GuiController *controller, GuiTrigger *trigger)
{
if(EntrieCount == 0)
return;
if(!controller->data.validPointer)
return;
int y = controller->data.y - this->getCenterY();
int positionWiimote = LIMIT(y - MinHeight, 0, MaxHeight - MinHeight);
int newSelected = (EntrieCount - 1) - (int) ((float) positionWiimote / (float) (MaxHeight-MinHeight) * (float) (EntrieCount-1));
int 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, 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 Scrollbar::SetPageSize(int size)
{
if(PageSize == size)
return;
PageSize = size;
listChanged(SelItem, SelInd);
}
void Scrollbar::SetSelectedItem(int pos)
{
if(SelItem == pos)
return;
SelItem = LIMIT(pos, 0, EntrieCount-1);
listChanged(SelItem, SelInd);
}
void Scrollbar::SetSelectedIndex(int pos)
{
if(SelInd == pos)
return;
SelInd = pos;
listChanged(SelItem, SelInd);
}
void Scrollbar::SetEntrieCount(int cnt)
{
if(EntrieCount == cnt)
return;
EntrieCount = cnt;
listChanged(SelItem, SelInd);
}
void Scrollbar::setScrollboxPosition(int SelItem, int SelInd)
{
int 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 Scrollbar::draw(CVideo * video)
{
scrollbarLineImg->draw(video);
arrowUpBtn->draw(video);
arrowDownBtn->draw(video);
scrollbarBoxBtn->draw(video);
updateEffects();
}
void Scrollbar::update(GuiController * t)
{
if(this->isStateSet(STATE_DISABLED))
return;
arrowUpBtn->update(t);
arrowDownBtn->update(t);
scrollbarBoxBtn->update(t);
++ScrollState;
}

View File

@ -1,84 +0,0 @@
/***************************************************************************
* 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 SCROLLBAR_HPP_
#define SCROLLBAR_HPP_
#include "gui/GuiElement.h"
#include "gui/GuiButton.h"
class Scrollbar : public GuiElement, public sigslot::has_slots<>
{
public:
Scrollbar(int height);
virtual ~Scrollbar();
void ScrollOneUp();
void ScrollOneDown();
int GetSelectedItem() { return SelItem; }
int GetSelectedIndex() { return SelInd; }
void draw(CVideo * video);
void update(GuiController * t);
//! Signals
sigslot::signal2<int, int> listChanged;
//! Slots
void SetPageSize(int size);
void SetRowSize(int size);
void SetSelectedItem(int pos);
void SetSelectedIndex(int pos);
void SetEntrieCount(int cnt);
protected:
void setScrollboxPosition(int SelItem, int 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);
u32 ScrollState;
u16 ScrollSpeed;
int MinHeight;
int MaxHeight;
int SelItem;
int SelInd;
int PageSize;
int EntrieCount;
int pressedChan;
GuiButton * arrowUpBtn;
GuiButton * arrowDownBtn;
GuiButton * scrollbarBoxBtn;
GuiImage * scrollbarLineImg;
GuiImage * arrowDownImg;
GuiImage * arrowUpImg;
GuiImage * scrollbarBoxImg;
GuiImageData * scrollbarLine;
GuiImageData * arrowDown;
GuiImageData * arrowUp;
GuiImageData * scrollbarBox;
GuiSound * btnSoundClick;
GuiTrigger touchTrigger;
GuiTrigger wpadTouchTrigger;
};
#endif

View File

@ -1,62 +0,0 @@
/****************************************************************************
* 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 <vpad/input.h>
#include "GuiController.h"
class VPadController : public GuiController
{
public:
//!Constructor
VPadController(int channel)
: GuiController(channel)
{
memset(&vpad, 0, sizeof(vpad));
}
//!Destructor
virtual ~VPadController() {}
bool update(int width, int height)
{
lastData = data;
VPADReadError vpadError = VPAD_READ_NO_SAMPLES;
VPADRead(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;
//! calculate the screen offsets
data.x = -(width >> 1) + (int)((vpad.tpFiltered1.x * width) >> 12);
data.y = (height >> 1) - (int)(height - ((vpad.tpFiltered1.y * height) >> 12));
return true;
}
return false;
}
private:
VPADStatus vpad;
};
#endif

View File

@ -1,179 +0,0 @@
/****************************************************************************
* 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 "GuiController.h"
#include "dynamic_libs/padscore_functions.h"
class WPadController : public GuiController
{
public:
//!Constructor
WPadController(int channel)
: GuiController(channel)
{
memset(&kpadData, 0, sizeof(kpadData));
}
//!Destructor
virtual ~WPadController() {}
u32 remapWiiMoteButtons(u32 buttons)
{
u32 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;
}
u32 remapClassicButtons(u32 buttons)
{
u32 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;
}
bool update(int width, int height)
{
lastData = data;
u32 controller_type;
//! check if the controller is connected
if(WPADProbe(chanIdx-1, &controller_type) != 0)
return false;
KPADRead(chanIdx-1, &kpadData, 1);
if(kpadData.device_type <= 1)
{
data.buttons_r = remapWiiMoteButtons(kpadData.btns_r);
data.buttons_h = remapWiiMoteButtons(kpadData.btns_h);
data.buttons_d = remapWiiMoteButtons(kpadData.btns_d);
}
else
{
data.buttons_r = remapClassicButtons(kpadData.classic.btns_r);
data.buttons_h = remapClassicButtons(kpadData.classic.btns_h);
data.buttons_d = remapClassicButtons(kpadData.classic.btns_d);
}
data.validPointer = (kpadData.pos_valid == 1 || kpadData.pos_valid == 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:
KPADData kpadData;
u32 lastButtons;
};
#endif

File diff suppressed because it is too large Load Diff

View File

@ -1,40 +0,0 @@
OUTPUT(flappy_bird.elf);
/* Tell linker where our application entry is so the garbage collect can work correct */
ENTRY(__entry_menu);
SECTIONS {
. = 0x00802000;
.text : {
*(.text*);
}
.rodata : {
*(.rodata*);
}
.data : {
*(.data*);
__sdata_start = .;
*(.sdata*);
__sdata_end = .;
__sdata2_start = .;
*(.sdata2*);
__sdata2_end = .;
}
.bss : {
__bss_start = .;
*(.bss*);
*(.sbss*);
*(COMMON);
__bss_end = .;
}
__CODE_END = .;
/DISCARD/ : {
*(*);
}
}
/******************************************************** FS ********************************************************/
/* coreinit.rpl difference in addresses 0xFE3C00 */

View File

@ -1,10 +1,9 @@
#include <nsysnet/socket.h> #include <nsysnet/socket.h>
#include <coreinit/ios.h>
#include "Application.h" #include "Application.h"
#include "system/memory.h" #include "system/memory.h"
#include "utils/logger.h" #include "utils/logger.h"
#include "utils/utils.h" #include "utils/utils.h"
#include "dynamic_libs/padscore_functions.h"
#include "common/common.h"
/* Entry point */ /* Entry point */
extern "C" int Menu_Main(void) extern "C" int Menu_Main(void)
@ -14,10 +13,7 @@ extern "C" int Menu_Main(void)
//!******************************************************************* //!*******************************************************************
socket_lib_init(); socket_lib_init();
//! do OS (for acquire) and sockets first so we got logging //! do OS (for acquire) and sockets first so we got logging
log_init("192.168.1.12"); log_init();
InitPadScoreFunctionPointers();
log_printf("Function exports loaded\n");
log_print("Initialize memory management\n"); log_print("Initialize memory management\n");
memoryInitialize(); memoryInitialize();
@ -29,9 +25,7 @@ extern "C" int Menu_Main(void)
log_printf("Start main application\n"); log_printf("Start main application\n");
Application::instance()->exec(); Application::instance()->exec();
Application::destroyInstance(); Application::destroyInstance();
log_deinit(); return 0;
return EXIT_SUCCESS;
} }

View File

@ -1,8 +1,6 @@
#ifndef _MAIN_H_ #ifndef _MAIN_H_
#define _MAIN_H_ #define _MAIN_H_
#include "common/types.h"
/* Main */ /* Main */
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {

View File

@ -27,7 +27,7 @@ MainWindow::MainWindow(int w, int h)
{ {
for(int i = 0; i < 4; i++) for(int i = 0; i < 4; i++)
{ {
std::string filename = strfmt("player%i_point.png", i+1); std::string filename = StringTools::strfmt("player%i_point.png", i+1);
pointerImgData[i] = Resources::GetImageData(filename.c_str()); pointerImgData[i] = Resources::GetImageData(filename.c_str());
pointerImg[i] = new GuiImage(pointerImgData[i]); pointerImg[i] = new GuiImage(pointerImgData[i]);
pointerImg[i]->setScale(1.5f); pointerImg[i]->setScale(1.5f);
@ -60,18 +60,18 @@ MainWindow::~MainWindow()
void MainWindow::updateEffects() void MainWindow::updateEffects()
{ {
//! dont read behind the initial elements in case one was added //! dont read behind the initial elements in case one was added
u32 tvSize = tvElements.size(); uint32_t tvSize = tvElements.size();
u32 drcSize = drcElements.size(); uint32_t drcSize = drcElements.size();
for(u32 i = 0; (i < drcSize) && (i < drcElements.size()); ++i) for(uint32_t i = 0; (i < drcSize) && (i < drcElements.size()); ++i)
{ {
drcElements[i]->updateEffects(); drcElements[i]->updateEffects();
} }
//! only update TV elements that are not updated yet because they are on DRC //! only update TV elements that are not updated yet because they are on DRC
for(u32 i = 0; (i < tvSize) && (i < tvElements.size()); ++i) for(uint32_t i = 0; (i < tvSize) && (i < tvElements.size()); ++i)
{ {
u32 n; uint32_t n;
for(n = 0; (n < drcSize) && (n < drcElements.size()); n++) for(n = 0; (n < drcSize) && (n < drcElements.size()); n++)
{ {
if(tvElements[i] == drcElements[n]) if(tvElements[i] == drcElements[n])
@ -86,18 +86,18 @@ void MainWindow::updateEffects()
void MainWindow::process(){ void MainWindow::process(){
//! dont read behind the initial elements in case one was added //! dont read behind the initial elements in case one was added
u32 tvSize = tvElements.size(); uint32_t tvSize = tvElements.size();
u32 drcSize = drcElements.size(); uint32_t drcSize = drcElements.size();
for(u32 i = 0; (i < drcSize) && (i < drcElements.size()); ++i) for(uint32_t i = 0; (i < drcSize) && (i < drcElements.size()); ++i)
{ {
drcElements[i]->process(); drcElements[i]->process();
} }
//! only update TV elements that are not updated yet because they are on DRC //! only update TV elements that are not updated yet because they are on DRC
for(u32 i = 0; (i < tvSize) && (i < tvElements.size()); ++i) for(uint32_t i = 0; (i < tvSize) && (i < tvElements.size()); ++i)
{ {
u32 n; uint32_t n;
for(n = 0; (n < drcSize) && (n < drcElements.size()); n++) for(n = 0; (n < drcSize) && (n < drcElements.size()); n++)
{ {
if(tvElements[i] == drcElements[n]) if(tvElements[i] == drcElements[n])
@ -113,31 +113,31 @@ void MainWindow::process(){
void MainWindow::update(GuiController *controller) void MainWindow::update(GuiController *controller)
{ {
//! dont read behind the initial elements in case one was added //! dont read behind the initial elements in case one was added
//u32 tvSize = tvElements.size(); //uint32_t tvSize = tvElements.size();
if(controller->chan & GuiTrigger::CHANNEL_1) if(controller->chan & GuiTrigger::CHANNEL_1)
{ {
u32 drcSize = drcElements.size(); uint32_t drcSize = drcElements.size();
for(u32 i = 0; (i < drcSize) && (i < drcElements.size()); ++i) for(uint32_t i = 0; (i < drcSize) && (i < drcElements.size()); ++i)
{ {
drcElements[i]->update(controller); drcElements[i]->update(controller);
} }
} }
else else
{ {
u32 tvSize = tvElements.size(); uint32_t tvSize = tvElements.size();
for(u32 i = 0; (i < tvSize) && (i < tvElements.size()); ++i) for(uint32_t i = 0; (i < tvSize) && (i < tvElements.size()); ++i)
{ {
tvElements[i]->update(controller); tvElements[i]->update(controller);
} }
} }
// //! only update TV elements that are not updated yet because they are on DRC // //! only update TV elements that are not updated yet because they are on DRC
// for(u32 i = 0; (i < tvSize) && (i < tvElements.size()); ++i) // for(uint32_t i = 0; (i < tvSize) && (i < tvElements.size()); ++i)
// { // {
// u32 n; // uint32_t n;
// for(n = 0; (n < drcSize) && (n < drcElements.size()); n++) // for(n = 0; (n < drcSize) && (n < drcElements.size()); n++)
// { // {
// if(tvElements[i] == drcElements[n]) // if(tvElements[i] == drcElements[n])
@ -152,8 +152,8 @@ void MainWindow::update(GuiController *controller)
if(controller->chanIdx >= 1 && controller->chanIdx <= 4 && controller->data.validPointer) if(controller->chanIdx >= 1 && controller->chanIdx <= 4 && controller->data.validPointer)
{ {
int wpadIdx = controller->chanIdx - 1; int wpadIdx = controller->chanIdx - 1;
f32 posX = controller->data.x; float posX = controller->data.x;
f32 posY = controller->data.y; float posY = controller->data.y;
pointerImg[wpadIdx]->setPosition(posX, posY); pointerImg[wpadIdx]->setPosition(posX, posY);
pointerImg[wpadIdx]->setAngle(controller->data.pointerAngle); pointerImg[wpadIdx]->setAngle(controller->data.pointerAngle);
pointerValid[wpadIdx] = true; pointerValid[wpadIdx] = true;
@ -162,7 +162,7 @@ void MainWindow::update(GuiController *controller)
void MainWindow::drawDrc(CVideo *video) void MainWindow::drawDrc(CVideo *video)
{ {
for(u32 i = 0; i < drcElements.size(); ++i) for(uint32_t i = 0; i < drcElements.size(); ++i)
{ {
drcElements[i]->draw(video); drcElements[i]->draw(video);
} }
@ -180,7 +180,7 @@ void MainWindow::drawDrc(CVideo *video)
void MainWindow::drawTv(CVideo *video) void MainWindow::drawTv(CVideo *video)
{ {
for(u32 i = 0; i < tvElements.size(); ++i) for(uint32_t i = 0; i < tvElements.size(); ++i)
{ {
tvElements[i]->draw(video); tvElements[i]->draw(video);
} }

View File

@ -55,7 +55,7 @@ public:
appendDrc(e); appendDrc(e);
} }
void insertTv(u32 pos, GuiElement *e) void insertTv(uint32_t pos, GuiElement *e)
{ {
if(!e) if(!e)
return; return;
@ -63,7 +63,7 @@ public:
removeTv(e); removeTv(e);
tvElements.insert(tvElements.begin() + pos, e); tvElements.insert(tvElements.begin() + pos, e);
} }
void insertDrc(u32 pos, GuiElement *e) void insertDrc(uint32_t pos, GuiElement *e)
{ {
if(!e) if(!e)
return; return;
@ -72,7 +72,7 @@ public:
drcElements.insert(drcElements.begin() + pos, e); drcElements.insert(drcElements.begin() + pos, e);
} }
void insert(u32 pos, GuiElement *e) void insert(uint32_t pos, GuiElement *e)
{ {
insertTv(pos, e); insertTv(pos, e);
insertDrc(pos, e); insertDrc(pos, e);
@ -80,7 +80,7 @@ public:
void removeTv(GuiElement *e) void removeTv(GuiElement *e)
{ {
for(u32 i = 0; i < tvElements.size(); ++i) for(uint32_t i = 0; i < tvElements.size(); ++i)
{ {
if(e == tvElements[i]) if(e == tvElements[i])
{ {
@ -91,7 +91,7 @@ public:
} }
void removeDrc(GuiElement *e) void removeDrc(GuiElement *e)
{ {
for(u32 i = 0; i < drcElements.size(); ++i) for(uint32_t i = 0; i < drcElements.size(); ++i)
{ {
if(e == drcElements[i]) if(e == drcElements[i])
{ {

View File

@ -3,7 +3,7 @@
#include "Resources.h" #include "Resources.h"
#include "filelist.h" #include "filelist.h"
#include "system/AsyncDeleter.h" #include "system/AsyncDeleter.h"
#include "fs/fs_utils.h" #include "fs/FSUtils.h"
#include "gui/GuiImageAsync.h" #include "gui/GuiImageAsync.h"
#include "gui/GuiSound.h" #include "gui/GuiSound.h"
@ -43,20 +43,20 @@ bool Resources::LoadFiles(const char * path)
fullpath += "/"; fullpath += "/";
fullpath += RecourceList[i].filename; fullpath += RecourceList[i].filename;
u8 * buffer = NULL; uint8_t * buffer = NULL;
u32 filesize = 0; uint32_t filesize = 0;
LoadFileToMem(fullpath.c_str(), &buffer, &filesize); FSUtils::LoadFileToMem(fullpath.c_str(), &buffer, &filesize);
RecourceList[i].CustomFile = buffer; RecourceList[i].CustomFile = buffer;
RecourceList[i].CustomFileSize = (u32) filesize; RecourceList[i].CustomFileSize = (uint32_t) filesize;
result |= (buffer != 0); result |= (buffer != 0);
} }
return result; return result;
} }
const u8 * Resources::GetFile(const char * filename) const uint8_t * Resources::GetFile(const char * filename)
{ {
for(int i = 0; RecourceList[i].filename != NULL; ++i) for(int i = 0; RecourceList[i].filename != NULL; ++i)
{ {
@ -69,7 +69,7 @@ const u8 * Resources::GetFile(const char * filename)
return NULL; return NULL;
} }
u32 Resources::GetFileSize(const char * filename) uint32_t Resources::GetFileSize(const char * filename)
{ {
for(int i = 0; RecourceList[i].filename != NULL; ++i) for(int i = 0; RecourceList[i].filename != NULL; ++i)
{ {
@ -97,8 +97,8 @@ GuiImageData * Resources::GetImageData(const char * filename)
{ {
if(strcasecmp(filename, RecourceList[i].filename) == 0) if(strcasecmp(filename, RecourceList[i].filename) == 0)
{ {
const u8 * buff = RecourceList[i].CustomFile ? RecourceList[i].CustomFile : RecourceList[i].DefaultFile; const uint8_t * buff = RecourceList[i].CustomFile ? RecourceList[i].CustomFile : RecourceList[i].DefaultFile;
const u32 size = RecourceList[i].CustomFile ? RecourceList[i].CustomFileSize : RecourceList[i].DefaultFileSize; const uint32_t size = RecourceList[i].CustomFile ? RecourceList[i].CustomFileSize : RecourceList[i].DefaultFileSize;
if(buff == NULL) if(buff == NULL)
return NULL; return NULL;
@ -150,8 +150,8 @@ GuiSound * Resources::GetSound(const char * filename)
{ {
if(strcasecmp(filename, RecourceList[i].filename) == 0) if(strcasecmp(filename, RecourceList[i].filename) == 0)
{ {
const u8 * buff = RecourceList[i].CustomFile ? RecourceList[i].CustomFile : RecourceList[i].DefaultFile; const uint8_t * buff = RecourceList[i].CustomFile ? RecourceList[i].CustomFile : RecourceList[i].DefaultFile;
const u32 size = RecourceList[i].CustomFile ? RecourceList[i].CustomFileSize : RecourceList[i].DefaultFileSize; const uint32_t size = RecourceList[i].CustomFile ? RecourceList[i].CustomFileSize : RecourceList[i].DefaultFileSize;
if(buff == NULL) if(buff == NULL)
return NULL; return NULL;

View File

@ -2,7 +2,6 @@
#define RECOURCES_H_ #define RECOURCES_H_
#include <map> #include <map>
#include "common/types.h"
//! forward declaration //! forward declaration
class GuiImageData; class GuiImageData;
@ -13,8 +12,8 @@ class Resources
public: public:
static void Clear(); static void Clear();
static bool LoadFiles(const char * path); static bool LoadFiles(const char * path);
static const u8 * GetFile(const char * filename); static const uint8_t * GetFile(const char * filename);
static u32 GetFileSize(const char * filename); static uint32_t GetFileSize(const char * filename);
static GuiImageData * GetImageData(const char * filename); static GuiImageData * GetImageData(const char * filename);
static void RemoveImageData(GuiImageData * image); static void RemoveImageData(GuiImageData * image);

View File

@ -1,143 +0,0 @@
/***************************************************************************
* 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 <unistd.h>
#include <malloc.h>
#include "utils/utils.h"
#include "BufferCircle.hpp"
BufferCircle::BufferCircle()
{
which = 0;
BufferBlockSize = 0;
}
BufferCircle::~BufferCircle()
{
FreeBuffer();
SoundBuffer.clear();
BufferSize.clear();
BufferReady.clear();
}
void BufferCircle::SetBufferBlockSize(int size)
{
if(size < 0)
return;
BufferBlockSize = size;
for(int i = 0; i < Size(); i++)
{
if(SoundBuffer[i] != NULL)
free(SoundBuffer[i]);
SoundBuffer[i] = (u8 *) memalign(32, ALIGN32(BufferBlockSize));
BufferSize[i] = 0;
BufferReady[i] = false;
}
}
void BufferCircle::Resize(int size)
{
while(size < Size())
RemoveBuffer(Size()-1);
int oldSize = Size();
SoundBuffer.resize(size);
BufferSize.resize(size);
BufferReady.resize(size);
for(int i = oldSize; i < Size(); i++)
{
if(BufferBlockSize > 0)
SoundBuffer[i] = (u8 *) memalign(32, ALIGN32(BufferBlockSize));
else
SoundBuffer[i] = NULL;
BufferSize[i] = 0;
BufferReady[i] = false;
}
}
void BufferCircle::RemoveBuffer(int 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(int i = 0; i < Size(); i++)
{
BufferSize[i] = 0;
BufferReady[i] = false;
}
which = 0;
}
void BufferCircle::FreeBuffer()
{
for(int 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(int pos, bool state)
{
if(!Valid(pos))
return;
BufferReady[pos] = state;
}
void BufferCircle::SetBufferSize(int pos, int size)
{
if(!Valid(pos))
return;
BufferSize[pos] = size;
}

View File

@ -1,86 +0,0 @@
/***************************************************************************
* 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 <vector>
#include "common/types.h"
class BufferCircle
{
public:
//!> Constructor
BufferCircle();
//!> Destructor
~BufferCircle();
//!> Set circle size
void Resize(int size);
//!> Get the circle size
int Size() { return SoundBuffer.size(); };
//!> Set/resize the buffer size
void SetBufferBlockSize(int size);
//!> Remove a buffer
void RemoveBuffer(int pos);
//!> Set all buffers clear
void ClearBuffer();
//!> Free all buffers
void FreeBuffer();
//!> Switch to next buffer
void LoadNext();
//!> Get the current buffer
u8 * GetBuffer() { return GetBuffer(which); };
//!> Get a buffer at a position
u8 * GetBuffer(int pos) { if(!Valid(pos)) return NULL; else return SoundBuffer[pos]; };
//!> Get current buffer size
u32 GetBufferSize() { return GetBufferSize(which); };
//!> Get buffer size at position
u32 GetBufferSize(int 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(int pos) { if(!Valid(pos)) return false; else return BufferReady[pos]; };
//!> Set a buffer at a position to a ready state
void SetBufferReady(int pos, bool st);
//!> Set the buffersize at a position
void SetBufferSize(int pos, int size);
//!> Get the current position in the circle
u16 Which() { return which; };
//!> Get the next location
inline u16 Next() { return (which+1 >= Size()) ? 0 : which+1; }
inline u16 Prev() { if(Size() == 0) return 0; else return ((int)which-1 < 0) ? Size()-1 : which-1; }
protected:
//!> Check if the position is a valid position in the vector
bool Valid(int pos) { return !(pos < 0 || pos >= Size()); };
u16 which;
u32 BufferBlockSize;
std::vector<u8 *> SoundBuffer;
std::vector<u32> BufferSize;
std::vector<bool> BufferReady;
};
#endif

View File

@ -1,217 +0,0 @@
/***************************************************************************
* 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 <string>
#include <string.h>
#include <limits.h>
#include <unistd.h>
#include <malloc.h>
#include <math.h>
#include "common/types.h"
#include "Mp3Decoder.hpp"
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 u8 * snd, int 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)
usleep(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 = (u8 *) memalign(32, SoundBlockSize*SoundBlocks);
if(!ReadBuffer)
{
if(file_fd)
delete file_fd;
file_fd = NULL;
return;
}
u8 dummybuff[4096];
int ret = Read(dummybuff, 4096, 0);
if(ret <= 0)
{
if(file_fd)
delete file_fd;
file_fd = NULL;
return;
}
SampleRate = (u32) Frame.header.samplerate;
Format = ((MAD_NCHANNELS(&Frame.header) == 2) ? (FORMAT_PCM_16_BIT | CHANNELS_STEREO) : (FORMAT_PCM_16_BIT | CHANNELS_MONO));
Rewind();
}
int 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 s16 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((s16)Fixed);
}
int Mp3Decoder::Read(u8 * buffer, int buffer_size, int pos)
{
if(!file_fd)
return -1;
if(Format == (FORMAT_PCM_16_BIT | CHANNELS_STEREO))
buffer_size &= ~0x0003;
else
buffer_size &= ~0x0001;
u8 * write_pos = buffer;
u8 * write_end = buffer+buffer_size;
while(1)
{
while(SynthPos < Synth.pcm.length)
{
if(write_pos >= write_end)
return write_pos-buffer;
*((s16 *) write_pos) = FixedToShort(Synth.pcm.samples[0][SynthPos]);
write_pos += 2;
if(MAD_NCHANNELS(&Frame.header) == 2)
{
*((s16 *) write_pos) = FixedToShort(Synth.pcm.samples[1][SynthPos]);
write_pos += 2;
}
SynthPos++;
}
if(Stream.buffer == NULL || Stream.error == MAD_ERROR_BUFLEN)
{
u8 * ReadStart = ReadBuffer;
int ReadSize = SoundBlockSize*SoundBlocks;
int 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;
}

View File

@ -1,47 +0,0 @@
/***************************************************************************
* 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 "SoundDecoder.hpp"
class Mp3Decoder : public SoundDecoder
{
public:
Mp3Decoder(const char * filepath);
Mp3Decoder(const u8 * sound, int len);
virtual ~Mp3Decoder();
int Rewind();
int Read(u8 * buffer, int buffer_size, int pos);
protected:
void OpenFile();
struct mad_stream Stream;
struct mad_frame Frame;
struct mad_synth Synth;
mad_timer_t Timer;
u8 * GuardPtr;
u8 * ReadBuffer;
u32 SynthPos;
};

View File

@ -1,137 +0,0 @@
/***************************************************************************
* 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 <unistd.h>
#include <malloc.h>
#include "OggDecoder.hpp"
static int ogg_read(void * punt, int bytes, int blocks, int *f)
{
return ((CFile *) f)->read((u8 *) punt, bytes*blocks);
}
static int ogg_seek(int *f, ogg_int64_t offset, int mode)
{
return ((CFile *) f)->seek((u64) 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 u8 * snd, int len)
: SoundDecoder(snd, len)
{
SoundType = SOUND_OGG;
if(!file_fd)
return;
OpenFile();
}
OggDecoder::~OggDecoder()
{
ExitRequested = true;
while(Decoding)
usleep(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;
}
int OggDecoder::Rewind()
{
if(!file_fd)
return -1;
int ret = ov_time_seek(&ogg_file, 0);
CurPos = 0;
EndOfFile = false;
return ret;
}
int OggDecoder::Read(u8 * buffer, int buffer_size, int pos)
{
if(!file_fd)
return -1;
int bitstream = 0;
int read = ov_read(&ogg_file, (char *) buffer, buffer_size, &bitstream);
if(read > 0)
CurPos += read;
return read;
}

View File

@ -1,43 +0,0 @@
/***************************************************************************
* 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 "SoundDecoder.hpp"
class OggDecoder : public SoundDecoder
{
public:
OggDecoder(const char * filepath);
OggDecoder(const u8 * snd, int len);
virtual ~OggDecoder();
int Rewind();
int Read(u8 * buffer, int buffer_size, int pos);
protected:
void OpenFile();
OggVorbis_File ogg_file;
vorbis_info *ogg_info;
};

View File

@ -1,224 +0,0 @@
/****************************************************************************
* 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 <malloc.h>
#include <string.h>
#include <unistd.h>
#include <coreinit/cache.h>
#include "SoundDecoder.hpp"
static const u32 FixedPointShift = 15;
static const u32 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 u8 * buffer, int size)
{
file_fd = new CFile(buffer, size);
Init();
}
SoundDecoder::~SoundDecoder()
{
ExitRequested = true;
while(Decoding)
usleep(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);
}
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;
}
int SoundDecoder::Rewind()
{
CurPos = 0;
EndOfFile = false;
file_fd->rewind();
return 0;
}
int SoundDecoder::Read(u8 * buffer, int buffer_size, int pos)
{
int 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 = (u8*)memalign(32, SoundBlockSize);
ResampleRatio = ( FixedPointScale * SampleRate ) / 48000;
SoundBlockSize = ( SoundBlockSize * ResampleRatio ) / FixedPointScale;
SoundBlockSize &= ~0x03;
// set new sample rate
SampleRate = 48000;
}
}
void SoundDecoder::Upsample(s16 *src, s16 *dst, u32 nr_src_samples, u32 nr_dst_samples)
{
int timer = 0;
for(u32 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 >= (int)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)
u16 whichPlaying = SoundBuffer.Which();
if( ((whichPlaying == 0) && (whichLoad == SoundBuffer.Size()-2))
|| ((whichPlaying == 1) && (whichLoad == SoundBuffer.Size()-1))
|| (whichLoad == (whichPlaying-2)))
{
return;
}
Decoding = true;
int done = 0;
u8 * write_buf = SoundBuffer.GetBuffer(whichLoad);
if(!write_buf)
{
ExitRequested = true;
Decoding = false;
return;
}
if(ResampleTo48kHz && !ResampleBuffer)
EnableUpsample();
while(done < SoundBlockSize)
{
int 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);
int src_samples = done >> 1;
int dest_samples = ( src_samples * FixedPointScale ) / ResampleRatio;
dest_samples &= ~0x01;
Upsample((s16*)ResampleBuffer, (s16*)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())
{
s16* monoBuf = (s16*)write_buf;
done = done >> 1;
for(int 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;
}

View File

@ -1,105 +0,0 @@
/***************************************************************************
* 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 "fs/CFile.hpp"
#include "system/CMutex.h"
#include "BufferCircle.hpp"
class SoundDecoder
{
public:
SoundDecoder();
SoundDecoder(const std::string & filepath);
SoundDecoder(const u8 * buffer, int size);
virtual ~SoundDecoder();
virtual void Lock() { mutex.lock(); }
virtual void Unlock() { mutex.unlock(); }
virtual int Read(u8 * buffer, int buffer_size, int pos);
virtual int Tell() { return CurPos; }
virtual int Seek(int pos) { CurPos = pos; return file_fd->seek(CurPos, SEEK_SET); }
virtual int Rewind();
virtual u16 GetFormat() { return Format; }
virtual u16 GetSampleRate() { return SampleRate; }
virtual void Decode();
virtual bool IsBufferReady() { return SoundBuffer.IsBufferReady(); }
virtual u8 * GetBuffer() { return SoundBuffer.GetBuffer(); }
virtual u32 GetBufferSize() { return SoundBuffer.GetBufferSize(); }
virtual void LoadNext() { SoundBuffer.LoadNext(); }
virtual bool IsEOF() { return EndOfFile; }
virtual void SetLoop(bool l) { Loop = l; EndOfFile = false; }
virtual u8 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(s16 *src, s16 *dst, u32 nr_src_samples, u32 nr_dst_samples);
CFile * file_fd;
BufferCircle SoundBuffer;
u8 SoundType;
u16 whichLoad;
u16 SoundBlocks;
int SoundBlockSize;
int CurPos;
bool ResampleTo48kHz;
bool Loop;
bool EndOfFile;
bool Decoding;
bool ExitRequested;
u16 Format;
u16 SampleRate;
u8 *ResampleBuffer;
u32 ResampleRatio;
CMutex mutex;
};
#endif

View File

@ -1,351 +0,0 @@
/***************************************************************************
* 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 <unistd.h>
#include <malloc.h>
#include "common/common.h"
#include "fs/CFile.hpp"
#include "SoundHandler.hpp"
#include "WavDecoder.hpp"
#include "Mp3Decoder.hpp"
#include "OggDecoder.hpp"
SoundHandler * SoundHandler::handlerInstance = NULL;
SoundHandler::SoundHandler()
: CThread(CThread::eAttributeAffCore1 | CThread::eAttributePinnedAff, 0, 0x8000)
{
Decoding = false;
ExitRequested = false;
for(u32 i = 0; i < MAX_DECODERS; ++i)
{
DecoderList[i] = NULL;
voiceList[i] = NULL;
}
resumeThread();
//! wait for initialization
while(!isThreadSuspended())
usleep(1000);
}
SoundHandler::~SoundHandler()
{
ExitRequested = true;
ThreadSignal();
ClearDecoderList();
}
void SoundHandler::AddDecoder(int voice, const char * filepath)
{
if(voice < 0 || voice >= MAX_DECODERS)
return;
if(DecoderList[voice] != NULL)
RemoveDecoder(voice);
DecoderList[voice] = GetSoundDecoder(filepath);
}
void SoundHandler::AddDecoder(int voice, const u8 * snd, int len)
{
if(voice < 0 || voice >= MAX_DECODERS)
return;
if(DecoderList[voice] != NULL)
RemoveDecoder(voice);
DecoderList[voice] = GetSoundDecoder(snd, len);
}
void SoundHandler::RemoveDecoder(int 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))
usleep(1000);
}
SoundDecoder *decoder = DecoderList[voice];
decoder->Lock();
DecoderList[voice] = NULL;
decoder->Unlock();
delete decoder;
}
}
void SoundHandler::ClearDecoderList()
{
for(u32 i = 0; i < MAX_DECODERS; ++i)
RemoveDecoder(i);
}
static inline bool CheckMP3Signature(const u8 * 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(int 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)
{
u32 magic;
CFile f(filepath, CFile::ReadOnly);
if(f.size() == 0)
return NULL;
do
{
f.read((u8 *) &magic, 1);
}
while(((u8 *) &magic)[0] == 0 && f.tell() < f.size());
if(f.tell() == f.size())
return NULL;
f.seek(f.tell()-1, SEEK_SET);
f.read((u8 *) &magic, 4);
f.close();
if(magic == 0x4f676753) // 'OggS'
{
return new OggDecoder(filepath);
}
else if(magic == 0x52494646) // 'RIFF'
{
return new WavDecoder(filepath);
}
else if(CheckMP3Signature((u8 *) &magic) == true)
{
return new Mp3Decoder(filepath);
}
return new SoundDecoder(filepath);
}
SoundDecoder * SoundHandler::GetSoundDecoder(const u8 * sound, int length)
{
const u8 * check = sound;
int counter = 0;
while(check[0] == 0 && counter < length)
{
check++;
counter++;
}
if(counter >= length)
return NULL;
u32 * magic = (u32 *) 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()
{
//! 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(u32 i = 0; i < MAX_DECODERS; ++i)
{
int priority = (MAX_DECODERS - i) * Voice::PRIO_MAX / MAX_DECODERS;
voiceList[i] = new Voice(priority); // allocate voice 0 with highest priority
}
AXRegisterAppFrameCallback(SoundHandler::axFrameCallback);
u16 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(u32 i = 0; i < MAX_DECODERS; ++i)
voiceList[i]->stop();
AXRegisterAppFrameCallback(NULL);
AXQuit();
for(u32 i = 0; i < MAX_DECODERS; ++i)
{
delete voiceList[i];
voiceList[i] = NULL;
}
}
void SoundHandler::axFrameCallback(void)
{
for (u32 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 u8 *buffer = decoder->GetBuffer();
const u32 bufferSize = decoder->GetBufferSize();
decoder->LoadNext();
const u8 *nextBuffer = NULL;
u32 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;
}
}
}

View File

@ -1,78 +0,0 @@
/***************************************************************************
* 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 "common/types.h"
#include "system/CThread.h"
#include "SoundDecoder.hpp"
#include "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(int voice, const char * filepath);
void AddDecoder(int voice, const u8 * snd, int len);
void RemoveDecoder(int voice);
SoundDecoder * getDecoder(int i) { return ((i < 0 || i >= MAX_DECODERS) ? NULL : DecoderList[i]); };
Voice * getVoice(int 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 u8 * sound, int length);
static SoundHandler * handlerInstance;
bool Decoding;
bool ExitRequested;
Voice * voiceList[MAX_DECODERS];
SoundDecoder * DecoderList[MAX_DECODERS];
};
#endif

View File

@ -1,164 +0,0 @@
/****************************************************************************
* 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(int prio)
: state(STATE_STOPPED)
{
lastLoopCounter = 0;
nextBufferSize = 0;
voice = AXAcquireVoice(prio, 0, 0);
if(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);
}
}
~Voice()
{
if(voice)
{
AXFreeVoice(voice);
}
}
void play(const u8 *buffer, u32 bufferSize, const u8 *nextBuffer, u32 nextBufSize, u16 format, u32 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
//u32 samplesPerSec = (AXGetInputSamplesPerSec != 0) ? AXGetInputSamplesPerSec() : 32000;
u32 samplesPerSec = AXGetInputSamplesPerSec();
memset(&ratioBits, 0, sizeof(ratioBits));
ratioBits.ratio = (u32)(0x00010000 * ((f32)sampleRate / (f32)samplesPerSec));
AXSetVoiceOffsets(voice, &voiceBuffer);
AXSetVoiceSrc(voice, &ratioBits);
AXSetVoiceSrcType(voice, 1);
AXSetVoiceState(voice, 1);
}
void stop()
{
if(voice)
AXSetVoiceState(voice, 0);
}
void setVolume(u32 vol)
{
if(voice)
{
AXVoiceVeData data;
data.volume = vol >> 16;
data.delta = vol & 0xFFFF;
AXSetVoiceVe(voice, &data);
}
}
void setNextBuffer(const u8 *buffer, u32 bufferSize)
{
voiceBuffer.loopOffset = ((buffer - (const u8*)voiceBuffer.data) >> 1);
nextBufferSize = bufferSize;
AXSetVoiceLoopOffset(voice, voiceBuffer.loopOffset);
}
bool isBufferSwitched()
{
u32 loopCounter = AXGetVoiceLoopCount(voice);
if(lastLoopCounter != loopCounter)
{
lastLoopCounter = loopCounter;
AXSetVoiceEndOffset(voice, voiceBuffer.loopOffset + (nextBufferSize >> 1) - 1);
return true;
}
return false;
}
u32 getInternState() const {
if(voice)
return ((u32 *)voice)[1];
return 0;
}
u32 getState() const {
return state;
}
void setState(u32 s) {
state = s;
}
void * getVoice() const {
return voice;
}
private:
AXVoice *voice;
AXVoiceSrc ratioBits;
AXVoiceOffsets voiceBuffer;
u32 state;
u32 nextBufferSize;
u32 lastLoopCounter;
};
#endif // _AXSOUND_H_

View File

@ -1,154 +0,0 @@
/***************************************************************************
* 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 <string.h>
#include "WavDecoder.hpp"
#include "utils/utils.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 u8 * snd, int 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((u8 *) &Header, sizeof(SWaveHdr));
file_fd->read((u8 *) &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((u8 *) &DataChunk, sizeof(SWaveChunk));
while(DataChunk.magicDATA != 0x64617461) // 'data'
{
DataOffset += 8+le32(DataChunk.size);
file_fd->seek(DataOffset, SEEK_SET);
int ret = file_fd->read((u8 *) &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;
}
int WavDecoder::Read(u8 * buffer, int buffer_size, int pos)
{
if(!file_fd)
return -1;
if(CurPos >= (int) DataSize)
return 0;
file_fd->seek(DataOffset+CurPos, SEEK_SET);
if(buffer_size > (int) DataSize-CurPos)
buffer_size = DataSize-CurPos;
int read = file_fd->read(buffer, buffer_size);
if(read > 0)
{
if (Is16Bit)
{
read &= ~0x0001;
for (u32 i = 0; i < (u32) (read / sizeof (u16)); ++i)
((u16 *) buffer)[i] = le16(((u16 *) buffer)[i]);
}
CurPos += read;
}
return read;
}

View File

@ -1,71 +0,0 @@
/***************************************************************************
* 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 "SoundDecoder.hpp"
typedef struct
{
u32 magicRIFF;
u32 size;
u32 magicWAVE;
} SWaveHdr;
typedef struct
{
u32 magicFMT;
u32 size;
u16 format;
u16 channels;
u32 freq;
u32 avgBps;
u16 alignment;
u16 bps;
} SWaveFmtChunk;
typedef struct
{
u32 magicDATA;
u32 size;
} SWaveChunk;
class WavDecoder : public SoundDecoder
{
public:
WavDecoder(const char * filepath);
WavDecoder(const u8 * snd, int len);
virtual ~WavDecoder();
int Read(u8 * buffer, int buffer_size, int pos);
protected:
void OpenFile();
void CloseFile();
u32 DataOffset;
u32 DataSize;
bool Is16Bit;
};
#endif

View File

@ -14,33 +14,29 @@
* You should have received a copy of the GNU General Public License * You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/ ****************************************************************************/
#include "AsyncDeleter.h" #include <system/AsyncDeleter.h>
AsyncDeleter * AsyncDeleter::deleterInstance = NULL; AsyncDeleter * AsyncDeleter::deleterInstance = NULL;
AsyncDeleter::AsyncDeleter() AsyncDeleter::AsyncDeleter()
: CThread(CThread::eAttributeAffCore1 | CThread::eAttributePinnedAff) : CThread(CThread::eAttributeAffCore1 | CThread::eAttributePinnedAff)
, exitApplication(false) , exitApplication(false) {
{
} }
AsyncDeleter::~AsyncDeleter() AsyncDeleter::~AsyncDeleter() {
{
exitApplication = true; exitApplication = true;
} }
void AsyncDeleter::triggerDeleteProcess(void) void AsyncDeleter::triggerDeleteProcess(void) {
{ if(!deleterInstance){
if(!deleterInstance) return;
deleterInstance = new AsyncDeleter; }
//! to trigger the event after GUI process is finished execution //! to trigger the event after GUI process is finished execution
//! this function is used to swap elements from one to next array //! this function is used to swap elements from one to next array
if(!deleterInstance->deleteElements.empty()) if(!deleterInstance->deleteElements.empty()) {
{
deleterInstance->deleteMutex.lock(); deleterInstance->deleteMutex.lock();
while(!deleterInstance->deleteElements.empty()) while(!deleterInstance->deleteElements.empty()) {
{
deleterInstance->realDeleteElements.push(deleterInstance->deleteElements.front()); deleterInstance->realDeleteElements.push(deleterInstance->deleteElements.front());
deleterInstance->deleteElements.pop(); deleterInstance->deleteElements.pop();
} }
@ -49,16 +45,12 @@ void AsyncDeleter::triggerDeleteProcess(void)
} }
} }
void AsyncDeleter::executeThread(void) void AsyncDeleter::executeThread(void) {
{ while(!exitApplication || !realDeleteElements.empty()) {
while(!exitApplication) if(realDeleteElements.empty()) suspendThread();
{
suspendThread();
//! delete elements that require post process deleting //! delete elements that require post process deleting
//! because otherwise they would block or do invalid access on GUI thread //! because otherwise they would block or do invalid access on GUI thread
while(!realDeleteElements.empty()) while(!realDeleteElements.empty()) {
{
deleteMutex.lock(); deleteMutex.lock();
AsyncDeleter::Element *element = realDeleteElements.front(); AsyncDeleter::Element *element = realDeleteElements.front();
realDeleteElements.pop(); realDeleteElements.pop();

View File

@ -21,30 +21,42 @@
#include "CThread.h" #include "CThread.h"
#include "CMutex.h" #include "CMutex.h"
class AsyncDeleter : public CThread class AsyncDeleter : public CThread {
{
public: public:
static void destroyInstance() static void destroyInstance() {
{ if(deleterInstance != NULL) {
delete deleterInstance; delete deleterInstance;
deleterInstance = NULL; deleterInstance = NULL;
}
} }
class Element class Element {
{
public: public:
Element() {} Element() {}
virtual ~Element() {} virtual ~Element() {}
}; };
static void pushForDelete(AsyncDeleter::Element *e) static void pushForDelete(AsyncDeleter::Element *e) {
{ if(!deleterInstance) {
if(!deleterInstance) deleterInstance = new AsyncDeleter();
deleterInstance = new AsyncDeleter; }
deleterInstance->deleteElements.push(e); deleterInstance->deleteElements.push(e);
} }
static BOOL deleteListEmpty() {
if(!deleterInstance) {
return true;
}
return deleterInstance->deleteElements.empty();
}
static BOOL realListEmpty() {
if(!deleterInstance) {
return true;
}
return deleterInstance->realDeleteElements.empty();
}
static void triggerDeleteProcess(void); static void triggerDeleteProcess(void);
private: private:
@ -55,7 +67,7 @@ private:
void executeThread(void); void executeThread(void);
bool exitApplication; BOOL exitApplication;
std::queue<AsyncDeleter::Element *> deleteElements; std::queue<AsyncDeleter::Element *> deleteElements;
std::queue<AsyncDeleter::Element *> realDeleteElements; std::queue<AsyncDeleter::Element *> realDeleteElements;
CMutex deleteMutex; CMutex deleteMutex;

View File

@ -43,7 +43,7 @@ public:
if(pMutex) if(pMutex)
OSUnlockMutex(pMutex); OSUnlockMutex(pMutex);
} }
bool tryLock(void) { BOOL tryLock(void) {
if(!pMutex) if(!pMutex)
return false; return false;

View File

@ -17,103 +17,117 @@
#ifndef CTHREAD_H_ #ifndef CTHREAD_H_
#define CTHREAD_H_ #define CTHREAD_H_
#include <malloc.h> #include <malloc.h>
#include <unistd.h> #include <unistd.h>
#include <coreinit/systeminfo.h>
#include <coreinit/thread.h> #include <coreinit/thread.h>
class CThread class CThread {
{
public: public:
typedef void (* Callback)(CThread *thread, void *arg); typedef void (* Callback)(CThread *thread, void *arg);
//! constructor //! constructor
CThread(int iAttr, int iPriority = 16, int iStackSize = 0x8000, CThread::Callback callback = NULL, void *callbackArg = NULL) CThread(int32_t iAttr, int32_t iPriority = 16, int32_t iStackSize = 0x8000, CThread::Callback callback = NULL, void *callbackArg = NULL)
: pThread(NULL) : pThread(NULL)
, pThreadStack(NULL) , pThreadStack(NULL)
, pCallback(callback) , pCallback(callback)
, pCallbackArg(callbackArg) , pCallbackArg(callbackArg) {
{ //! save attribute assignment
//! save attribute assignment iAttributes = iAttr;
iAttributes = iAttr; //! allocate the thread
//! allocate the thread pThread = (OSThread*)memalign(8, sizeof(OSThread));
pThread = (OSThread*)memalign(8, sizeof(OSThread)); //! allocate the stack
//! allocate the stack pThreadStack = (uint8_t *) memalign(0x20, iStackSize);
pThreadStack = (u8 *) memalign(0x20, iStackSize);
//! create the thread //! create the thread
if(pThread && pThreadStack) if(pThread && pThreadStack)
OSCreateThread(pThread, &CThread::threadCallback, 1, (char*)this, pThreadStack+iStackSize, iStackSize, iPriority, iAttributes); OSCreateThread(pThread, &CThread::threadCallback, 1, (char*)this, pThreadStack+iStackSize, iStackSize, iPriority, iAttributes);
} }
//! destructor //! destructor
virtual ~CThread() { shutdownThread(); } virtual ~CThread() {
shutdownThread();
}
static CThread *create(CThread::Callback callback, void *callbackArg, int iAttr = eAttributeNone, int iPriority = 16, int iStackSize = 0x8000) static CThread *create(CThread::Callback callback, void *callbackArg, int32_t iAttr = eAttributeNone, int32_t iPriority = 16, int32_t iStackSize = 0x8000) {
{ return ( new CThread(iAttr, iPriority, iStackSize, callback, callbackArg) );
return ( new CThread(iAttr, iPriority, iStackSize, callback, callbackArg) ); }
}
//! Get thread ID //! Get thread ID
virtual void* getThread() const { return pThread; } virtual void* getThread() const {
//! Thread entry function return pThread;
virtual void executeThread(void) }
{ //! Thread entry function
if(pCallback) virtual void executeThread(void) {
if(pCallback)
pCallback(this, pCallbackArg); pCallback(this, pCallbackArg);
} }
//! Suspend thread //! Suspend thread
virtual void suspendThread(void) { if(isThreadSuspended()) return; if(pThread) OSSuspendThread(pThread); } virtual void suspendThread(void) {
//! Resume thread if(isThreadSuspended()) return;
virtual void resumeThread(void) { if(!isThreadSuspended()) return; if(pThread) OSResumeThread(pThread); } if(pThread) OSSuspendThread(pThread);
//! Set thread priority }
virtual void setThreadPriority(int prio) { if(pThread) OSSetThreadPriority(pThread, prio); } //! Resume thread
//! Check if thread is suspended virtual void resumeThread(void) {
virtual bool isThreadSuspended(void) const { if(pThread) return OSIsThreadSuspended(pThread); return false; } if(!isThreadSuspended()) return;
//! Check if thread is terminated if(pThread) OSResumeThread(pThread);
virtual bool isThreadTerminated(void) const { if(pThread) return OSIsThreadTerminated(pThread); return false; } }
//! Check if thread is running //! Set thread priority
virtual bool isThreadRunning(void) const { return !isThreadSuspended() && !isThreadRunning(); } virtual void setThreadPriority(int prio) {
//! Shutdown thread if(pThread) OSSetThreadPriority(pThread, prio);
virtual void shutdownThread(void) }
{ //! Check if thread is suspended
//! wait for thread to finish virtual BOOL isThreadSuspended(void) const {
if(pThread && !(iAttributes & eAttributeDetach)) if(pThread) return OSIsThreadSuspended(pThread);
{ return false;
if(isThreadSuspended()) }
//! Check if thread is terminated
virtual BOOL isThreadTerminated(void) const {
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())
resumeThread(); resumeThread();
OSJoinThread(pThread, NULL); OSJoinThread(pThread, NULL);
} }
//! free the thread stack buffer //! free the thread stack buffer
if(pThreadStack) if(pThreadStack)
free(pThreadStack); free(pThreadStack);
if(pThread) if(pThread)
free(pThread); free(pThread);
pThread = NULL; pThread = NULL;
pThreadStack = NULL; pThreadStack = NULL;
} }
//! Thread attributes //! Thread attributes
enum eCThreadAttributes enum eCThreadAttributes {
{ eAttributeNone = 0x07,
eAttributeNone = 0x07, eAttributeAffCore0 = 0x01,
eAttributeAffCore0 = 0x01, eAttributeAffCore1 = 0x02,
eAttributeAffCore1 = 0x02, eAttributeAffCore2 = 0x04,
eAttributeAffCore2 = 0x04, eAttributeDetach = 0x08,
eAttributeDetach = 0x08, eAttributePinnedAff = 0x10
eAttributePinnedAff = 0x10 };
};
private: private:
static int threadCallback(int argc, const char **argv) static int threadCallback(int argc, const char **argv) {
{ //! After call to start() continue with the internal function
//! After call to start() continue with the internal function ((CThread *) argv)->executeThread();
((CThread *) argv)->executeThread(); return 0;
return 0; }
}
int iAttributes; int iAttributes;
OSThread *pThread; OSThread *pThread;
u8 *pThreadStack; uint8_t *pThreadStack;
Callback pCallback; Callback pCallback;
void *pCallbackArg; void *pCallbackArg;
}; };
#endif #endif

View File

@ -1,169 +0,0 @@
#include <stdio.h>
#include "common/types.h"
#include "exception_handler.h"
#define OS_EXCEPTION_MODE_GLOBAL_ALL_CORES 4
#define OS_EXCEPTION_DSI 2
#define OS_EXCEPTION_ISI 3
#define OS_EXCEPTION_PROGRAM 6
/* Exceptions */
typedef struct OSContext
{
/* OSContext identifier */
uint32_t tag1;
uint32_t tag2;
/* GPRs */
uint32_t gpr[32];
/* Special registers */
uint32_t cr;
uint32_t lr;
uint32_t ctr;
uint32_t xer;
/* Initial PC and MSR */
uint32_t srr0;
uint32_t srr1;
/* Only valid during DSI exception */
uint32_t exception_specific0;
uint32_t exception_specific1;
/* There is actually a lot more here but we don't need the rest*/
} OSContext;
#include <coreinit/exception.h>
#include <coreinit/debug.h>
#define CPU_STACK_TRACE_DEPTH 10
#define __stringify(rn) #rn
#define mfspr(_rn) \
({ register uint32_t _rval = 0; \
asm volatile("mfspr %0," __stringify(_rn) \
: "=r" (_rval));\
_rval; \
})
typedef struct _framerec {
struct _framerec *up;
void *lr;
} frame_rec, *frame_rec_t;
static const char *exception_names[] = {
"DSI",
"ISI",
"PROGRAM"
};
static const char exception_print_formats[18][45] = {
"Exception type %s occurred!\n", // 0
"GPR00 %08X GPR08 %08X GPR16 %08X GPR24 %08X\n", // 1
"GPR01 %08X GPR09 %08X GPR17 %08X GPR25 %08X\n", // 2
"GPR02 %08X GPR10 %08X GPR18 %08X GPR26 %08X\n", // 3
"GPR03 %08X GPR11 %08X GPR19 %08X GPR27 %08X\n", // 4
"GPR04 %08X GPR12 %08X GPR20 %08X GPR28 %08X\n", // 5
"GPR05 %08X GPR13 %08X GPR21 %08X GPR29 %08X\n", // 6
"GPR06 %08X GPR14 %08X GPR22 %08X GPR30 %08X\n", // 7
"GPR07 %08X GPR15 %08X GPR23 %08X GPR31 %08X\n", // 8
"LR %08X SRR0 %08x SRR1 %08x\n", // 9
"DAR %08X DSISR %08X\n", // 10
"\nSTACK DUMP:", // 11
" --> ", // 12
" -->\n", // 13
"\n", // 14
"%p", // 15
"\nCODE DUMP:\n", // 16
"%p: %08X %08X %08X %08X\n", // 17
};
static unsigned char exception_cb(OSContext * context, unsigned char exception_type) {
char buf[850];
int pos = 0;
/*
* This part is mostly from libogc. Thanks to the devs over there.
*/
pos += sprintf(buf + pos, exception_print_formats[0], exception_names[exception_type]);
pos += sprintf(buf + pos, exception_print_formats[1], context->gpr[0], context->gpr[8], context->gpr[16], context->gpr[24]);
pos += sprintf(buf + pos, exception_print_formats[2], context->gpr[1], context->gpr[9], context->gpr[17], context->gpr[25]);
pos += sprintf(buf + pos, exception_print_formats[3], context->gpr[2], context->gpr[10], context->gpr[18], context->gpr[26]);
pos += sprintf(buf + pos, exception_print_formats[4], context->gpr[3], context->gpr[11], context->gpr[19], context->gpr[27]);
pos += sprintf(buf + pos, exception_print_formats[5], context->gpr[4], context->gpr[12], context->gpr[20], context->gpr[28]);
pos += sprintf(buf + pos, exception_print_formats[6], context->gpr[5], context->gpr[13], context->gpr[21], context->gpr[29]);
pos += sprintf(buf + pos, exception_print_formats[7], context->gpr[6], context->gpr[14], context->gpr[22], context->gpr[30]);
pos += sprintf(buf + pos, exception_print_formats[8], context->gpr[7], context->gpr[15], context->gpr[23], context->gpr[31]);
pos += sprintf(buf + pos, exception_print_formats[9], context->lr, context->srr0, context->srr1);
//if(exception_type == OS_EXCEPTION_DSI) {
pos += sprintf(buf + pos, exception_print_formats[10], context->exception_specific1, context->exception_specific0); // this freezes
//}
void *pc = (void*)context->srr0;
void *lr = (void*)context->lr;
void *r1 = (void*)context->gpr[1];
register uint32_t i = 0;
register frame_rec_t l,p = (frame_rec_t)lr;
l = p;
p = r1;
if(!p)
asm volatile("mr %0,%%r1" : "=r"(p));
pos += sprintf(buf + pos, exception_print_formats[11]);
for(i = 0; i < CPU_STACK_TRACE_DEPTH-1 && p->up; p = p->up, i++) {
if(i % 4)
pos += sprintf(buf + pos, exception_print_formats[12]);
else {
if(i > 0)
pos += sprintf(buf + pos, exception_print_formats[13]);
else
pos += sprintf(buf + pos, exception_print_formats[14]);
}
switch(i) {
case 0:
if(pc)
pos += sprintf(buf + pos, exception_print_formats[15],pc);
break;
case 1:
if(!l)
l = (frame_rec_t)mfspr(8);
pos += sprintf(buf + pos, exception_print_formats[15],(void*)l);
break;
default:
pos += sprintf(buf + pos, exception_print_formats[15],(void*)(p->up->lr));
break;
}
}
//if(exception_type == OS_EXCEPTION_DSI) {
uint32_t *pAdd = (uint32_t*)context->srr0;
pos += sprintf(buf + pos, exception_print_formats[16]);
// TODO by Dimok: this was actually be 3 instead of 2 lines in libogc .... but there is just no more space anymore on the screen
for (i = 0; i < 8; i += 4)
pos += sprintf(buf + pos, exception_print_formats[17], &(pAdd[i]),pAdd[i], pAdd[i+1], pAdd[i+2], pAdd[i+3]);
//}
OSFatal(buf);
return 1;
}
static unsigned char dsi_exception_cb(void * context) {
return exception_cb(context, 0);
}
static unsigned char isi_exception_cb(void * context) {
return exception_cb(context, 1);
}
static unsigned char program_exception_cb(void * context) {
return exception_cb(context, 2);
}
void setup_os_exceptions(void) {
OSSetExceptionCallback(OS_EXCEPTION_DSI, (OSExceptionCallbackFn)dsi_exception_cb);
OSSetExceptionCallback(OS_EXCEPTION_ISI, (OSExceptionCallbackFn)isi_exception_cb);
OSSetExceptionCallback(OS_EXCEPTION_PROGRAM, (OSExceptionCallbackFn)program_exception_cb);
}

View File

@ -1,14 +0,0 @@
#ifndef __EXCEPTION_HANDLER_H_
#define __EXCEPTION_HANDLER_H_
#ifdef __cplusplus
extern "C" {
#endif
void setup_os_exceptions(void);
#ifdef __cplusplus
}
#endif
#endif

View File

@ -17,10 +17,8 @@
#include <malloc.h> #include <malloc.h>
#include <string.h> #include <string.h>
#include <coreinit/memheap.h> #include <coreinit/memheap.h>
#include <coreinit/baseheap.h> #include <coreinit/memfrmheap.h>
#include <coreinit/expandedheap.h> #include <coreinit/memexpheap.h>
#include <coreinit/frameheap.h>
#include "common/common.h"
#include "memory.h" #include "memory.h"
#define MEMORY_ARENA_1 0 #define MEMORY_ARENA_1 0
@ -37,14 +35,14 @@
//! Memory functions //! Memory functions
//! This is the only place where those are needed so lets keep them more or less private //! This is the only place where those are needed so lets keep them more or less private
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
static MEMExpandedHeap * mem1_heap = NULL; static MEMHeapHandle mem1_heap = NULL;
static MEMExpandedHeap * bucket_heap = NULL; static MEMHeapHandle bucket_heap = NULL;
void memoryInitialize(void) void memoryInitialize(void)
{ {
if(!mem1_heap) if(!mem1_heap)
{ {
MEMFrameHeap * mem1_heap_handle = MEMGetBaseHeapHandle(MEMORY_ARENA_1); MEMHeapHandle mem1_heap_handle = MEMGetBaseHeapHandle(MEMORY_ARENA_1);
unsigned int mem1_allocatable_size = MEMGetAllocatableSizeForFrmHeapEx(mem1_heap_handle, 4); unsigned int mem1_allocatable_size = MEMGetAllocatableSizeForFrmHeapEx(mem1_heap_handle, 4);
void *mem1_memory = MEMAllocFromFrmHeapEx(mem1_heap_handle, mem1_allocatable_size, 4); void *mem1_memory = MEMAllocFromFrmHeapEx(mem1_heap_handle, mem1_allocatable_size, 4);
if(mem1_memory) if(mem1_memory)
@ -53,7 +51,7 @@ void memoryInitialize(void)
if(!bucket_heap) if(!bucket_heap)
{ {
MEMFrameHeap * bucket_heap_handle = MEMGetBaseHeapHandle(MEMORY_ARENA_FG_BUCKET); MEMHeapHandle bucket_heap_handle = MEMGetBaseHeapHandle(MEMORY_ARENA_FG_BUCKET);
unsigned int bucket_allocatable_size = MEMGetAllocatableSizeForFrmHeapEx(bucket_heap_handle, 4); unsigned int bucket_allocatable_size = MEMGetAllocatableSizeForFrmHeapEx(bucket_heap_handle, 4);
void *bucket_memory = MEMAllocFromFrmHeapEx(bucket_heap_handle, bucket_allocatable_size, 4); void *bucket_memory = MEMAllocFromFrmHeapEx(bucket_heap_handle, bucket_allocatable_size, 4);
if(bucket_memory) if(bucket_memory)

View File

@ -1,397 +0,0 @@
/****************************************************************************
* 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 <malloc.h>
#include <string.h>
#include "common/common.h"
#include "utils/utils.h"
#include "memory_area_table.h"
typedef struct _memory_values_t
{
unsigned int start_address;
unsigned int end_address;
} memory_values_t;
static const memory_values_t mem_vals_400[] =
{
{ 0x2E573BFC, 0x2FF8F83C }, // 26735 kB
{ 0x2D86D318, 0x2DFFFFFC }, // 7755 kB
{ 0x2CE59830, 0x2D3794D8 }, // 5247 kB
{ 0x2D3795AC, 0x2D854300 }, // 4971 kB
{ 0x28FEC800, 0x293B29D0 }, // 3864 kB
{ 0x29BC200C, 0x29D79B94 }, // 1758 kB
{ 0x2A517A68, 0x2A6794B8 }, // 1414 kB
{ 0x288C1D80, 0x28A69FA0 }, // 1696 kB
{ 0, 0 }
};
static const memory_values_t mem_vals_410[] =
{
// { 0x28041760, 0x28049D0C } // 33 kB
// { 0x280608F4, 0x2806C97C } // 48 kB
// { 0x280953C8, 0x280A1324 } // 47 kB
// { 0x280A1358, 0x280AD388 } // 48 kB
// { 0x280C9040, 0x280D0ABC } // 30 kB
// { 0x280D0AD8, 0x28113FBC } // 269 kB
// { 0x2812575C, 0x2817A53C } // 339 kB
// { 0x2817A6A0, 0x281BA53C } // 255 kB
// { 0x281D571C, 0x2820253C } // 179 kB
// { 0x28234D00, 0x2824B33C } // 89 kB
// { 0x2824E300, 0x2828D7BC } // 253 kB
// { 0x282A8DF0, 0x282B63FC } // 53 kB
// { 0x282BC524, 0x282C62FC } // 39 kB
// { 0x2835A988, 0x28366804 } // 47 kB
// { 0x2836E05C, 0x28378DBC } // 43 kB
// { 0x283A735C, 0x284D2A64 } // 1197 kB (1 MB)
// { 0x284D76B0, 0x285021FC } // 170 kB
// { 0x285766A4, 0x28583E4C } // 53 kB
// { 0x28590E5C, 0x2859B248 } // 40 kB
// { 0x2859B288, 0x285AE06C } // 75 kB
// { 0x285B7108, 0x285C0A7C } // 38 kB
// { 0x285C38A0, 0x285D089C } // 52 kB
// { 0x285D0A84, 0x285DC63C } // 46 kB
// { 0x285E0A84, 0x285F089C } // 63 kB
// { 0x285F7FD0, 0x286037D8 } // 46 kB
// { 0x2860E3E4, 0x28621B00 } // 77 kB
// { 0x286287B0, 0x28638BC0 } // 65 kB
// { 0x2863F4A0, 0x2864DE00 } // 58 kB
// { 0x2864F1FC, 0x28656EE0 } // 31 kB
// { 0x2865AF44, 0x286635A0 } // 33 kB
// { 0x2866F774, 0x2867C680 } // 51 kB
// { 0x2867FAC0, 0x286A2CA0 } // 140 kB
// { 0x286B3540, 0x286C1900 } // 56 kB
// { 0x286C64A4, 0x286DDB80 } // 93 kB
// { 0x286E640C, 0x286F1DC0 } // 46 kB
// { 0x286F3884, 0x2870D3C0 } // 102 kB
// { 0x28710824, 0x28719D80 } // 37 kB
// { 0x2872A674, 0x2873B180 } // 66 kB
// { 0x287402F0, 0x28758780 } // 97 kB
// { 0x287652F0, 0x28771C00 } // 50 kB
// { 0x287F878C, 0x2880A680 } // 71 kB
// { 0x2880F4AC, 0x2881E6E0 } // 60 kB
// { 0x28821488, 0x28829A40 } // 33 kB
// { 0x2882A5D0, 0x288385BC } // 55 kB
// { 0x288385D8, 0x28854780 } // 112 kB
// { 0x28857984, 0x28864F80 } // 53 kB
// { 0x28870AC0, 0x2887CAC0 } // 48 kB
// { 0x2887CAC8, 0x28888CC8 } // 48 kB
// { 0x28888CD0, 0x28894ED0 } // 48 kB
// { 0x28894ED8, 0x288BE0DC } // 164 kB
// { 0x288C1C70, 0x28AD9ED4 } // 2144 kB (2 MB)
// { 0x28AD9F04, 0x28B66100 } // 560 kB
// { 0x28B748A8, 0x28B952E0 } // 130 kB
// { 0x28B9AB58, 0x28BA2480 } // 30 kB
// { 0x28BA3D00, 0x28BC21C0 } // 121 kB
// { 0x28BC2F08, 0x28BD9860 } // 90 kB
// { 0x28BED09C, 0x28BFDD00 } // 67 kB
// { 0x28C068F0, 0x28C2E220 } // 158 kB
// { 0x28CC4C6C, 0x28CF6834 } // 198 kB
// { 0x28D3DD64, 0x28D4BF8C } // 56 kB
// { 0x28D83C4C, 0x28DD0284 } // 305 kB
// { 0x28DDDED4, 0x28E84294 } // 664 kB
// { 0x28E99C7C, 0x28F382A4 } // 633 kB
// { 0x28F45EF4, 0x28FEC2B4 } // 664 kB
// { 0x28FEC800, 0x293B2A18 } // 3864 kB (3 MB)
// { 0x293E187C, 0x293EC7FC } // 43 kB
// { 0x295C7240, 0x295D523C } // 56 kB
// { 0x295DA8DC, 0x295E323C } // 34 kB
// { 0x295ED6C0, 0x295F6FDC } // 38 kB
// { 0x29606340, 0x2960FC5C } // 38 kB
// { 0x2964F040, 0x29657C3C } // 35 kB
// { 0x296E0EBC, 0x296EBDBC } // 43 kB
// { 0x2998DFB4, 0x2999DEE4 } // 63 kB
// { 0x2999E6A8, 0x299BE9C4 } // 128 kB
// { 0x29B8DF40, 0x29BA09DC } // 74 kB
// { 0x29BC200C, 0x29D79B94 } // 1758 kB (1 MB)
// { 0x29DA9694, 0x29DB1694 } // 32 kB
// { 0x2A3D7558, 0x2A427558 } // 320 kB
// { 0x2A42769C, 0x2A47769C } // 320 kB
// { 0x2A4777E0, 0x2A4C77E0 } // 320 kB
// { 0x2A4C7924, 0x2A517924 } // 320 kB
// { 0x2A517A68, 0x2A6794B8 } // 1414 kB (1 MB)
// { 0x2AD17528, 0x2AD4EA24 } // 221 kB
// { 0x2B038C4C, 0x2B1794C8 } // 1282 kB (1 MB)
// { 0x2BBA990C, 0x2BBB983C } // 63 kB
// { 0x2BBBA160, 0x2BC82164 } // 800 kB
// { 0x2BD0000C, 0x2BD71638 } // 453 kB
// { 0x2BD7170C, 0x2BD83B0C } // 73 kB
// { 0x2BDBA000, 0x2BDCA028 } // 64 kB
// { 0x2BDCE000, 0x2BDDE028 } // 64 kB
// { 0x2BDE2E34, 0x2BDF2D64 } // 63 kB
// { 0x2BDF35E8, 0x2BE031BC } // 62 kB
// { 0x2BE052A4, 0x2BE151D4 } // 63 kB
// { 0x2BE174AC, 0x2BE27244 } // 63 kB
// { 0x2BE3AC80, 0x2BE48C80 } // 56 kB
// { 0x2BE49EDC, 0x2BE56C7C } // 51 kB
// { 0x2BE82F70, 0x2BE92E9C } // 63 kB
// { 0x2BE9ADBC, 0x2BEA8DBC } // 56 kB
// { 0x2BEAAB7C, 0x2BEB6DBC } // 48 kB
// { 0x2BEC0F3C, 0x2BECEF3C } // 56 kB
// { 0x2BED45DC, 0x2BEDCF3C } // 34 kB
// { 0x2BEE73C0, 0x2BEF0CDC } // 38 kB
// { 0x2BF00040, 0x2BF0995C } // 38 kB
// { 0x2BF48D40, 0x2BF5193C } // 35 kB
// { 0x2BFDABBC, 0x2BFE5ABC } // 43 kB
// { 0x2C03DA40, 0x2C045D7C } // 32 kB
// { 0x2C179450, 0x2C18937C } // 63 kB
// { 0x2C1DC940, 0x2C1EA93C } // 56 kB
// { 0x2C1EABDC, 0x2C1F893C } // 55 kB
// { 0x2C239A80, 0x2C243D3C } // 40 kB
// { 0x2CE10224, 0x2CE3683C } // 153 kB
// { 0x2CE374F4, 0x2CE473A4 } // 63 kB
// { 0x2CE49830, 0x2D3794D8 } // 5311 kB (5 MB)
// { 0x2D3795AC, 0x2D854300 } // 4971 kB (4 MB)
// { 0x2D8546B0, 0x2D8602C4 } // 47 kB
// { 0x2D86D318, 0x2DFFFFFC } // 7755 kB (7 MB)
// { 0x2E2DCD60, 0x2E2E4D7C } // 32 kB
// { 0x2E33F160, 0x2E365AFC } // 154 kB
// { 0x2E37AC40, 0x2E39BB3C } // 131 kB
// { 0x2E3A6EF0, 0x2E3CA2FC } // 141 kB
// { 0x2E3D9EE0, 0x2E400B3C } // 155 kB
// { 0x2E43A8F0, 0x2E442BBC } // 32 kB
// { 0x2E46EC90, 0x2E48E27C } // 125 kB
// { 0x2E497F90, 0x2E4A147C } // 37 kB
// { 0x2E4A5B40, 0x2E4C67BC } // 131 kB
// { 0x2E4FBEF0, 0x2E52697C } // 170 kB
// { 0x2E550750, 0x2E57333C } // 138 kB
// { 0x2E573F3C, 0x2FF8F07C } // 226732 kB (26 MB)
// { 0x31000000, 0x31E1FFFC } // 614464 kB (14 MB)
// { 0x320A5D80, 0x320AEA3C } // 35 kB
// { 0x320E8670, 0x3210017C } // 94 kB
// { 0x3212609C, 0x3213187C } // 45 kB
// { 0x3219DF08, 0x321B72BC } // 100 kB
// { 0x3300ED34, 0x3301AD3C } // 48 kB
// { 0x33041760, 0x33049D0C } // 33 kB
// { 0x330608F8, 0x3306C97C } // 48 kB
// { 0x33089D80, 0x33095284 } // 45 kB
// { 0x33095470, 0x330A1324 } // 47 kB
// { 0x330A1358, 0x330ADC10 } // 50 kB
// { 0x330C9040, 0x330D0ABC } // 30 kB
// { 0x330D0AD8, 0x3311F9CC } // 315 kB
// { 0x3312575C, 0x3320A63C } // 915 kB
// { 0x33234D00, 0x3324B33C } // 89 kB
// { 0x3324E300, 0x3328D7BC } // 253 kB
// { 0x3329D134, 0x332CA324 } // 180 kB
// { 0x3332B200, 0x33340C88 } // 86 kB
// { 0x3335A440, 0x335021FC } // 1695 kB (1 MB)
// { 0x3350A778, 0x3391680C } // 4144 kB (4 MB)
// { 0x3391A444, 0x3392A25C } // 63 kB
// { 0x3392A444, 0x33939EB4 } // 62 kB
// { 0x3393A444, 0x3394A25C } // 63 kB
// { 0x339587C0, 0x33976C80 } // 121 kB
// { 0x339779C8, 0x3398E320 } // 90 kB
// { 0x3399AE74, 0x339A7D80 } // 51 kB
// { 0x339AB1C0, 0x339CE3A0 } // 140 kB
// { 0x339CEB28, 0x339DEC38 } // 64 kB
// { 0x339DEC40, 0x339ED000 } // 56 kB
// { 0x339F1BA4, 0x33A09280 } // 93 kB
// { 0x33A0C6E4, 0x33A15C40 } // 37 kB
// { 0x33A15D64, 0x33EBFFFC } // 4776 kB (4 MB)
// { 0x33F01380, 0x33F21FFC } // 131 kB
// { 0x33F44820, 0x33F6B1BC } // 154 kB
// { 0x33F80300, 0x33FA11FC } // 131 kB
// { 0x33FA4D3C, 0x33FEDAFC } // 291 kB
// { 0x33FFFFD4, 0x38FFFFFC } // 81920 kB (80 MB)
{0, 0}
};
static const memory_values_t mem_vals_500[] =
{
{ 0x2E605CBC, 0x2FF849BC }, // size 26733828 (26107 kB) (25 MB)
{ 0x2CAE7878, 0x2D207DB4 }, // size 7472448 (7297 kB) (7 MB)
{ 0x2D3B966C, 0x2D8943C0 }, // size 5090648 (4971 kB) (4 MB)
{ 0x2D8AD3D8, 0x2DFFFFFC }, // size 7679016 (7499 kB) (7 MB)
// TODO: Check which of those areas are usable
// { 0x283A73DC, 0x284D2AE4 } // size 1226508 (1197 kB) (1 MB)
// { 0x29030800, 0x293F69FC } // size 3957248 (3864 kB) (3 MB)
// { 0x2970200C, 0x298B9C54 } // size 1801292 (1759 kB) (1 MB)
// { 0x2A057B68, 0x2A1B9578 } // size 1448468 (1414 kB) (1 MB)
// { 0x29030800, 0x293F69FC } // size 3957248 (3864 kB) (3 MB)
// { 0x2970200C, 0x298B9C54 } // size 1801292 (1759 kB) (1 MB)
// { 0x2A057B68, 0x2A1B9578 } // size 1448468 (1414 kB) (1 MB)
// { 0x288EEC30, 0x28B06E94 } // size 2196072 (2144 kB) (2 MB)
// { 0x283A73DC, 0x284D2AE4 } // size 1226508 (1197 kB) (1 MB)
// { 0x3335A4C0, 0x335021FC } // size 1736000 (1695 kB) (1 MB)
// { 0x3350C1D4, 0x339182CC } // size 4243708 (4144 kB) (4 MB)
// { 0x33A14094, 0x33EBFFFC } // size 4898668 (4783 kB) (4 MB)
// { 0x33FFFFD4, 0x38FFFFFC } // size 83886124 (81920 kB) (80 MB)
{0, 0}
};
static const memory_values_t mem_vals_532[] =
{
// TODO: Check which of those areas are usable
// {0x28000000 + 0x000DCC9C, 0x28000000 + 0x00174F80}, // 608 kB
// {0x28000000 + 0x00180B60, 0x28000000 + 0x001C0A00}, // 255 kB
// {0x28000000 + 0x001ECE9C, 0x28000000 + 0x00208CC0}, // 111 kB
// {0x28000000 + 0x00234180, 0x28000000 + 0x0024B444}, // 92 kB
// {0x28000000 + 0x0024D8C0, 0x28000000 + 0x0028D884}, // 255 kB
// {0x28000000 + 0x003A745C, 0x28000000 + 0x004D2B68}, // 1197 kB
// {0x28000000 + 0x004D77B0, 0x28000000 + 0x00502200}, // 170 kB
// {0x28000000 + 0x005B3A88, 0x28000000 + 0x005C6870}, // 75 kB
// {0x28000000 + 0x0061F3E4, 0x28000000 + 0x00632B04}, // 77 kB
// {0x28000000 + 0x00639790, 0x28000000 + 0x00649BC4}, // 65 kB
// {0x28000000 + 0x00691490, 0x28000000 + 0x006B3CA4}, // 138 kB
// {0x28000000 + 0x006D7BCC, 0x28000000 + 0x006EEB84}, // 91 kB
// {0x28000000 + 0x00704E44, 0x28000000 + 0x0071E3C4}, // 101 kB
// {0x28000000 + 0x0073B684, 0x28000000 + 0x0074C184}, // 66 kB
// {0x28000000 + 0x00751354, 0x28000000 + 0x00769784}, // 97 kB
// {0x28000000 + 0x008627DC, 0x28000000 + 0x00872904}, // 64 kB
// {0x28000000 + 0x008C1E98, 0x28000000 + 0x008EB0A0}, // 164 kB
// {0x28000000 + 0x008EEC30, 0x28000000 + 0x00B06E98}, // 2144 kB
// {0x28000000 + 0x00B06EC4, 0x28000000 + 0x00B930C4}, // 560 kB
// {0x28000000 + 0x00BA1868, 0x28000000 + 0x00BC22A4}, // 130 kB
// {0x28000000 + 0x00BC48F8, 0x28000000 + 0x00BDEC84}, // 104 kB
// {0x28000000 + 0x00BE3DC0, 0x28000000 + 0x00C02284}, // 121 kB
// {0x28000000 + 0x00C02FC8, 0x28000000 + 0x00C19924}, // 90 kB
// {0x28000000 + 0x00C2D35C, 0x28000000 + 0x00C3DDC4}, // 66 kB
// {0x28000000 + 0x00C48654, 0x28000000 + 0x00C6E2E4}, // 151 kB
// {0x28000000 + 0x00D04E04, 0x28000000 + 0x00D36938}, // 198 kB
// {0x28000000 + 0x00DC88AC, 0x28000000 + 0x00E14288}, // 302 kB
// {0x28000000 + 0x00E21ED4, 0x28000000 + 0x00EC8298}, // 664 kB
// {0x28000000 + 0x00EDDC7C, 0x28000000 + 0x00F7C2A8}, // 633 kB
// {0x28000000 + 0x00F89EF4, 0x28000000 + 0x010302B8}, // 664 kB
// {0x28000000 + 0x01030800, 0x28000000 + 0x013F69A0}, // 3864 kB
// {0x28000000 + 0x016CE000, 0x28000000 + 0x016E0AA0}, // 74 kB
// {0x28000000 + 0x0170200C, 0x28000000 + 0x018B9C58}, // 1759 kB
// {0x28000000 + 0x01F17658, 0x28000000 + 0x01F6765C}, // 320 kB
// {0x28000000 + 0x01F6779C, 0x28000000 + 0x01FB77A0}, // 320 kB
// {0x28000000 + 0x01FB78E0, 0x28000000 + 0x020078E4}, // 320 kB
// {0x28000000 + 0x02007A24, 0x28000000 + 0x02057A28}, // 320 kB
// {0x28000000 + 0x02057B68, 0x28000000 + 0x021B957C}, // 1414 kB
// {0x28000000 + 0x02891528, 0x28000000 + 0x028C8A28}, // 221 kB
// {0x28000000 + 0x02BBCC4C, 0x28000000 + 0x02CB958C}, // 1010 kB
// {0x28000000 + 0x0378D45C, 0x28000000 + 0x03855464}, // 800 kB
// {0x28000000 + 0x0387800C, 0x28000000 + 0x03944938}, // 818 kB
// {0x28000000 + 0x03944A08, 0x28000000 + 0x03956E0C}, // 73 kB
// {0x28000000 + 0x04A944A4, 0x28000000 + 0x04ABAAC0}, // 153 kB
// {0x28000000 + 0x04ADE370, 0x28000000 + 0x0520EAB8}, // 7361 kB // ok
// {0x28000000 + 0x053B966C, 0x28000000 + 0x058943C4}, // 4971 kB // ok
// {0x28000000 + 0x058AD3D8, 0x28000000 + 0x06000000}, // 7499 kB
// {0x28000000 + 0x0638D320, 0x28000000 + 0x063B0280}, // 139 kB
// {0x28000000 + 0x063C39E0, 0x28000000 + 0x063E62C0}, // 138 kB
// {0x28000000 + 0x063F52A0, 0x28000000 + 0x06414A80}, // 125 kB
// {0x28000000 + 0x06422810, 0x28000000 + 0x0644B2C0}, // 162 kB
// {0x28000000 + 0x064E48D0, 0x28000000 + 0x06503EC0}, // 125 kB
// {0x28000000 + 0x0650E360, 0x28000000 + 0x06537080}, // 163 kB
// {0x28000000 + 0x0653A460, 0x28000000 + 0x0655C300}, // 135 kB
// {0x28000000 + 0x0658AA40, 0x28000000 + 0x065BC4C0}, // 198 kB // ok
// {0x28000000 + 0x065E51A0, 0x28000000 + 0x06608E80}, // 143 kB // ok
// {0x28000000 + 0x06609ABC, 0x28000000 + 0x07F82C00}, // 26084 kB // ok
// {0x30000000 + 0x000DCC9C, 0x30000000 + 0x00180A00}, // 655 kB
// {0x30000000 + 0x00180B60, 0x30000000 + 0x001C0A00}, // 255 kB
// {0x30000000 + 0x001F5EF0, 0x30000000 + 0x00208CC0}, // 75 kB
// {0x30000000 + 0x00234180, 0x30000000 + 0x0024B444}, // 92 kB
// {0x30000000 + 0x0024D8C0, 0x30000000 + 0x0028D884}, // 255 kB
// {0x30000000 + 0x003A745C, 0x30000000 + 0x004D2B68}, // 1197 kB
// {0x30000000 + 0x006D3334, 0x30000000 + 0x00772204}, // 635 kB
// {0x30000000 + 0x00789C60, 0x30000000 + 0x007C6000}, // 240 kB
// {0x30000000 + 0x00800000, 0x30000000 + 0x01E20000}, // 22876 kB // ok
{ 0x2E609ABC, 0x2FF82C00 }, // 26084 kB
{ 0x29030800, 0x293F69A0 }, // 3864 kB
{ 0x288EEC30, 0x28B06E98 }, // 2144 kB
{ 0x2D3B966C, 0x2D8943C4 }, // 4971 kB
{ 0x2CAE0370, 0x2D20EAB8 }, // 7361 kB
{ 0x2D8AD3D8, 0x2E000000 }, // 7499 kB
{0, 0}
}; // total : 66mB + 25mB
static const memory_values_t mem_vals_540[] =
{
{ 0x2E609EFC, 0x2FF82000 }, // 26083 kB
{ 0x29030800, 0x293F6000 }, // 3864 kB
{ 0x288EEC30, 0x28B06800 }, // 2144 kB
{ 0x2D3B966C, 0x2D894000 }, // 4971 kB
{ 0x2CB56370, 0x2D1EF000 }, // 6756 kB
{ 0x2D8AD3D8, 0x2E000000 }, // 7499 kB
{ 0x2970200C, 0x298B9800 }, // 1759 kB
{ 0x2A057B68, 0x2A1B9000 }, // 1414 kB
{ 0x2ABBCC4C, 0x2ACB9000 }, // 1010 kB
{0, 0}
};
s_mem_area * memoryGetAreaTable(void)
{
return MEM_AREA_TABLE;
}
static inline void memoryAddArea(int start, int end, int cur_index)
{
// Create and copy new memory area
s_mem_area * mem_area = memoryGetAreaTable();
mem_area[cur_index].address = start;
mem_area[cur_index].size = end - start;
mem_area[cur_index].next = 0;
// Fill pointer to this area in the previous area
if (cur_index > 0)
{
mem_area[cur_index - 1].next = &mem_area[cur_index];
}
}
/* Create memory areas arrays */
void memoryInitAreaTable()
{
u32 ApplicationMemoryEnd = (u32)APP_BASE_MEM;
// This one seems to be available on every firmware and therefore its our code area but also our main RPX area behind our code
// 22876 kB - our application // ok
if(OS_FIRMWARE <= 400) {
memoryAddArea(ApplicationMemoryEnd + 0x4B000000, 0x4B000000 + 0x01E20000, 0);
}
else {
memoryAddArea(ApplicationMemoryEnd + 0x30000000, 0x30000000 + 0x01E20000, 0);
}
const memory_values_t * mem_vals = NULL;
switch(OS_FIRMWARE)
{
case 400: {
mem_vals = mem_vals_400;
break;
}
case 500: {
mem_vals = mem_vals_500;
break;
}
case 532: {
mem_vals = mem_vals_532;
break;
}
case 540:
case 550: {
mem_vals = mem_vals_540;
break;
}
default:
return; // no known values
}
// Fill entries
int i = 0;
while (mem_vals[i].start_address)
{
memoryAddArea(mem_vals[i].start_address, mem_vals[i].end_address, i + 1);
i++;
}
}

View File

@ -1,34 +0,0 @@
/****************************************************************************
* 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_AREA_TABLE_H_
#define _MEMORY_AREA_TABLE_H_
#ifdef __cplusplus
extern "C" {
#endif
#include "common/common.h"
void memoryInitAreaTable();
s_mem_area * memoryGetAreaTable(void);
#ifdef __cplusplus
}
#endif
#endif // _MEMORY_AREA_TABLE_H_

View File

@ -30,164 +30,167 @@
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <wchar.h> #include <wchar.h>
#include "common/types.h" #include <strings.h>
#include <wut_types.h>
#include <stdio.h>
#include <utils/StringTools.h>
const char * fmt(const char * format, ...)
{
static char strChar[512];
strChar[0] = 0;
char * tmp = NULL;
va_list va; BOOL StringTools::EndsWith(const std::string& a, const std::string& b) {
va_start(va, format); if (b.size() > a.size()) return false;
if((vasprintf(&tmp, format, va) >= 0) && tmp) return std::equal(a.begin() + a.size() - b.size(), a.end(), b.begin());
{
snprintf(strChar, sizeof(strChar), tmp);
free(tmp);
va_end(va);
return (const char *) strChar;
}
va_end(va);
if(tmp)
free(tmp);
return NULL;
} }
const wchar_t * wfmt(const char * format, ...) const char * StringTools::byte_to_binary(int32_t x) {
{ static char b[9];
static wchar_t strWChar[512]; b[0] = '\0';
strWChar[0] = 0;
if(!format) int32_t z;
return (const wchar_t *) strWChar; for (z = 128; z > 0; z >>= 1) {
strcat(b, ((x & z) == z) ? "1" : "0");
}
if(strcmp(format, "") == 0) return b;
return (const wchar_t *) strWChar;
char * tmp = NULL;
va_list va;
va_start(va, format);
if((vasprintf(&tmp, format, va) >= 0) && tmp)
{
int bt;
int strlength = strlen(tmp);
bt = mbstowcs(strWChar, tmp, (strlength < 512) ? strlength : 512 );
free(tmp);
tmp = 0;
if(bt > 0)
{
strWChar[bt] = 0;
return (const wchar_t *) strWChar;
}
}
va_end(va);
if(tmp)
free(tmp);
return NULL;
} }
int strprintf(std::string &str, const char * format, ...) std::string StringTools::removeCharFromString(std::string& input,char toBeRemoved) {
{ std::string output = input;
int result = 0; size_t position;
char * tmp = NULL; while(1) {
position = output.find(toBeRemoved);
va_list va; if(position == std::string::npos)
va_start(va, format); break;
if((vasprintf(&tmp, format, va) >= 0) && tmp) output.erase(position, 1);
{ }
str = tmp; return output;
result = str.size();
}
va_end(va);
if(tmp)
free(tmp);
return result;
} }
std::string strfmt(const char * format, ...) const char * StringTools::fmt(const char * format, ...) {
{ static char strChar[512];
std::string str; strChar[0] = 0;
char * tmp = NULL;
va_list va; va_list va;
va_start(va, format); va_start(va, format);
if((vasprintf(&tmp, format, va) >= 0) && tmp) if((vsprintf(strChar, format, va) >= 0)) {
{ va_end(va);
str = tmp; return (const char *) strChar;
} }
va_end(va); va_end(va);
if(tmp) return NULL;
free(tmp);
return str;
} }
bool char2wchar_t(const char * strChar, wchar_t * dest) const wchar_t * StringTools::wfmt(const char * format, ...) {
{ static char tmp[512];
if(!strChar || !dest) static wchar_t strWChar[512];
return false; strWChar[0] = 0;
tmp[0] = 0;
int bt; if(!format)
bt = mbstowcs(dest, strChar, strlen(strChar)); return (const wchar_t *) strWChar;
if (bt > 0) {
dest[bt] = 0;
return true;
}
return false; if(strcmp(format, "") == 0)
return (const wchar_t *) strWChar;
va_list va;
va_start(va, format);
if((vsprintf(tmp, format, va) >= 0)) {
int bt;
int32_t strlength = strlen(tmp);
bt = mbstowcs(strWChar, tmp, (strlength < 512) ? strlength : 512 );
if(bt > 0) {
strWChar[bt] = 0;
return (const wchar_t *) strWChar;
}
}
va_end(va);
return NULL;
} }
int strtokcmp(const char * string, const char * compare, const char * separator) int32_t StringTools::strprintf(std::string &str, const char * format, ...) {
{ static char tmp[512];
if(!string || !compare) tmp[0] = 0;
return -1; int32_t result = 0;
char TokCopy[512]; va_list va;
strncpy(TokCopy, compare, sizeof(TokCopy)); va_start(va, format);
TokCopy[511] = '\0'; if((vsprintf(tmp, format, va) >= 0)) {
str = tmp;
result = str.size();
}
va_end(va);
char * strTok = strtok(TokCopy, separator); return result;
while (strTok != NULL)
{
if (strcasecmp(string, strTok) == 0)
{
return 0;
}
strTok = strtok(NULL,separator);
}
return -1;
} }
int strextcmp(const char * string, const char * extension, char seperator) std::string StringTools::strfmt(const char * format, ...) {
{ std::string str;
if(!string || !extension) static char tmp[512];
return -1; tmp[0] = 0;
char *ptr = strrchr(string, seperator); va_list va;
if(!ptr) va_start(va, format);
return -1; if((vsprintf(tmp, format, va) >= 0)) {
str = tmp;
}
va_end(va);
return strcasecmp(ptr + 1, extension); return str;
}
BOOL StringTools::char2wchar_t(const char * strChar, wchar_t * dest) {
if(!strChar || !dest)
return false;
int bt;
bt = mbstowcs(dest, strChar, strlen(strChar));
if (bt > 0) {
dest[bt] = 0;
return true;
}
return false;
}
int32_t StringTools::strtokcmp(const char * string, const char * compare, const char * separator) {
if(!string || !compare)
return -1;
char TokCopy[512];
strncpy(TokCopy, compare, sizeof(TokCopy));
TokCopy[511] = '\0';
char * strTok = strtok(TokCopy, separator);
while (strTok != NULL) {
if (strcasecmp(string, strTok) == 0) {
return 0;
}
strTok = strtok(NULL,separator);
}
return -1;
}
int32_t StringTools::strextcmp(const char * string, const char * extension, char seperator) {
if(!string || !extension)
return -1;
char *ptr = strrchr(string, seperator);
if(!ptr)
return -1;
return strcasecmp(ptr + 1, extension);
} }
std::vector<std::string> stringSplit(const std::string & inValue, const std::string & splitter) std::vector<std::string> StringTools::stringSplit(const std::string & inValue, const std::string & splitter) {
{
std::string value = inValue; std::string value = inValue;
std::vector<std::string> result; std::vector<std::string> result;
while (true) { while (true) {
unsigned int index = value.find(splitter); uint32_t index = value.find(splitter);
if (index == std::string::npos) { if (index == std::string::npos) {
result.push_back(value); result.push_back(value);
break; break;

View File

@ -28,51 +28,55 @@
#include <vector> #include <vector>
#include <string> #include <string>
#include "common/types.h" #include <wut_types.h>
const char * fmt(const char * format, ...); class StringTools{
const wchar_t * wfmt(const char * format, ...); public:
int strprintf(std::string &str, const char * format, ...); static BOOL EndsWith(const std::string& a, const std::string& b);
std::string strfmt(const char * format, ...); static const char * byte_to_binary(int32_t x);
bool char2wchar_t(const char * src, wchar_t * dest); static std::string removeCharFromString(std::string& input,char toBeRemoved);
int strtokcmp(const char * string, const char * compare, const char * separator); static const char * fmt(const char * format, ...);
int strextcmp(const char * string, const char * extension, char seperator); static const wchar_t * wfmt(const char * format, ...);
static int32_t strprintf(std::string &str, const char * format, ...);
static std::string strfmt(const char * format, ...);
static BOOL char2wchar_t(const char * src, wchar_t * dest);
static int32_t strtokcmp(const char * string, const char * compare, const char * separator);
static int32_t strextcmp(const char * string, const char * extension, char seperator);
inline const char * FullpathToFilename(const char *path) static const char * FullpathToFilename(const char *path){
{ if(!path) return path;
if(!path) return path;
const char * ptr = path; const char * ptr = path;
const char * Filename = ptr; const char * Filename = ptr;
while(*ptr != '\0') while(*ptr != '\0')
{ {
if(ptr[0] == '/' && ptr[1] != '\0') if(ptr[0] == '/' && ptr[1] != '\0')
Filename = ptr+1; Filename = ptr+1;
++ptr; ++ptr;
} }
return Filename; return Filename;
} }
inline void RemoveDoubleSlashs(std::string &str) static void RemoveDoubleSlashs(std::string &str){
{ uint32_t length = str.size();
u32 length = str.size();
//! clear path of double slashes //! clear path of double slashes
for(u32 i = 1; i < length; ++i) for(uint32_t i = 1; i < length; ++i)
{ {
if(str[i-1] == '/' && str[i] == '/') if(str[i-1] == '/' && str[i] == '/')
{ {
str.erase(i, 1); str.erase(i, 1);
i--; i--;
length--; length--;
} }
} }
} }
std::vector<std::string> stringSplit(const std::string & value, const std::string & splitter); static std::vector<std::string> stringSplit(const std::string & value, const std::string & splitter);
};
#endif /* __STRING_TOOLS_H */ #endif /* __STRING_TOOLS_H */

View File

@ -1,61 +1,48 @@
#include <unistd.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <errno.h> #include <errno.h>
#include <utils/logger.h>
#include <nsysnet/socket.h> #include <nsysnet/socket.h>
#include "common/common.h" #include <coreinit/debug.h>
#include "logger.h"
#ifdef DEBUG_LOGGER #include <coreinit/systeminfo.h>
static int log_socket = -1; #include <coreinit/thread.h>
static volatile int log_lock = 0;
void log_init(const char * ipString) static int log_socket __attribute__((section(".data")))= -1;
{ static struct sockaddr_in connect_addr __attribute__((section(".data")));
log_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); static volatile int log_lock __attribute__((section(".data"))) = 0;
if (log_socket < 0)
return;
struct sockaddr_in connect_addr; void log_init_() {
memset(&connect_addr, 0, sizeof(connect_addr)); int broadcastEnable = 1;
connect_addr.sin_family = AF_INET; log_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
connect_addr.sin_port = 4405; if (log_socket < 0)
inet_aton(ipString, &connect_addr.sin_addr); return;
if(connect(log_socket, (struct sockaddr*)&connect_addr, sizeof(connect_addr)) < 0) setsockopt(log_socket, SOL_SOCKET, SO_BROADCAST, &broadcastEnable, sizeof(broadcastEnable));
{
socketclose(log_socket); memset(&connect_addr, 0, sizeof(struct sockaddr_in));
log_socket = -1; connect_addr.sin_family = AF_INET;
} connect_addr.sin_port = 4405;
connect_addr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
} }
void log_deinit(void) void log_print_(const char *str) {
{
if(log_socket >= 0)
{
socketclose(log_socket);
log_socket = -1;
}
}
void log_print(const char *str)
{
// socket is always 0 initially as it is in the BSS // socket is always 0 initially as it is in the BSS
if(log_socket < 0) { if(log_socket < 0) {
return; return;
} }
while(log_lock) while(log_lock)
usleep(1000); OSSleepTicks(OSMicrosecondsToTicks(1000));
log_lock = 1; log_lock = 1;
int len = strlen(str); int len = strlen(str);
int ret; int ret;
while (len > 0) { while (len > 0) {
int block = len < 1400 ? len : 1400; // take max 1400 bytes per UDP packet int block = len < 1400 ? len : 1400; // take max 1400 bytes per UDP packet
ret = send(log_socket, str, block, 0); ret = sendto(log_socket, str, block, 0, (struct sockaddr *)&connect_addr, sizeof(struct sockaddr_in));
if(ret < 0) if(ret < 0)
break; break;
@ -66,23 +53,30 @@ void log_print(const char *str)
log_lock = 0; log_lock = 0;
} }
void log_printf(const char *format, ...) void OSFatal_printf(const char *format, ...) {
{ char tmp[512];
tmp[0] = 0;
va_list va;
va_start(va, format);
if((vsprintf(tmp, format, va) >= 0)) {
OSFatal(tmp);
}
va_end(va);
}
void log_printf_(const char *format, ...) {
if(log_socket < 0) { if(log_socket < 0) {
return; return;
} }
char * tmp = NULL; char tmp[512];
tmp[0] = 0;
va_list va; va_list va;
va_start(va, format); va_start(va, format);
if((vasprintf(&tmp, format, va) >= 0) && tmp) if((vsprintf(tmp, format, va) >= 0)) {
{ log_print_(tmp);
log_print(tmp); }
} va_end(va);
va_end(va);
if(tmp)
free(tmp);
} }
#endif

Some files were not shown because too many files have changed in this diff Show More