mirror/RetroArch
1
0
Fork 0
mirror of https://github.com/libretro/RetroArch synced 2025-03-03 04:14:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into master

Browse Source
This commit is contained in:
Twinaphex 2017-11-19 17:02:06 +01:00 committed by GitHub
commit 18436a476d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
184 changed files with 4684 additions and 5840 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
CHANGES.md
View File

@ -1,34 +1,55 @@
# 1.6.8 (future)
- Test
# 1.6.9 (future)
# 1.6.8
- Audio: Fix the Audio DSP picker
- CHEEVOS: Add support for Atari Lynx cheevos.
- CHEEVOS: Add support for RetroAchievements Leaderboards.
- GUI: (MaterialUI) Fix crash that happened on context reset with Vulkan.
- GUI: (MaterialUI) Skip querying and drawing items that are not visible; Cache content height and bbox calculation.
- GUI: (MaterialUI) Fix entry box highlight calculation.
- GUI: (XMB) Skip drawing the fading list when it is already transparent. Optimization.
- GUI: (XMB) Comment out visible item calculation in xmb_draw_items().
- GUI: (RGUI) Prevent crashes when using a non-English language reliant on UTF8.
- GUI: Add option for OSD background color.
- GUI: Add menu option for OSD background color.
- GUI: Add menu option for OSD text color.
- GUI: Add menu option to remove frame count from OSD.
- GUI: Allow wraparound of int/float settings when pressing the left key
- INPUT/LIBRETRO: Add support for more mouse buttons (buttons 4/5)
- INPUT/LIBRETRO: Add support for analog buttons
- INPUT: Always show the controls menu even if descriptors are not set
- INPUT: Fix input descriptors not being set on cores that don't implement the controllers interface
- INPUT: Apply descriptors only for the amount of cores the core supports
- INPUT: Implement keyboard to gamepad input remapping (limited to one gamepad device for now)
- INPUT: Fix absolute mouse move handling on the winraw driver
- INPUT: Ignore keyboard input if window is not active on udev driver
- INPUT: Sanitize the filenames of autoconfig profiles before saving
- LOBBIES: Fix crash on navigating left / right from the lobby menu
- LOCALIZATION: Update Dutch translation
- LOCALIZATION: Update Italian translation.
- LOCALIZATION: Update Japanese translation.
- LOCALIZATION: Update Portuguese-Brazilian translation.
- LOCALIZATION: Update Russian translation.
- LINUX/ARMHF: Set buildbot updater URL to armhf location instead of blank string
- LINUX/PI: Broadcom VC4: Add Videocore config option
- LINUX/UDEV: Fix - RetroArch reads keyboard input when not focused with the udev input driver.
- NETPLAY: Fix disconnection not fully deinitializing Netplay.
- NETPLAY: Fix lan rooms when there is more than one room
- NETPLAY: Fix lan rooms on systems where all addresses are treated as IPv6
- COMMON: Fix clear/free loop conditionals in playlists.
- WINDOWS/GDI: Fix flickering of text.
- WINDOWS/GDI: Fix graphics corruption on Windows 98
- WINDOWS/GDI: Allow compiling without DirectInput8 for NT support
- WINDOWS/WGL: Try to use wglSwapLayerBuffers instead of SwapBuffers if possible (for more optimal performance).
- WINDOWS: Fix menubar text corruption on Japanese locale systems
- WINDOWS: Support Unicode file I/O (can now display CJK characters in file browser for example).
- WINDOWS: Support Windows 95, NT3.51, NT4
- WINDOWS: add Makefile.griffin targets for msvc6,2003,2005,2010,2012,2013
- WII: Use custom, embedded libogc SDK.
- WIIU: Initial touchscreen support for WiiU gamepad.
- WIIU: Add Cheevos support.
- SCANNER: Fix archive scanning.
- SCANNER: Support CHD files.
- SCANNER: Support Gamecube ISO scanning.
- SCANNER: Use primary data track of disc images for CRC lookups rather than cue files. This is slower but finds matches more reliably, and is necessary for CHD files to work at all. Update your databases!
# 1.6.7
@ -42,7 +63,7 @@
- GUI: Performance optimizations for XMB menu driver - only calculates visible items.
- LOCALIZATION: Update Italian translation.
# 1.6.6 (future)
# 1.6.6
- 3DS: Fixes serious performance regression that affected every core; rewind was always implicitly enabled.
- AUDIO: MOD/S3M/XM sound should now be properly mixed in with the core's sound.
- GUI: Visual makeover of MaterialUI.
@ -54,7 +75,7 @@
- INPUT: Overlay controller response - when we press buttons on the gamepad or keyboard, the corresponding buttons on the overlay will be highlighted as well.
- NETBSD: Silence some compilation warnings.
- COMMON: Fixed bug 'Deleting an entry from a playlist would not update the list view inside XMB'.
- COMMON: Fix inet_ntop_compat on *nix
- COMMON: Fix inet_ntop_compat on Unix
- LOBBY: Add skeleton to add help descriptions to lobbies
# 1.6.5

4
Makefile
View File

@ -74,7 +74,7 @@ ifneq ($(findstring Win32,$(OS)),)
LDFLAGS += -mwindows
endif
CFLAGS += -Wall $(OPTIMIZE_FLAG) $(INCLUDE_DIRS) $(DEBUG_FLAG) -I.
CFLAGS += -Wall $(OPTIMIZE_FLAG) $(INCLUDE_DIRS) $(DEBUG_FLAG) -I. -Ideps -Ideps/stb
APPEND_CFLAGS := $(CFLAGS)
CXXFLAGS += $(APPEND_CFLAGS) -std=c++11 -D__STDC_CONSTANT_MACROS
@ -204,7 +204,7 @@ install: $(TARGET)
rm -rf $(DESTDIR)$(ASSETS_DIR)/retroarch/assets/xmb/monochrome/src; \
rm -rf $(DESTDIR)$(ASSETS_DIR)/retroarch/assets/xmb/retroactive/src; \
rm -rf $(DESTDIR)$(ASSETS_DIR)/retroarch/assets/xmb/neoactive/src; \
rm -rf $(DESTDIR)$(ASSETS_DIR)/retroarch/assets/xmb/retroactive_marked/src; \
rm -rf $(DESTDIR)$(ASSETS_DIR)/retroarch/assets/xmb/retrosystem/src; \
rm -rf $(DESTDIR)$(ASSETS_DIR)/retroarch/assets/xmb/dot-art/src; \
echo "Asset copying done."; \
fi

13
Makefile.common
View File

@ -52,10 +52,6 @@ ifeq ($(HAVE_VITA2D), 1)
DEFINES += -DHAVE_VITA2D
endif
ifeq ($(HAVE_FBO), 1)
DEFINES += -DHAVE_FBO
endif
ifeq ($(HAVE_DYLIB), 1)
DEFINES += -DHAVE_DYLIB
endif
@ -1309,9 +1305,6 @@ ifeq ($(HAVE_FLAC),1)
CFLAGS += -I$(DEPS_DIR)/libFLAC/include
DEFINES += -DHAVE_FLAC -DHAVE_STDINT_H -DHAVE_LROUND -DFLAC__HAS_OGG=0 \
-DFLAC_PACKAGE_VERSION="\"retroarch\""
ifneq ($(findstring Win32,$(OS)),)
DEFINES += -DHAVE_FSEEKO
endif
FLACOBJ = $(DEPS_DIR)/libFLAC/bitmath.o \
$(DEPS_DIR)/libFLAC/bitreader.o \
$(DEPS_DIR)/libFLAC/cpu.o \
@ -1327,6 +1320,12 @@ ifeq ($(HAVE_FLAC),1)
$(DEPS_DIR)/libFLAC/md5.o \
$(DEPS_DIR)/libFLAC/memory.o \
$(DEPS_DIR)/libFLAC/stream_decoder.o
ifneq ($(findstring Win32,$(OS)),)
DEFINES += -DHAVE_FSEEKO
# make sure not to use this on legacy Windows versions that don't have W-functions implemented
DEFINES += -DNEED_UTF8_SUPPORT
FLACOBJ += $(DEPS_DIR)/libFLAC/windows_unicode_filenames.o
endif
OBJ += $(FLACOBJ)
endif

2
Makefile.ctr
View File

@ -142,7 +142,7 @@ ifeq ($(WHOLE_ARCHIVE_LINK), 1)
WHOLE_END := -Wl,--no-whole-archive
endif
CFLAGS += -I. -Ideps/libz -Ideps/7zip -Ilibretro-common/include
CFLAGS += -I. -Ideps -Ideps/libz -Ideps/7zip -Ideps/stb -Ilibretro-common/include
CFLAGS += -DRARCH_INTERNAL -DRARCH_CONSOLE -DSINC_LOWEST_QUALITY
CFLAGS += -DHAVE_FILTERS_BUILTIN $(DEFINES)

2
Makefile.ctr.salamander
View File

@ -74,7 +74,7 @@ else
CFLAGS += -O3
endif
CFLAGS += -I. -Ideps/libz -Ideps/7zip -Ilibretro-common/include
CFLAGS += -I. -Ideps/libz -Ideps/7zip -Ideps/stb -Ilibretro-common/include
#CFLAGS += -DRARCH_INTERNAL
CFLAGS += -DRARCH_CONSOLE -DIS_SALAMANDER

3
Makefile.emscripten
View File

@ -19,7 +19,6 @@ HAVE_RGUI = 1
HAVE_SDL = 0
HAVE_SDL2 = 1
HAVE_ZLIB = 1
HAVE_FBO = 1
WANT_ZLIB = 1
MEMORY = 536870912
@ -72,7 +71,7 @@ OBJ += libretro-common/audio/dsp_filters/phaser.o
OBJ += libretro-common/audio/dsp_filters/reverb.o
OBJ += libretro-common/audio/dsp_filters/wahwah.o
CFLAGS += -Ideps/libz/
CFLAGS += -Ideps/libz -Ideps -Ideps/stb
libretro = libretro_emscripten.bc
ifneq ($(V), 1)

36
Makefile.griffin
View File

@ -318,7 +318,6 @@ else ifeq ($(platform), windows_msvc6_x86)
HAVE_STB_FONT := 1
HAVE_THREADS := 1
HAVE_LIBRETRODB := 1
HAVE_FBO := 1
HAVE_COMMAND := 1
HAVE_STDIN_CMD := 1
HAVE_CMD := 1
@ -342,7 +341,7 @@ else ifeq ($(platform), windows_msvc6_x86)
INCLUDE := $(shell IFS=$$'\n'; cygpath -w "$(VCDIR)/Include")
LIB := $(shell IFS=$$'\n'; cygpath -w "$(VCDIR)/Lib")
export INCLUDE := $(INCLUDE);$(INETSDK)\Include;libretro-common\include;libretro-common\include\compat\msvc
export INCLUDE := $(INCLUDE);$(INETSDK)\Include;libretro-common\include;libretro-common\include\compat\msvc;gfx\include;deps;deps\stb
export LIB := $(LIB);$(INETSDK)\Lib
else ifeq ($(platform), windows_msvc2003_x86)
HAVE_RPNG := 1
@ -360,7 +359,6 @@ else ifeq ($(platform), windows_msvc2003_x86)
HAVE_STB_FONT := 1
HAVE_THREADS := 1
HAVE_LIBRETRODB := 1
HAVE_FBO := 1
HAVE_COMMAND := 1
HAVE_STDIN_CMD := 1
HAVE_CMD := 1
@ -385,10 +383,10 @@ else ifeq ($(platform), windows_msvc2003_x86)
ifeq ($(HAVE_DIRECTX), 1)
PLATCFLAGS += -DHAVE_DINPUT -DHAVE_DSOUND
DXSDK_DIR := $(DXSDK_DIR:\=)
export INCLUDE := $(INCLUDE);$(INETSDK)\Include;$(DXSDK_DIR)\Include;libretro-common\include;libretro-common\include\compat\msvc
export INCLUDE := $(INCLUDE);$(INETSDK)\Include;$(DXSDK_DIR)\Include;libretro-common\include;libretro-common\include\compat\msvc;gfx\include;deps;deps\stb
export LIB := $(LIB);$(INETSDK)\Lib;$(DXSDK_DIR)\Lib\x86
else
export INCLUDE := $(INCLUDE);$(INETSDK)\Include;libretro-common\include;libretro-common\include\compat\msvc
export INCLUDE := $(INCLUDE);$(INETSDK)\Include;libretro-common\include;libretro-common\include\compat\msvc;gfx\include;deps;deps\stb
export LIB := $(LIB);$(INETSDK)\Lib
endif
else ifeq ($(platform), windows_msvc2005_x86)
@ -407,7 +405,6 @@ else ifeq ($(platform), windows_msvc2005_x86)
HAVE_STB_FONT := 1
HAVE_THREADS := 1
HAVE_LIBRETRODB := 1
HAVE_FBO := 1
HAVE_COMMAND := 1
HAVE_STDIN_CMD := 1
HAVE_CMD := 1
@ -433,10 +430,10 @@ else ifeq ($(platform), windows_msvc2005_x86)
ifeq ($(HAVE_DIRECTX), 1)
PLATCFLAGS += -DHAVE_DINPUT -DHAVE_DSOUND
DXSDK_DIR := $(DXSDK_DIR:\=)
export INCLUDE := $(INCLUDE);$(INETSDK)\Include;$(DXSDK_DIR)\Include;libretro-common\include;libretro-common\include\compat\msvc
export INCLUDE := $(INCLUDE);$(INETSDK)\Include;$(DXSDK_DIR)\Include;libretro-common\include;libretro-common\include\compat\msvc;gfx\include;deps;deps\stb
export LIB := $(LIB);$(INETSDK)\Lib;$(DXSDK_DIR)\Lib\x86
else
export INCLUDE := $(INCLUDE);$(INETSDK)\Include;libretro-common\include;libretro-common\include\compat\msvc
export INCLUDE := $(INCLUDE);$(INETSDK)\Include;libretro-common\include;libretro-common\include\compat\msvc;gfx\include;deps;deps\stb
export LIB := $(LIB);$(INETSDK)\Lib
endif
else ifneq (,$(findstring windows_msvc2010,$(platform)))
@ -455,7 +452,6 @@ else ifneq (,$(findstring windows_msvc2010,$(platform)))
HAVE_STB_FONT := 1
HAVE_THREADS := 1
HAVE_LIBRETRODB := 1
HAVE_FBO := 1
HAVE_COMMAND := 1
HAVE_STDIN_CMD := 1
HAVE_CMD := 1
@ -504,10 +500,10 @@ else ifneq (,$(findstring windows_msvc2010,$(platform)))
ifeq ($(HAVE_DIRECTX), 1)
PLATCFLAGS += -DHAVE_DINPUT -DHAVE_DSOUND -DHAVE_D3D -DHAVE_D3D9 -DHAVE_XAUDIO -DHAVE_XINPUT
DXSDK_DIR := $(DXSDK_DIR:\=)
export INCLUDE := $(INCLUDE);$(WindowsSdkDir)\Include;$(DXSDK_DIR)\Include;libretro-common\include;libretro-common\include\compat\msvc;gfx\include
export INCLUDE := $(INCLUDE);$(WindowsSdkDir)\Include;$(DXSDK_DIR)\Include;libretro-common\include;libretro-common\include\compat\msvc;gfx\include;deps;deps\stb
export LIB := $(LIB);$(WindowsSdkDir)\$(PlatLib);$(DXSDK_DIR)\Lib\$(WinArch)
else
export INCLUDE := $(INCLUDE);$(WindowsSdkDir)\Include;libretro-common\include;libretro-common\include\compat\msvc;gfx\include
export INCLUDE := $(INCLUDE);$(WindowsSdkDir)\Include;libretro-common\include;libretro-common\include\compat\msvc;gfx\include;deps;deps\stb
export LIB := $(LIB);$(WindowsSdkDir)\$(PlatLib)
endif
else ifneq (,$(findstring windows_msvc2012,$(platform)))
@ -526,7 +522,6 @@ else ifneq (,$(findstring windows_msvc2012,$(platform)))
HAVE_STB_FONT := 1
HAVE_THREADS := 1
HAVE_LIBRETRODB := 1
HAVE_FBO := 1
HAVE_COMMAND := 1
HAVE_STDIN_CMD := 1
HAVE_CMD := 1
@ -579,10 +574,10 @@ else ifneq (,$(findstring windows_msvc2012,$(platform)))
ifeq ($(HAVE_DIRECTX), 1)
PLATCFLAGS += -DHAVE_DINPUT -DHAVE_DSOUND -DHAVE_D3D -DHAVE_D3D9 -DHAVE_XAUDIO -DHAVE_XINPUT
DXSDK_DIR := $(DXSDK_DIR:\=)
export INCLUDE := $(INCLUDE);$(WindowsSdkDir)\Include\um;$(WindowsSdkDir)\Include\shared;$(DXSDK_DIR)\Include;libretro-common\include;libretro-common\include\compat\msvc;gfx\include
export INCLUDE := $(INCLUDE);$(WindowsSdkDir)\Include\um;$(WindowsSdkDir)\Include\shared;$(DXSDK_DIR)\Include;libretro-common\include;libretro-common\include\compat\msvc;gfx\include;deps;deps\stb
export LIB := $(LIB);$(WindowsSdkDir)\$(PlatLib);$(DXSDK_DIR)\Lib\$(WinArch)
else
export INCLUDE := $(INCLUDE);$(WindowsSdkDir)\Include\um;$(WindowsSdkDir)\Include\shared;libretro-common\include;libretro-common\include\compat\msvc;gfx\include
export INCLUDE := $(INCLUDE);$(WindowsSdkDir)\Include\um;$(WindowsSdkDir)\Include\shared;libretro-common\include;libretro-common\include\compat\msvc;gfx\include;deps;deps\stb
export LIB := $(LIB);$(WindowsSdkDir)\$(PlatLib)
endif
else ifneq (,$(findstring windows_msvc2013,$(platform)))
@ -601,7 +596,6 @@ else ifneq (,$(findstring windows_msvc2013,$(platform)))
HAVE_STB_FONT := 1
HAVE_THREADS := 1
HAVE_LIBRETRODB := 1
HAVE_FBO := 1
HAVE_COMMAND := 1
HAVE_STDIN_CMD := 1
HAVE_CMD := 1
@ -654,10 +648,10 @@ else ifneq (,$(findstring windows_msvc2013,$(platform)))
ifeq ($(HAVE_DIRECTX), 1)
PLATCFLAGS += -DHAVE_DINPUT -DHAVE_DSOUND -DHAVE_D3D -DHAVE_D3D9 -DHAVE_XAUDIO -DHAVE_XINPUT
DXSDK_DIR := $(DXSDK_DIR:\=)
export INCLUDE := $(INCLUDE);$(WindowsSdkDir)\Include\um;$(WindowsSdkDir)\Include\shared;$(DXSDK_DIR)\Include;libretro-common\include;libretro-common\include\compat\msvc;gfx\include
export INCLUDE := $(INCLUDE);$(WindowsSdkDir)\Include\um;$(WindowsSdkDir)\Include\shared;$(DXSDK_DIR)\Include;libretro-common\include;libretro-common\include\compat\msvc;gfx\include;deps;deps\stb
export LIB := $(LIB);$(WindowsSdkDir)\$(PlatLib);$(DXSDK_DIR)\Lib\$(WinArch)
else
export INCLUDE := $(INCLUDE);$(WindowsSdkDir)\Include\um;$(WindowsSdkDir)\Include\shared;libretro-common\include;libretro-common\include\compat\msvc;gfx\include
export INCLUDE := $(INCLUDE);$(WindowsSdkDir)\Include\um;$(WindowsSdkDir)\Include\shared;libretro-common\include;libretro-common\include\compat\msvc;gfx\include;deps;deps\stb
export LIB := $(LIB);$(WindowsSdkDir)\$(PlatLib)
endif
endif
@ -666,7 +660,9 @@ ifneq (,$(findstring msvc,$(platform)))
CFLAGS += -W2 $(MACHDEP) $(PLATCFLAGS)
else
CFLAGS += -Wall -std=gnu99 $(MACHDEP) $(PLATCFLAGS) $(INCLUDE)
INCLUDE += -I./libretro-common/include
INCLUDE += -I./libretro-common/include \
-Ideps \
-Ideps/stb
endif
OBJ = griffin/griffin.o $(PLATOBJS)
@ -810,10 +806,6 @@ ifeq ($(HAVE_GETOPT_LONG), 1)
CFLAGS += -DHAVE_GETOPT_LONG=1
endif
ifeq ($(HAVE_FBO), 1)
CFLAGS += -DHAVE_FBO
endif
ifeq ($(HAVE_DYLIB), 1)
CFLAGS += -DHAVE_DYLIB
endif

4
Makefile.ps3
View File

@ -33,7 +33,7 @@ EBOOT_PATH = pkg/ps3/USRDIR/EBOOT.BIN
CORE_PATH = pkg/ps3/USRDIR/cores/CORE.SELF
LDDIRS = -L. -L$(CELL_SDK)/target/ppu/lib/PSGL/RSX/ultra-opt
INCDIRS = -I. -Idefines -Ideps/libz -Ilibretro-common/include
INCDIRS = -I. -Idefines -Ideps/libz -Ilibretro-common/include -Ideps -Ideps/stb
# system platform
system_platform = unix
@ -101,7 +101,7 @@ PPU_LDLIBS = $(FONT_LIBS) $(GL_LIBS) $(WHOLE_START) -lretro_ps3 $(WHOLE_END) -l
PPU_RANLIB = $(CELL_SDK)/host-win32/ppu/bin/ppu-lv2-ranlib.exe
DEFINES += -DHAVE_THREADS -DRARCH_CONSOLE -DHAVE_OPENGL -DHAVE_HEADSET -DHAVE_LANGEXTRA -DHAVE_OPENGLES -DHAVE_OPENGLES1 -DHAVE_PSGL -DHAVE_CG -DHAVE_CG_RUNTIME_COMPILER -DHAVE_FBO -DHAVE_SYSMODULES -DHAVE_SYSUTILS -DHAVE_RARCH_EXEC -DHAVE_RSOUND -DHAVE_ZLIB -DHAVE_RPNG -DHAVE_RJPEG -DHAVE_RBMP -DHAVE_RTGA -DHAVE_7Z -DWANT_ZLIB -DSINC_LOWER_QUALITY -D__CELLOS_LV2__ -DHAVE_NETWORKING=1 -DHAVE_SOCKET_LEGACY=1 -DHAVE_MOUSE -DHAVE_GRIFFIN=1 -DHAVE_MULTIMAN=1 -DPC_DEVELOPMENT_IP_ADDRESS=\"$(PC_DEVELOPMENT_IP_ADDRESS)\" -DPC_DEVELOPMENT_UDP_PORT=$(PC_DEVELOPMENT_UDP_PORT) -DHAVE_FILTERS_BUILTIN
DEFINES += -DHAVE_THREADS -DRARCH_CONSOLE -DHAVE_OPENGL -DHAVE_HEADSET -DHAVE_LANGEXTRA -DHAVE_OPENGLES -DHAVE_OPENGLES1 -DHAVE_PSGL -DHAVE_CG -DHAVE_CG_RUNTIME_COMPILER -DHAVE_SYSMODULES -DHAVE_SYSUTILS -DHAVE_RARCH_EXEC -DHAVE_RSOUND -DHAVE_ZLIB -DHAVE_RPNG -DHAVE_RJPEG -DHAVE_RBMP -DHAVE_RTGA -DHAVE_7Z -DWANT_ZLIB -DSINC_LOWER_QUALITY -D__CELLOS_LV2__ -DHAVE_NETWORKING=1 -DHAVE_SOCKET_LEGACY=1 -DHAVE_MOUSE -DHAVE_GRIFFIN=1 -DHAVE_MULTIMAN=1 -DPC_DEVELOPMENT_IP_ADDRESS=\"$(PC_DEVELOPMENT_IP_ADDRESS)\" -DPC_DEVELOPMENT_UDP_PORT=$(PC_DEVELOPMENT_UDP_PORT) -DHAVE_FILTERS_BUILTIN
#DEFINES += -DHAVE_IMAGEVIEWER

4
Makefile.ps3.cobra
View File

@ -31,7 +31,7 @@ EBOOT_PATH = pkg/ps3/USRDIR/EBOOT.BIN
CORE_PATH = pkg/ps3/USRDIR/cores/CORE.SELF
LDDIRS = -L. -L$(CELL_SDK)/target/ppu/lib/PSGL/RSX/ultra-opt
INCDIRS = -I. -Idefines
INCDIRS = -I. -Idefines -Ideps -Ideps/stb
# system platform
system_platform = unix
@ -99,7 +99,7 @@ PPU_LDLIBS = $(FONT_LIBS) $(GL_LIBS) $(WHOLE_START) -lretro_ps3 $(WHOLE_END) -l
PPU_RANLIB = $(CELL_SDK)/host-win32/ppu/bin/ppu-lv2-ranlib.exe
DEFINES += -DHAVE_THREADS -DRARCH_CONSOLE -DHAVE_OPENGL -DHAVE_OVERLAY -DHAVE_HEADSET -DHAVE_OPENGLES -DHAVE_OPENGLES1 -DHAVE_PSGL -DHAVE_CG -DHAVE_CG_RUNTIME_COMPILER -DHAVE_FBO -DHAVE_SYSMODULES -DHAVE_SYSUTILS -DHAVE_RARCH_EXEC -DHAVE_RSOUND -DHAVE_ZLIB -DHAVE_RPNG -DWANT_ZLIB -DSINC_LOWER_QUALITY -D__CELLOS_LV2__ -DHAVE_NETWORKING=1 -DHAVE_SOCKET_LEGACY=1 -DHAVE_MOUSE -DHAVE_GRIFFIN=1 -DHAVE_MULTIMAN=0 -DPC_DEVELOPMENT_IP_ADDRESS=\"$(PC_DEVELOPMENT_IP_ADDRESS)\" -DPC_DEVELOPMENT_UDP_PORT=$(PC_DEVELOPMENT_UDP_PORT) -DHAVE_STB_VORBIS
DEFINES += -DHAVE_THREADS -DRARCH_CONSOLE -DHAVE_OPENGL -DHAVE_OVERLAY -DHAVE_HEADSET -DHAVE_OPENGLES -DHAVE_OPENGLES1 -DHAVE_PSGL -DHAVE_CG -DHAVE_CG_RUNTIME_COMPILER -DHAVE_SYSMODULES -DHAVE_SYSUTILS -DHAVE_RARCH_EXEC -DHAVE_RSOUND -DHAVE_ZLIB -DHAVE_RPNG -DWANT_ZLIB -DSINC_LOWER_QUALITY -D__CELLOS_LV2__ -DHAVE_NETWORKING=1 -DHAVE_SOCKET_LEGACY=1 -DHAVE_MOUSE -DHAVE_GRIFFIN=1 -DHAVE_MULTIMAN=0 -DPC_DEVELOPMENT_IP_ADDRESS=\"$(PC_DEVELOPMENT_IP_ADDRESS)\" -DPC_DEVELOPMENT_UDP_PORT=$(PC_DEVELOPMENT_UDP_PORT) -DHAVE_STB_VORBIS
ifeq ($(DEBUG), 1)
PPU_OPTIMIZE_LV := -O0 -g

4
Makefile.psl1ght
View File

@ -17,7 +17,7 @@ ELF_TARGET := retroarch_psl1ght.elf
EBOOT_PATH = pkg/ps3/USRDIR/EBOOT.BIN
CORE_PATH = pkg/ps3/USRDIR/cores/CORE.SELF
INCLUDE := -I. -I$(PS3DEV)/ppu/include -Ideps/libz -Ips3/gcmgl/include/export -Ips3/include
INCLUDE := -I. -I$(PS3DEV)/ppu/include -Ideps/libz -Ips3/gcmgl/include/export -Ips3/include -Ideps -Ideps/stb
LIBDIRS := -L$(PS3DEV)/ppu/lib -L$(PS3DEV)/portlibs/ppu/lib -L.
MACHDEP := -D__CELLOS_LV2__ -D__PSL1GHT__
@ -89,7 +89,7 @@ ifeq ($(HAVE_FILE_LOGGER), 1)
CFLAGS += -DHAVE_FILE_LOGGER
endif
SHARED_FLAGS := -DRARCH_CONSOLE -DHAVE_OPENGL -DHAVE_OVERLAY -DHAVE_HEADSET -DHAVE_OPENGLES -DHAVE_OPENGLES1 -DHAVE_PSGL -DHAVE_CG -DHAVE_CG_RUNTIME_COMPILER -DHAVE_GCMGL -DHAVE_FBO -DHAVE_SYSMODULES -DHAVE_SYSUTILS -DHAVE_RARCH_EXEC -DHAVE_MOUSE -DHAVE_ZLIB -DHAVE_RPNG -DWANT_ZLIB -DHAVE_GRIFFIN=1 -DHAVE_NETWORKING=1 -DHAVE_SOCKET_LEGACY=1 -DPC_DEVELOPMENT_IP_ADDRESS=\"$(PC_DEVELOPMENT_IP_ADDRESS)\" -DPC_DEVELOPMENT_UDP_PORT=$(PC_DEVELOPMENT_UDP_PORT) -Wno-char-subscripts -DHAVE_CC_RESAMPLER
SHARED_FLAGS := -DRARCH_CONSOLE -DHAVE_OPENGL -DHAVE_OVERLAY -DHAVE_HEADSET -DHAVE_OPENGLES -DHAVE_OPENGLES1 -DHAVE_PSGL -DHAVE_CG -DHAVE_CG_RUNTIME_COMPILER -DHAVE_GCMGL -DHAVE_SYSMODULES -DHAVE_SYSUTILS -DHAVE_RARCH_EXEC -DHAVE_MOUSE -DHAVE_ZLIB -DHAVE_RPNG -DWANT_ZLIB -DHAVE_GRIFFIN=1 -DHAVE_NETWORKING=1 -DHAVE_SOCKET_LEGACY=1 -DPC_DEVELOPMENT_IP_ADDRESS=\"$(PC_DEVELOPMENT_IP_ADDRESS)\" -DPC_DEVELOPMENT_UDP_PORT=$(PC_DEVELOPMENT_UDP_PORT) -Wno-char-subscripts -DHAVE_CC_RESAMPLER
CFLAGS += -std=gnu99 $(SHARED_FLAGS)
CXXFLAGS += $(SHARED_FLAGS)

2
Makefile.psp1
View File

@ -19,7 +19,7 @@ ifeq ($(WHOLE_ARCHIVE_LINK), 1)
WHOLE_END := -Wl,--no-whole-archive
endif
INCDIR = deps/libz deps/7zip libretro-common/include
INCDIR = deps deps/stb deps/libz deps/7zip libretro-common/include
CFLAGS = $(OPTIMIZE_LV) -G0 -std=gnu99 -ffast-math
ASFLAGS = $(CFLAGS)

2
Makefile.vita
View File

@ -98,7 +98,7 @@ STRIP := $(PREFIX)strip
NM := $(PREFIX)nm
LD := $(CXX)
INCDIRS := -I. -Ideps/libz -Ideps/7zip -Ilibretro-common/include
INCDIRS := -I. -Ideps/libz -Ideps/7zip -Ilibretro-common/include -Ideps/stb
LIBDIRS := -L.
ARCHFLAGS := -march=armv7-a -mfpu=neon -mfloat-abi=hard -DVITA

41
Makefile.wiiu
View File

@ -5,6 +5,10 @@ DEBUG = 0
GRIFFIN_BUILD = 0
WHOLE_ARCHIVE_LINK = 0
ifneq ($(V), 1)
Q := @
endif
PC_DEVELOPMENT_IP_ADDRESS ?=
PC_DEVELOPMENT_TCP_PORT ?=
@ -130,7 +134,7 @@ else
endif
INCDIRS := -I. -Ideps/libz -Ideps/7zip -Ilibretro-common/include -Iwiiu -Iwiiu/include -I$(DEVKITPRO)/portlibs/ppc/include
INCDIRS := -I. -Ideps -Ideps/stb -Ideps/libz -Ideps/7zip -Ilibretro-common/include -Iwiiu -Iwiiu/include -I$(DEVKITPRO)/portlibs/ppc/include
LIBDIRS := -L. -L$(DEVKITPRO)/portlibs/ppc/lib
CFLAGS := -mwup -mcpu=750 -meabi -mhard-float
@ -202,41 +206,50 @@ all: $(TARGETS)
%.o: %.cpp
%.o: %.cpp %.depend
$(CXX) -c -o $@ $< $(CXXFLAGS) $(INCDIRS) $(DEPFLAGS)
$(POSTCOMPILE)
@$(if $(Q), echo CXX $<,)
$(Q)$(CXX) -c -o $@ $< $(CXXFLAGS) $(INCDIRS) $(DEPFLAGS)
$(Q)$(POSTCOMPILE)
%.o: %.c
%.o: %.c %.depend
$(CC) -c -o $@ $< $(CFLAGS) $(INCDIRS) $(DEPFLAGS)
$(POSTCOMPILE)
@$(if $(Q), echo CC $<,)
$(Q)$(CC) -c -o $@ $< $(CFLAGS) $(INCDIRS) $(DEPFLAGS)
$(Q)$(POSTCOMPILE)
%.o: %.S
%.o: %.S %.depend
$(CC) -c -o $@ $< $(ASFLAGS) $(INCDIRS) $(DEPFLAGS)
$(POSTCOMPILE)
@$(if $(Q), echo AS $<,)
$(Q)$(CC) -c -o $@ $< $(ASFLAGS) $(INCDIRS) $(DEPFLAGS)
$(Q)$(POSTCOMPILE)
%.o: %.s
%.o: %.s %.depend
$(CC) -c -o $@ $< $(ASFLAGS) $(INCDIRS) $(DEPFLAGS)
$(POSTCOMPILE)
@$(if $(Q), echo AS $<,)
$(Q)$(CC) -c -o $@ $< $(ASFLAGS) $(INCDIRS) $(DEPFLAGS)
$(Q)$(POSTCOMPILE)
%.a:
$(AR) -rc $@ $^
@$(if $(Q), echo AR $<,)
$(Q)$(AR) -rc $@ $^
%.depend: ;
$(ELF2RPL):
$(MAKE) -C wiiu/wut/elf2rpl/
@$(if $(Q), echo MAKE $@,)
$(Q)$(MAKE) -C wiiu/wut/elf2rpl/
$(TARGET).elf: $(OBJ) $(HBL_ELF_OBJ) libretro_wiiu.a wiiu/link_elf.ld
$(LD) $(OBJ) $(HBL_ELF_OBJ) $(LDFLAGS) $(HBL_ELF_LDFLAGS) $(LIBDIRS) $(LIBS) -o $@
@$(if $(Q), echo LD $@,)
$(Q)$(LD) $(OBJ) $(HBL_ELF_OBJ) $(LDFLAGS) $(HBL_ELF_LDFLAGS) $(LIBDIRS) $(LIBS) -o $@
$(TARGET).rpx.elf: $(OBJ) $(RPX_OBJ) libretro_wiiu.a wiiu/link_elf.ld
$(LD) $(OBJ) $(RPX_OBJ) $(LDFLAGS) $(RPX_LDFLAGS) $(LIBDIRS) $(LIBS) -o $@
@$(if $(Q), echo LD $@,)
$(Q)$(LD) $(OBJ) $(RPX_OBJ) $(LDFLAGS) $(RPX_LDFLAGS) $(LIBDIRS) $(LIBS) -o $@
$(TARGET).rpx: $(TARGET).rpx.elf $(ELF2RPL)
-$(ELF2RPL) $(TARGET).rpx.elf $@
@$(if $(Q), echo ELF2RPL $@,)
$(Q)-$(ELF2RPL) $(TARGET).rpx.elf $@
clean:
rm -f $(OBJ) $(RPX_OBJ) $(HBL_ELF_OBJ) $(TARGET).elf $(TARGET).rpx.elf $(TARGET).rpx

5
Makefile.win
View File

@ -5,7 +5,6 @@ HAVE_XAUDIO = 1
HAVE_DSOUND = 1
HAVE_WASAPI = 1
HAVE_OPENGL = 1
HAVE_FBO = 1
HAVE_DYLIB = 1
HAVE_D3D9 = 1
HAVE_NETWORKING = 1
@ -122,8 +121,8 @@ else
CXXFLAGS += -O3 -ffast-math
endif
CFLAGS += -Wall -Wno-unused-result -Wno-unused-variable -I.
CXXFLAGS += -Wall -Wno-unused-result -Wno-unused-variable -I. -std=c++98 -D__STDC_CONSTANT_MACROS
CFLAGS += -Wall -Wno-unused-result -Wno-unused-variable -I. -Ideps
CXXFLAGS += -Wall -Wno-unused-result -Wno-unused-variable -I. -Ideps -std=c++98 -D__STDC_CONSTANT_MACROS
ifeq ($(CXX_BUILD), 1)
CFLAGS += -std=c++98 -xc++ -D__STDC_CONSTANT_MACROS
else

20
README.md
View File

@ -36,13 +36,16 @@ or visit our IRC channel: #retroarch @ irc.freenode.org.
## Documentation
See our [wiki](https://github.com/libretro/RetroArch/wiki). On Unix, man-pages are provided.
See our [Documentation Center](https://docs.libretro.com/). On Unix, man-pages are provided.
More developer-centric stuff is found [here](https://github.com/libretro/libretro.github.com/wiki/Documentation-devs).
## Related projects
- Cg/HLSL shaders: [common-shaders](https://github.com/libretro/common-shaders)
- slang shaders: [slang-shaders](https://github.com/libretro/slang-shaders)
- GLSL shaders: [glsl-shaders](https://github.com/libretro/glsl-shaders)
- Helper scripts to build libretro implementations: [libretro-super](https://github.com/libretro/libretro-super)
- GitHub mirrors of projects, useful for generating diff files: [libretro-mirrors](https://github.com/libretro-mirrors/)
## Philosophy
@ -58,12 +61,19 @@ RetroArch also emphasizes on being easy to integrate into various launcher front
## Platforms
RetroArch has been ported to the following platforms outside PC:
RetroArch has been ported to the following platforms:
- Windows
- Linux
- FreeBSD
- NetBSD
- MacOS
- PlayStation 3
- PlayStation Portable
- Original Xbox
- Xbox 360 (Libxenon/XeXDK)
- Xbox 1
- Wii, Gamecube (Libogc)
- Wii, GameCube (Libogc)
- WiiU
- Nintendo 3DS
- Raspberry Pi
- Android
@ -126,4 +136,4 @@ To configure joypads, use the built-in menu or the `retroarch-joyconfig` command
## Compiling and installing
Instructions for compiling and installing RetroArch can be found in the [Libretro/RetroArch Documentation Center](https://buildbot.libretro.com/docs).
Instructions for compiling and installing RetroArch can be found in the [Libretro/RetroArch Documentation Center](https://docs.libretro.com/).

12
audio/drivers/wiiu_audio.c
View File

@ -193,11 +193,11 @@ static bool ax_audio_start(void* data, bool is_shutdown)
static ssize_t ax_audio_write(void* data, const void* buf, size_t size)
{
int i;
uint32_t i;
size_t countAvail = 0;
ax_audio_t* ax = (ax_audio_t*)data;
const uint16_t* src = buf;
int count = size >> 2;
size_t count = size >> 2;
if(!size || (size & 0x3))
return 0;
@ -330,8 +330,8 @@ audio_driver_t audio_ax =
ax_audio_free,
ax_audio_use_float,
"AX",
NULL,
NULL,
/* ax_audio_write_avail, */
/* ax_audio_buffer_size */
NULL, /* device_list_new */
NULL, /* device_list_free */
NULL, /* write_avail */
NULL, /* buffer_size */
};

502
cheevos/cheevos.c
View File

@ -99,27 +99,6 @@
#define CHEEVOS_EIGHT_MB ( 8 * 1024 * 1024)
#define CHEEVOS_SIZE_LIMIT (64 * 1024 * 1024)
enum
{
CHEEVOS_DIRTY_TITLE = 1 << 0,
CHEEVOS_DIRTY_DESC = 1 << 1,
CHEEVOS_DIRTY_POINTS = 1 << 2,
CHEEVOS_DIRTY_AUTHOR = 1 << 3,
CHEEVOS_DIRTY_ID = 1 << 4,
CHEEVOS_DIRTY_BADGE = 1 << 5,
CHEEVOS_DIRTY_CONDITIONS = 1 << 6,
CHEEVOS_DIRTY_VOTES = 1 << 7,
CHEEVOS_DIRTY_DESCRIPTION = 1 << 8,
CHEEVOS_DIRTY_ALL = (1 << 9) - 1
};
enum
{
CHEEVOS_ACTIVE_SOFTCORE = 1 << 0,
CHEEVOS_ACTIVE_HARDCORE = 1 << 1
};
typedef struct
{
cheevos_cond_t *conds;
@ -208,18 +187,21 @@ typedef struct
typedef struct
{
cheevos_var_t var;
int multiplier;
double multiplier;
bool compare_next;
} cheevos_term_t;
typedef struct
{
cheevos_term_t *terms;
unsigned count;
unsigned compare_count;
} cheevos_expr_t;
typedef struct
{
unsigned id;
unsigned format;
const char *title;
const char *description;
int active;
@ -231,6 +213,42 @@ typedef struct
cheevos_expr_t value;
} cheevos_leaderboard_t;
/*
typedef struct
{
bool is_lookup;
char* prestring;
cheevos_expr_t expression;
} cheevos_rps_element_t;
typedef struct
{
char* name;
unsigned type;
} cheevos_rps_format_t;
typedef struct
{
unsigned compare;
char* result;
} cheevos_rps_lookup_value;
typedef struct
{
char* name;
cheevos_rps_lookup_value* values;
} cheevos_rps_lookup_t;
typedef struct
{
cheevos_rps_element_t* elements;
cheevos_rps_format_t* formats;
unsigned format_count;
cheevos_rps_lookup_t* lookups;
unsigned lookup_count;
} cheevos_rps_t;
*/
typedef struct
{
int console_id;
@ -865,7 +883,9 @@ static int cheevos_parse_condition(cheevos_condition_t *condition, const char* m
unsigned set = 0;
cheevos_condset_t *condset = NULL;
cheevos_condset_t *conds = NULL;
const cheevos_condset_t* end;
const cheevos_condset_t* end = NULL;
(void)conds;
condition->condsets = (cheevos_condset_t*)
calloc(condition->count, sizeof(cheevos_condset_t));
@ -895,9 +915,10 @@ static int cheevos_parse_condition(cheevos_condition_t *condition, const char* m
{
while (--condset >= condition->condsets)
{
free((void*)condset->conds);
if ((void*)condset->conds)
free((void*)condset->conds);
}
return -1;
}
@ -910,7 +931,6 @@ static int cheevos_parse_condition(cheevos_condition_t *condition, const char* m
return 0;
}
#ifdef CHEEVOS_ENABLE_LBOARDS
static void cheevos_free_condition(cheevos_condition_t* condition)
{
unsigned i;
@ -918,54 +938,107 @@ static void cheevos_free_condition(cheevos_condition_t* condition)
if (condition->condsets)
{
for (i = 0; i < condition->count; i++)
free((void*)condition->condsets[i].conds);
{
if (condition->condsets[i].conds)
{
free(condition->condsets[i].conds);
condition->condsets[i].conds = NULL;
}
}
free((void*)condition->condsets);
if (condition->condsets)
{
free(condition->condsets);
condition->condsets = NULL;
}
}
}
#endif
/*****************************************************************************
Parse the Mem field of leaderboards.
*****************************************************************************/
#ifdef CHEEVOS_ENABLE_LBOARDS
static int cheevos_parse_expression(cheevos_expr_t *expr, const char* mem)
{
const char* aux;
char* end;
unsigned i;
expr->count = 1;
expr->compare_count = 1;
for (aux = mem; *aux != '"'; aux++)
{
expr->count += *aux == '_';
}
expr->terms = (cheevos_term_t*)calloc(expr->count, sizeof(cheevos_term_t));
if (!expr->terms)
return -1;
for (i = 0, aux = mem; i < expr->count; i++)
for (i = 0; i < expr->count; i++)
{
expr->terms[i].compare_next = false;
expr->terms[i].multiplier = 1;
}
for (i = 0, aux = mem; i < expr->count;)
{
cheevos_var_parse(&expr->terms[i].var, &aux);
if (*aux != '*')
{
free((void*)expr->terms);
return -1;
/* expression has no multiplier */
if (*aux == '_')
{
aux++;
i++;
}
else if (*aux == '$')
{
expr->terms[i].compare_next = true;
expr->compare_count++;
aux++;
i++;
}
/* no multiplier at end of string */
else if (*aux == '\0' || *aux == '"' || *aux == ',')
return 0;
/* invalid character in expression */
else
{
if (expr->terms)
{
free(expr->terms);
expr->terms = NULL;
}
return -1;
}
}
else
{
if(aux[1] == 'h' || aux[1] == 'H')
expr->terms[i].multiplier = (double)strtol(aux + 2, &end, 16);
else
expr->terms[i].multiplier = strtod(aux + 1, &end);
aux = end;
expr->terms[i].multiplier = (int)strtol(aux + 1, &end, 10);
aux = end + 1;
if(*aux == '$')
{
aux++;
expr->terms[i].compare_next = true;
expr->compare_count++;
}
else
expr->terms[i].compare_next = false;
aux++;
i++;
}
}
return 0;
}
#endif
#ifdef CHEEVOS_ENABLE_LBOARDS
static int cheevos_parse_mem(cheevos_leaderboard_t *lb, const char* mem)
{
lb->start.condsets = NULL;
@ -1014,10 +1087,13 @@ error:
cheevos_free_condition(&lb->start);
cheevos_free_condition(&lb->cancel);
cheevos_free_condition(&lb->submit);
free((void*)lb->value.terms);
if (lb->value.terms)
{
free((void*)lb->value.terms);
lb->value.terms = NULL;
}
return -1;
}
#endif
/*****************************************************************************
Load achievements from a JSON string.
@ -1073,19 +1149,104 @@ static int cheevos_new_cheevo(cheevos_readud_t *ud)
return 0;
error:
free((void*)cheevo->title);
free((void*)cheevo->description);
free((void*)cheevo->author);
free((void*)cheevo->badge);
if (cheevo->title)
{
free((void*)cheevo->title);
cheevo->title = NULL;
}
if (cheevo->description)
{
free((void*)cheevo->description);
cheevo->description = NULL;
}
if (cheevo->author)
{
free((void*)cheevo->author);
cheevo->author = NULL;
}
if (cheevo->badge)
{
free((void*)cheevo->badge);
cheevo->badge = NULL;
}
return -1;
}
#ifdef CHEEVOS_ENABLE_LBOARDS
/*****************************************************************************
Helper functions for displaying leaderboard values.
*****************************************************************************/
static void cheevos_format_value(const unsigned value, const unsigned type,
char* formatted_value, size_t formatted_size)
{
unsigned mins, secs, millis;
switch(type)
{
case CHEEVOS_FORMAT_VALUE:
snprintf(formatted_value, formatted_size, "%u", value);
break;
case CHEEVOS_FORMAT_SCORE:
snprintf(formatted_value, formatted_size, "%06upts", value);
break;
case CHEEVOS_FORMAT_FRAMES:
mins = value / 3600;
secs = (value % 3600) / 60;
millis = (int) (value % 60) * (10.00 / 6.00);
snprintf(formatted_value, formatted_size, "%02u:%02u.%02u", mins, secs, millis);
break;
case CHEEVOS_FORMAT_MILLIS:
mins = value / 6000;
secs = (value % 6000) / 100;
millis = (int) (value % 100);
snprintf(formatted_value, formatted_size, "%02u:%02u.%02u", mins, secs, millis);
break;
case CHEEVOS_FORMAT_SECS:
mins = value / 60;
secs = value % 60;
snprintf(formatted_value, formatted_size, "%02u:%02u", mins, secs);
break;
default:
snprintf(formatted_value, formatted_size, "%u (?)", value);
}
}
unsigned cheevos_parse_format(cheevos_field_t* format)
{
/* Most likely */
if (strncmp(format->string, "VALUE", format->length) == 0)
return CHEEVOS_FORMAT_VALUE;
else if (strncmp(format->string, "TIME", format->length) == 0)
return CHEEVOS_FORMAT_FRAMES;
else if (strncmp(format->string, "SCORE", format->length) == 0)
return CHEEVOS_FORMAT_SCORE;
/* Less likely */
else if (strncmp(format->string, "MILLISECS", format->length) == 0)
return CHEEVOS_FORMAT_MILLIS;
else if (strncmp(format->string, "TIMESECS", format->length) == 0)
return CHEEVOS_FORMAT_SECS;
/* Rare (RPS only) */
else if (strncmp(format->string, "POINTS", format->length) == 0)
return CHEEVOS_FORMAT_SCORE;
else if (strncmp(format->string, "FRAMES", format->length) == 0)
return CHEEVOS_FORMAT_FRAMES;
else
return CHEEVOS_FORMAT_OTHER;
}
static int cheevos_new_lboard(cheevos_readud_t *ud)
{
cheevos_leaderboard_t *lboard = cheevos_locals.leaderboards + ud->lboard_count++;
lboard->id = strtol(ud->id.string, NULL, 10);
lboard->format = cheevos_parse_format(&ud->format);
lboard->title = cheevos_dupstr(&ud->title);
lboard->description = cheevos_dupstr(&ud->desc);
@ -1102,11 +1263,12 @@ static int cheevos_new_lboard(cheevos_readud_t *ud)
return 0;
error:
free((void*)lboard->title);
free((void*)lboard->description);
if ((void*)lboard->title)
free((void*)lboard->title);
if ((void*)lboard->description)
free((void*)lboard->description);
return -1;
}
#endif
static int cheevos_read__json_key( void *userdata,
const char *name, size_t length)
@ -1222,10 +1384,8 @@ static int cheevos_read__json_end_object(void *userdata)
if (ud->in_cheevos)
return cheevos_new_cheevo(ud);
#ifdef CHEEVOS_ENABLE_LBOARDS
else if (ud->in_lboards)
return cheevos_new_lboard(ud);
#endif
return 0;
}
@ -1282,9 +1442,12 @@ static int cheevos_parse(const char *json)
if ( !cheevos_locals.core.cheevos || !cheevos_locals.unofficial.cheevos
|| !cheevos_locals.leaderboards)
{
free((void*)cheevos_locals.core.cheevos);
free((void*)cheevos_locals.unofficial.cheevos);
free((void*)cheevos_locals.leaderboards);
if ((void*)cheevos_locals.core.cheevos)
free((void*)cheevos_locals.core.cheevos);
if ((void*)cheevos_locals.unofficial.cheevos)
free((void*)cheevos_locals.unofficial.cheevos);
if ((void*)cheevos_locals.leaderboards)
free((void*)cheevos_locals.leaderboards);
cheevos_locals.core.count = cheevos_locals.unofficial.count =
cheevos_locals.lboard_count = 0;
@ -1630,8 +1793,11 @@ static void cheevos_test_cheevo_set(const cheevoset_t *set)
RARCH_LOG("[CHEEVOS]: awarding cheevo %u: %s (%s).\n",
cheevo->id, cheevo->title, cheevo->description);
runloop_msg_queue_push(cheevo->title, 0, 3 * 60, false);
runloop_msg_queue_push(cheevo->description, 0, 5 * 60, false);
char msg[256];
snprintf(msg, sizeof(msg), "Achievement Unlocked: %s", cheevo->title);
msg[sizeof(msg) - 1] = 0;
runloop_msg_queue_push(msg, 0, 2 * 60, false);
runloop_msg_queue_push(cheevo->description, 0, 3 * 60, false);
cheevos_make_unlock_url(cheevo, url, sizeof(url));
task_push_http_transfer(url, true, NULL, cheevos_unlocked, cheevo);
@ -1642,7 +1808,6 @@ static void cheevos_test_cheevo_set(const cheevoset_t *set)
}
}
#ifdef CHEEVOS_ENABLE_LBOARDS
static int cheevos_test_lboard_condition(const cheevos_condition_t* condition)
{
int dirty_conds = 0;
@ -1677,14 +1842,28 @@ static int cheevos_expr_value(cheevos_expr_t* expr)
{
cheevos_term_t* term = expr->terms;
unsigned i;
int value = 0;
/* Separate possible values with '$' operator, submit the largest */
unsigned current_value = 0;
int values[expr->compare_count];
memset(values, 0, sizeof values);
for (i = expr->count; i != 0; i--, term++)
{
value += cheevos_var_get_value(&term->var) * term->multiplier;
values[current_value] += cheevos_var_get_value(&term->var) * term->multiplier;
if (term->compare_next)
current_value++;
}
return value;
if (expr->compare_count > 1)
{
int maximum = values[0];
for (unsigned j = 1; j < expr->compare_count; j++)
maximum = values[j] > maximum ? values[j] : maximum;
return maximum;
}
else return values[0];
}
static void cheevos_make_lboard_url(const cheevos_leaderboard_t *lboard,
@ -1697,7 +1876,7 @@ static void cheevos_make_lboard_url(const cheevos_leaderboard_t *lboard,
hash[0] = '\0';
snprintf(signature, sizeof(signature), "%u%s%u", lboard->id,
snprintf(signature, sizeof(signature), "%u%s%u", lboard->id,
settings->arrays.cheevos_username,
lboard->id);
@ -1725,9 +1904,7 @@ static void cheevos_make_lboard_url(const cheevos_leaderboard_t *lboard,
cheevos_log_url("[CHEEVOS]: url to submit the leaderboard: %s\n", url);
#endif
}
#endif
#ifdef CHEEVOS_ENABLE_LBOARDS
static void cheevos_lboard_submit(void *task_data, void *user_data, const char *error)
{
cheevos_leaderboard_t *lboard = (cheevos_leaderboard_t *)user_data;
@ -1750,9 +1927,7 @@ static void cheevos_lboard_submit(void *task_data, void *user_data, const char *
}
#endif
}
#endif
#ifdef CHEEVOS_ENABLE_LBOARDS
static void cheevos_test_leaderboards(void)
{
cheevos_leaderboard_t* lboard = cheevos_locals.leaderboards;
@ -1774,18 +1949,35 @@ static void cheevos_test_leaderboards(void)
if (cheevos_test_lboard_condition(&lboard->submit))
{
char url[256];
lboard->active = 0;
cheevos_make_lboard_url(lboard, url, sizeof(url));
task_push_http_transfer(url, true, NULL, cheevos_lboard_submit, lboard);
/* failsafe for improper LBs */
if (value == 0)
{
RARCH_LOG("[CHEEVOS]: error: lboard %s tried to submit 0\n", lboard->title);
runloop_msg_queue_push("Leaderboard attempt cancelled!", 0, 2 * 60, false);
}
else
{
char url[256];
cheevos_make_lboard_url(lboard, url, sizeof(url));
task_push_http_transfer(url, true, NULL, cheevos_lboard_submit, lboard);
RARCH_LOG("[CHEEVOS]: submit lboard %s\n", lboard->title);
RARCH_LOG("[CHEEVOS]: submit lboard %s\n", lboard->title);
char msg[256];
char formatted_value[16];
cheevos_format_value(value, lboard->format, formatted_value, sizeof(formatted_value));
snprintf(msg, sizeof(msg), "Submitted %s for %s", formatted_value, lboard->title);
msg[sizeof(msg) - 1] = 0;
runloop_msg_queue_push(msg, 0, 2 * 60, false);
}
}
if (cheevos_test_lboard_condition(&lboard->cancel))
{
RARCH_LOG("[CHEEVOS]: cancel lboard %s\n", lboard->title);
lboard->active = 0;
runloop_msg_queue_push("Leaderboard attempt cancelled!", 0, 2 * 60, false);
}
}
else
@ -1795,11 +1987,16 @@ static void cheevos_test_leaderboards(void)
RARCH_LOG("[CHEEVOS]: start lboard %s\n", lboard->title);
lboard->active = 1;
lboard->last_value = -1;
char msg[256];
snprintf(msg, sizeof(msg), "Leaderboard Active: %s", lboard->title);
msg[sizeof(msg) - 1] = 0;
runloop_msg_queue_push(msg, 0, 2 * 60, false);
runloop_msg_queue_push(lboard->description, 0, 3*60, false);
}
}
}
}
#endif
/*****************************************************************************
Free the loaded achievements.
@ -1807,15 +2004,20 @@ Free the loaded achievements.
static void cheevos_free_condset(const cheevos_condset_t *set)
{
free((void*)set->conds);
if (set->conds)
free((void*)set->conds);
}
static void cheevos_free_cheevo(const cheevo_t *cheevo)
{
free((void*)cheevo->title);
free((void*)cheevo->description);
free((void*)cheevo->author);
free((void*)cheevo->badge);
if (cheevo->title)
free((void*)cheevo->title);
if (cheevo->description)
free((void*)cheevo->description);
if (cheevo->author)
free((void*)cheevo->author);
if (cheevo->badge)
free((void*)cheevo->badge);
cheevos_free_condset(cheevo->condition.condsets);
}
@ -1827,7 +2029,8 @@ static void cheevos_free_cheevo_set(const cheevoset_t *set)
while (cheevo < end)
cheevos_free_cheevo(cheevo++);
free((void*)set->cheevos);
if (set->cheevos)
free((void*)set->cheevos);
}
#ifndef CHEEVOS_DONT_DEACTIVATE
@ -2128,7 +2331,7 @@ static void cheevos_patch_addresses(cheevoset_t* set)
case CHEEVOS_VAR_TYPE_DELTA_MEM:
cheevos_var_patch_addr(&cond->source, cheevos_locals.console_id);
#ifdef CHEEVOS_DUMP_ADDRS
RARCH_LOG("[CHEEVOS]: var %03d:%08X\n", cond->source.bank_id + 1, cond->source.value);
RARCH_LOG("[CHEEVOS]: s-var %03d:%08X\n", cond->source.bank_id + 1, cond->source.value);
#endif
break;
@ -2142,7 +2345,7 @@ static void cheevos_patch_addresses(cheevoset_t* set)
case CHEEVOS_VAR_TYPE_DELTA_MEM:
cheevos_var_patch_addr(&cond->target, cheevos_locals.console_id);
#ifdef CHEEVOS_DUMP_ADDRS
RARCH_LOG("[CHEEVOS]: var %03d:%08X\n", cond->target.bank_id + 1, cond->target.value);
RARCH_LOG("[CHEEVOS]: t-var %03d:%08X\n", cond->target.bank_id + 1, cond->target.value);
#endif
break;
@ -2154,6 +2357,85 @@ static void cheevos_patch_addresses(cheevoset_t* set)
}
}
static void cheevos_patch_lb_conditions(cheevos_condition_t* condition)
{
unsigned i, j;
cheevos_condset_t* condset = condition->condsets;
for (i = condition->count; i != 0; i--, condset++)
{
cheevos_cond_t* cond = condset->conds;
for (j = condset->count; j != 0; j--, cond++)
{
switch (cond->source.type)
{
case CHEEVOS_VAR_TYPE_ADDRESS:
case CHEEVOS_VAR_TYPE_DELTA_MEM:
cheevos_var_patch_addr(&cond->source, cheevos_locals.console_id);
#ifdef CHEEVOS_DUMP_ADDRS
RARCH_LOG("[CHEEVOS]: s-var %03d:%08X\n", cond->source.bank_id + 1, cond->source.value);
#endif
break;
default:
break;
}
switch (cond->target.type)
{
case CHEEVOS_VAR_TYPE_ADDRESS:
case CHEEVOS_VAR_TYPE_DELTA_MEM:
cheevos_var_patch_addr(&cond->target, cheevos_locals.console_id);
#ifdef CHEEVOS_DUMP_ADDRS
RARCH_LOG("[CHEEVOS]: t-var %03d:%08X\n", cond->target.bank_id + 1, cond->target.value);
#endif
break;
default:
break;
}
}
}
}
static void cheevos_patch_lb_expressions(cheevos_expr_t* expression)
{
unsigned i;
cheevos_term_t* term = expression->terms;
for (i = expression->count; i != 0; i--, term++)
{
switch (term->var.type)
{
case CHEEVOS_VAR_TYPE_ADDRESS:
case CHEEVOS_VAR_TYPE_DELTA_MEM:
cheevos_var_patch_addr(&term->var, cheevos_locals.console_id);
#ifdef CHEEVOS_DUMP_ADDRS
RARCH_LOG("[CHEEVOS]: s-var %03d:%08X\n", term->var.bank_id + 1, term->var.value);
#endif
break;
default:
break;
}
}
}
static void cheevos_patch_lbs(cheevos_leaderboard_t *leaderboard)
{
unsigned i;
for(i = 0; i < cheevos_locals.lboard_count; i++)
{
cheevos_condition_t* start = &leaderboard[i].start;
cheevos_condition_t* cancel = &leaderboard[i].cancel;
cheevos_condition_t* submit = &leaderboard[i].submit;
cheevos_expr_t* value = &leaderboard[i].value;
cheevos_patch_lb_conditions(start);
cheevos_patch_lb_conditions(cancel);
cheevos_patch_lb_conditions(submit);
cheevos_patch_lb_expressions(value);
}
}
void cheevos_test(void)
{
settings_t *settings = config_get_ptr();
@ -2162,6 +2444,7 @@ void cheevos_test(void)
{
cheevos_patch_addresses(&cheevos_locals.core);
cheevos_patch_addresses(&cheevos_locals.unofficial);
cheevos_patch_lbs(cheevos_locals.leaderboards);
cheevos_locals.addrs_patched = true;
}
@ -2171,9 +2454,8 @@ void cheevos_test(void)
if (settings->bools.cheevos_test_unofficial)
cheevos_test_cheevo_set(&cheevos_locals.unofficial);
#ifdef CHEEVOS_ENABLE_LBOARDS
cheevos_test_leaderboards();
#endif
if (settings->bools.cheevos_hardcore_mode_enable && settings->bools.cheevos_leaderboards_enable)
cheevos_test_leaderboards();
}
bool cheevos_set_cheats(void)
@ -2369,7 +2651,7 @@ static int cheevos_iterate(coro_t* coro)
/* Load the content into memory, or copy it over to our own buffer */
if (!CHEEVOS_VAR_DATA)
{
CHEEVOS_VAR_STREAM = filestream_open(CHEEVOS_VAR_PATH, RFILE_MODE_READ, 0);
CHEEVOS_VAR_STREAM = filestream_open(CHEEVOS_VAR_PATH, RFILE_MODE_READ, -1);
if (!CHEEVOS_VAR_STREAM)
CORO_STOP();
@ -2521,11 +2803,13 @@ static int cheevos_iterate(coro_t* coro)
#endif
if (cheevos_parse(CHEEVOS_VAR_JSON))
{
free((void*)CHEEVOS_VAR_JSON);
if ((void*)CHEEVOS_VAR_JSON)
free((void*)CHEEVOS_VAR_JSON);
CORO_STOP();
}
free((void*)CHEEVOS_VAR_JSON);
if ((void*)CHEEVOS_VAR_JSON)
free((void*)CHEEVOS_VAR_JSON);
cheevos_loaded = true;
/*
@ -2633,7 +2917,7 @@ static int cheevos_iterate(coro_t* coro)
* Output CHEEVOS_VAR_GAMEID the Retro Achievements game ID, or 0 if not found
*************************************************************************/
CORO_SUB(LYNX_MD5)
if (CHEEVOS_VAR_LEN < 0x0240)
{
CHEEVOS_VAR_GAMEID = 0;
@ -2816,12 +3100,14 @@ static int cheevos_iterate(coro_t* coro)
if (cheevos_get_value(CHEEVOS_VAR_JSON, CHEEVOS_JSON_KEY_GAMEID, gameid, sizeof(gameid)))
{
free((void*)CHEEVOS_VAR_JSON);
if ((void*)CHEEVOS_VAR_JSON)
free((void*)CHEEVOS_VAR_JSON);
RARCH_ERR("[CHEEVOS]: error getting game_id.\n");
CORO_RET();
}
free((void*)CHEEVOS_VAR_JSON);
if ((void*)CHEEVOS_VAR_JSON)
free((void*)CHEEVOS_VAR_JSON);
RARCH_LOG("[CHEEVOS]: got game id %s.\n", gameid);
CHEEVOS_VAR_GAMEID = strtol(gameid, NULL, 10);
CORO_RET();
@ -2903,7 +3189,8 @@ static int cheevos_iterate(coro_t* coro)
if (CHEEVOS_VAR_JSON)
{
int res = cheevos_get_value(CHEEVOS_VAR_JSON, CHEEVOS_JSON_KEY_TOKEN, cheevos_locals.token, sizeof(cheevos_locals.token));
free((void*)CHEEVOS_VAR_JSON);
if ((void*)CHEEVOS_VAR_JSON)
free((void*)CHEEVOS_VAR_JSON);
if (!res)
{
@ -2952,7 +3239,7 @@ static int cheevos_iterate(coro_t* coro)
{
if (CHEEVOS_VAR_K != 0)
RARCH_LOG("[CHEEVOS]: Retrying HTTP request: %u of 5\n", CHEEVOS_VAR_K + 1);
CHEEVOS_VAR_JSON = NULL;
CHEEVOS_VAR_CONN = net_http_connection_new(CHEEVOS_VAR_URL, "GET", NULL);
@ -3045,8 +3332,9 @@ static int cheevos_iterate(coro_t* coro)
RARCH_LOG("[CHEEVOS]: deactivated unlocked achievements in softcore mode.\n");
else
RARCH_ERR("[CHEEVOS]: error deactivating unlocked achievements in softcore mode.\n");
free((void*)CHEEVOS_VAR_JSON);
if ((void*)CHEEVOS_VAR_JSON)
free((void*)CHEEVOS_VAR_JSON);
}
else
RARCH_ERR("[CHEEVOS]: error retrieving list of unlocked achievements in softcore mode.\n");
@ -3073,8 +3361,9 @@ static int cheevos_iterate(coro_t* coro)
RARCH_LOG("[CHEEVOS]: deactivated unlocked achievements in hardcore mode.\n");
else
RARCH_ERR("[CHEEVOS]: error deactivating unlocked achievements in hardcore mode.\n");
free((void*)CHEEVOS_VAR_JSON);
if ((void*)CHEEVOS_VAR_JSON)
free((void*)CHEEVOS_VAR_JSON);
}
else
RARCH_ERR("[CHEEVOS]: error retrieving list of unlocked achievements in hardcore mode.\n");
@ -3107,7 +3396,8 @@ static int cheevos_iterate(coro_t* coro)
if (CHEEVOS_VAR_JSON)
{
RARCH_LOG("[CHEEVOS]: posted playing activity.\n");
free((void*)CHEEVOS_VAR_JSON);
if ((void*)CHEEVOS_VAR_JSON)
free((void*)CHEEVOS_VAR_JSON);
}
else
RARCH_ERR("[CHEEVOS]: error posting playing activity.\n");
@ -3122,11 +3412,16 @@ static void cheevos_task_handler(retro_task_t *task)
{
coro_t *coro = (coro_t*)task->state;
if (!coro)
return;
if (!cheevos_iterate(coro))
{
task_set_finished(task, true);
free(CHEEVOS_VAR_DATA);
free((void*)CHEEVOS_VAR_PATH);
if (CHEEVOS_VAR_DATA)
free(CHEEVOS_VAR_DATA);
if ((void*)CHEEVOS_VAR_PATH)
free((void*)CHEEVOS_VAR_PATH);
free((void*)coro);
}
}
@ -3134,8 +3429,8 @@ static void cheevos_task_handler(retro_task_t *task)
bool cheevos_load(const void *data)
{
retro_task_t *task;
coro_t *coro;
const struct retro_game_info *info;
const struct retro_game_info *info = NULL;
coro_t *coro = NULL;
cheevos_loaded = 0;
@ -3151,7 +3446,8 @@ bool cheevos_load(const void *data)
if (!task)
{
free((void*)coro);
if ((void*)coro)
free((void*)coro);
return false;
}
@ -3170,8 +3466,10 @@ bool cheevos_load(const void *data)
if (!CHEEVOS_VAR_DATA)
{
free((void*)task);
free((void*)coro);
if ((void*)task)
free((void*)task);
if ((void*)coro)
free((void*)coro);
return false;
}

53
cheevos/cheevos.h
View File

@ -60,10 +60,59 @@ typedef enum
CHEEVOS_CONSOLE_SEGA_CD = 9,
CHEEVOS_CONSOLE_SEGA_32X = 10,
CHEEVOS_CONSOLE_MASTER_SYSTEM = 11,
CHEEVOS_CONSOLE_XBOX_360 = 12,
CHEEVOS_CONSOLE_ATARI_LYNX = 13
CHEEVOS_CONSOLE_PLAYSTATION = 12,
CHEEVOS_CONSOLE_ATARI_LYNX = 13,
CHEEVOS_CONSOLE_NEOGEO = 14,
CHEEVOS_CONSOLE_XBOX_360 = 15,
CHEEVOS_CONSOLE_GAMECUBE = 16,
CHEEVOS_CONSOLE_ATARI_JAGUAR = 17,
CHEEVOS_CONSOLE_NINTENDO_DS = 18,
CHEEVOS_CONSOLE_WII = 19,
CHEEVOS_CONSOLE_WII_U = 20,
CHEEVOS_CONSOLE_PLAYSTATION_2 = 21,
CHEEVOS_CONSOLE_XBOX = 22,
CHEEVOS_CONSOLE_SKYNET = 23,
CHEEVOS_CONSOLE_XBOX_ONE = 24,
CHEEVOS_CONSOLE_ATARI_2600 = 25,
CHEEVOS_CONSOLE_MS_DOS = 26,
CHEEVOS_CONSOLE_ARCADE = 27,
CHEEVOS_CONSOLE_VIRTUAL_BOY = 28,
CHEEVOS_CONSOLE_MSX = 29,
CHEEVOS_CONSOLE_COMMODORE_64 = 30,
CHEEVOS_CONSOLE_ZX81 = 31
} cheevos_console_t;
enum
{
CHEEVOS_DIRTY_TITLE = 1 << 0,
CHEEVOS_DIRTY_DESC = 1 << 1,
CHEEVOS_DIRTY_POINTS = 1 << 2,
CHEEVOS_DIRTY_AUTHOR = 1 << 3,
CHEEVOS_DIRTY_ID = 1 << 4,
CHEEVOS_DIRTY_BADGE = 1 << 5,
CHEEVOS_DIRTY_CONDITIONS = 1 << 6,
CHEEVOS_DIRTY_VOTES = 1 << 7,
CHEEVOS_DIRTY_DESCRIPTION = 1 << 8,
CHEEVOS_DIRTY_ALL = (1 << 9) - 1
};
enum
{
CHEEVOS_ACTIVE_SOFTCORE = 1 << 0,
CHEEVOS_ACTIVE_HARDCORE = 1 << 1
};
enum
{
CHEEVOS_FORMAT_FRAMES = 0,
CHEEVOS_FORMAT_SECS,
CHEEVOS_FORMAT_MILLIS,
CHEEVOS_FORMAT_SCORE,
CHEEVOS_FORMAT_VALUE,
CHEEVOS_FORMAT_OTHER
};
bool cheevos_load(const void *data);
void cheevos_reset_game(void);

2
cheevos/var.c
View File

@ -226,7 +226,7 @@ void cheevos_var_patch_addr(cheevos_var_t* var, cheevos_console_t console)
unsigned addr = var->value;
var->bank_id = (int)(desc - system->mmaps.descriptors);
var->value = (unsigned)cheevos_var_reduce(
(var->value - desc->core.start) & desc->disconnect_mask,
(addr - desc->core.start) & desc->disconnect_mask,
desc->core.disconnect);
if (var->value >= desc->core.len)

2
command.c
View File

@ -2239,7 +2239,7 @@ TODO: Add a setting for these tweaks */
case CMD_EVENT_ADD_TO_FAVORITES:
playlist_push(
g_defaults.content_favorites,
path_get(RARCH_PATH_CONTENT),
(const char*)data,
NULL,
file_path_str(FILE_PATH_DETECT),
file_path_str(FILE_PATH_DETECT),

6
config.features.h
View File

@ -260,12 +260,6 @@ static const bool _sdl_image_supp = true;
static const bool _sdl_image_supp = false;
#endif
#ifdef HAVE_FBO
static const bool _fbo_supp = true;
#else
static const bool _fbo_supp = false;
#endif
#ifdef HAVE_DYNAMIC
static const bool _dynamic_supp = true;
#else

49
configuration.c
View File

@ -25,6 +25,7 @@
#include <compat/posix_string.h>
#include <retro_assert.h>
#include <string/stdstring.h>
#include <streams/file_stream.h>
#ifdef HAVE_CONFIG_H
#include "config.h"
@ -49,6 +50,12 @@
#include "tasks/tasks_internal.h"
static const char* invalid_filename_chars[] = {
/* https://support.microsoft.com/en-us/help/905231/information-about-the-characters-that-you-cannot-use-in-site-names--fo */
"~", "#", "%", "&", "*", "{", "}", "\\", ":", "[", "]", "?", "/", "|", "\'", "\"",
NULL
};
/* All config related settings go here. */
struct config_bool_setting
@ -1247,6 +1254,7 @@ static struct config_bool_setting *populate_settings_bool(settings_t *settings,
SETTING_BOOL("cheevos_enable", &settings->bools.cheevos_enable, true, cheevos_enable, false);
SETTING_BOOL("cheevos_test_unofficial", &settings->bools.cheevos_test_unofficial, true, false, false);
SETTING_BOOL("cheevos_hardcore_mode_enable", &settings->bools.cheevos_hardcore_mode_enable, true, false, false);
SETTING_BOOL("cheevos_leaderboards_enable", &settings->bools.cheevos_leaderboards_enable, true, false, false);
SETTING_BOOL("cheevos_verbose_enable", &settings->bools.cheevos_verbose_enable, true, false, false);
#endif
#ifdef HAVE_OVERLAY
@ -1890,6 +1898,8 @@ static config_file_t *open_default_config_file(void)
application_data[0] = conf_path[0] = app_path[0] = '\0';
(void)path_size;
#if defined(_WIN32) && !defined(_XBOX)
fill_pathname_application_path(app_path, path_size);
fill_pathname_resolve_relative(conf_path, app_path,
@ -2919,7 +2929,7 @@ bool config_load_override(void)
/* Restore the libretro_path we're using
* since it will be overwritten by the override when reloading. */
path_set(RARCH_PATH_CORE, buf);
runloop_msg_queue_push("Configuration override loaded.", 1, 100, true);
runloop_msg_queue_push(msg_hash_to_str(MSG_CONFIG_OVERRIDE_LOADED), 1, 100, true);
/* Reset save paths. */
retroarch_override_setting_set(RARCH_OVERRIDE_SETTING_STATE_PATH, NULL);
@ -3036,7 +3046,7 @@ bool config_load_remap(void)
RARCH_LOG("Remaps: game-specific remap found at %s.\n", game_path);
if (input_remapping_load_file(new_conf, game_path))
{
runloop_msg_queue_push("Game remap file loaded.", 1, 100, true);
runloop_msg_queue_push(msg_hash_to_str(MSG_GAME_REMAP_FILE_LOADED), 1, 100, true);
rarch_ctl(RARCH_CTL_SET_REMAPS_GAME_ACTIVE, NULL);
goto success;
}
@ -3056,7 +3066,7 @@ bool config_load_remap(void)
RARCH_LOG("Remaps: core-specific remap found at %s.\n", core_path);
if (input_remapping_load_file(new_conf, core_path))
{
runloop_msg_queue_push("Core remap file loaded.", 1, 100, true);
runloop_msg_queue_push(msg_hash_to_str(MSG_CORE_REMAP_FILE_LOADED), 1, 100, true);
rarch_ctl(RARCH_CTL_SET_REMAPS_CORE_ACTIVE, NULL);
goto success;
}
@ -3440,6 +3450,7 @@ bool config_save_autoconf_profile(const char *path, unsigned user)
unsigned i;
char *buf = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
char *autoconf_file = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
char *path_new = NULL;
size_t path_size = PATH_MAX_LENGTH * sizeof(char);
int32_t pid_user = 0;
int32_t vid_user = 0;
@ -3451,6 +3462,26 @@ bool config_save_autoconf_profile(const char *path, unsigned user)
buf[0] = autoconf_file[0] = '\0';
if (string_is_empty(path))
goto error;
path_new = strdup(path);
for (i = 0; invalid_filename_chars[i]; i++)
{
while (1)
{
char *tmp = strstr(path_new, invalid_filename_chars[i]);
if (tmp)
*tmp = '_';
else
break;
}
}
path = path_new;
fill_pathname_join(buf, autoconf_dir, joypad_ident, path_size);
if(path_is_directory(buf))
@ -3476,7 +3507,7 @@ bool config_save_autoconf_profile(const char *path, unsigned user)
path_size);
}
conf = config_file_new(autoconf_file);
conf = config_file_new(autoconf_file);
if (!conf)
{
@ -3512,11 +3543,15 @@ bool config_save_autoconf_profile(const char *path, unsigned user)
config_file_free(conf);
free(buf);
free(autoconf_file);
if (path_new)
free(path_new);
return ret;
error:
free(buf);
free(autoconf_file);
if (path_new)
free(path_new);
return false;
}
@ -3699,15 +3734,15 @@ bool config_save_file(const char *path)
#ifdef HAVE_LAKKA
if (settings->bools.ssh_enable)
fclose(fopen(LAKKA_SSH_PATH, "w"));
filestream_close(filestream_open(LAKKA_SSH_PATH, RFILE_MODE_WRITE, -1));
else
path_file_remove(LAKKA_SSH_PATH);
if (settings->bools.samba_enable)
fclose(fopen(LAKKA_SAMBA_PATH, "w"));
filestream_close(filestream_open(LAKKA_SAMBA_PATH, RFILE_MODE_WRITE, -1));
else
path_file_remove(LAKKA_SAMBA_PATH);
if (settings->bools.bluetooth_enable)
fclose(fopen(LAKKA_BLUETOOTH_PATH, "w"));
filestream_close(filestream_open(LAKKA_BLUETOOTH_PATH, RFILE_MODE_WRITE, -1));
else
path_file_remove(LAKKA_BLUETOOTH_PATH);
#endif

1
configuration.h
View File

@ -183,6 +183,7 @@ typedef struct settings
bool cheevos_enable;
bool cheevos_test_unofficial;
bool cheevos_hardcore_mode_enable;
bool cheevos_leaderboards_enable;
bool cheevos_verbose_enable;
/* Camera */

58
deps/libFLAC/include/share/win_utf8_io.h vendored Normal file
View File

@ -0,0 +1,58 @@
/* libFLAC - Free Lossless Audio Codec library
* Copyright (C) 2013-2016 Xiph.Org Foundation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* - Neither the name of the Xiph.org Foundation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifdef _WIN32
#ifndef flac__win_utf8_io_h
#define flac__win_utf8_io_h
#include <stdio.h>
#include <stdarg.h>
#ifdef __cplusplus
extern "C" {
#endif
size_t strlen_utf8(const char *str);
int win_get_console_width(void);
int get_utf8_argv(int *argc, char ***argv);
int printf_utf8(const char *format, ...);
int fprintf_utf8(FILE *stream, const char *format, ...);
int vfprintf_utf8(FILE *stream, const char *format, va_list argptr);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif
#endif

67
deps/libFLAC/include/share/windows_unicode_filenames.h vendored Normal file
View File

@ -0,0 +1,67 @@
/* libFLAC - Free Lossless Audio Codec library
* Copyright (C) 2013-2016 Xiph.Org Foundation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* - Neither the name of the Xiph.org Foundation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifdef _WIN32
#ifndef flac__windows_unicode_filenames_h
#define flac__windows_unicode_filenames_h
#include <stdio.h>
#include <sys/stat.h>
#include <sys/utime.h>
#include "FLAC/ordinals.h"
#ifdef __cplusplus
extern "C" {
#endif
void flac_internal_set_utf8_filenames(FLAC__bool flag);
FLAC__bool flac_internal_get_utf8_filenames(void);
#define flac_set_utf8_filenames flac_internal_set_utf8_filenames
#define flac_get_utf8_filenames flac_internal_get_utf8_filenames
FILE* flac_internal_fopen_utf8(const char *filename, const char *mode);
int flac_internal_stat64_utf8(const char *path, struct __stat64 *buffer);
int flac_internal_chmod_utf8(const char *filename, int pmode);
int flac_internal_utime_utf8(const char *filename, struct utimbuf *times);
int flac_internal_unlink_utf8(const char *filename);
int flac_internal_rename_utf8(const char *oldname, const char *newname);
#include <windows.h>
HANDLE WINAPI flac_internal_CreateFile_utf8(const char *lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile);
#define CreateFile_utf8 flac_internal_CreateFile_utf8
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif
#endif

201
deps/libFLAC/windows_unicode_filenames.c vendored Normal file
View File

@ -0,0 +1,201 @@
/* libFLAC - Free Lossless Audio Codec library
* Copyright (C) 2013-2016 Xiph.Org Foundation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* - Neither the name of the Xiph.org Foundation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include <io.h>
#include "include/share/windows_unicode_filenames.h"
/* convert UTF-8 back to WCHAR. Caller is responsible for freeing memory */
static wchar_t *wchar_from_utf8(const char *str)
{
wchar_t *widestr;
int len;
if (!str)
return NULL;
if ((len = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0)) == 0)
return NULL;
if ((widestr = (wchar_t *)malloc(len*sizeof(wchar_t))) == NULL)
return NULL;
if (MultiByteToWideChar(CP_UTF8, 0, str, -1, widestr, len) == 0) {
free(widestr);
widestr = NULL;
}
return widestr;
}
static FLAC__bool utf8_filenames = false;
void flac_internal_set_utf8_filenames(FLAC__bool flag)
{
utf8_filenames = flag ? true : false;
}
FLAC__bool flac_internal_get_utf8_filenames(void)
{
return utf8_filenames;
}
/* file functions */
FILE* flac_internal_fopen_utf8(const char *filename, const char *mode)
{
if (!utf8_filenames) {
return fopen(filename, mode);
} else {
wchar_t *wname = NULL;
wchar_t *wmode = NULL;
FILE *f = NULL;
do {
if (!(wname = wchar_from_utf8(filename))) break;
if (!(wmode = wchar_from_utf8(mode))) break;
f = _wfopen(wname, wmode);
} while(0);
free(wname);
free(wmode);
return f;
}
}
int flac_internal_stat64_utf8(const char *path, struct __stat64 *buffer)
{
if (!utf8_filenames) {
return _stat64(path, buffer);
} else {
wchar_t *wpath;
int ret;
if (!(wpath = wchar_from_utf8(path))) return -1;
ret = _wstat64(wpath, buffer);
free(wpath);
return ret;
}
}
int flac_internal_chmod_utf8(const char *filename, int pmode)
{
if (!utf8_filenames) {
return _chmod(filename, pmode);
} else {
wchar_t *wname;
int ret;
if (!(wname = wchar_from_utf8(filename))) return -1;
ret = _wchmod(wname, pmode);
free(wname);
return ret;
}
}
int flac_internal_utime_utf8(const char *filename, struct utimbuf *times)
{
if (!utf8_filenames) {
return utime(filename, times);
} else {
wchar_t *wname;
struct __utimbuf64 ut;
int ret;
if (!(wname = wchar_from_utf8(filename))) return -1;
ut.actime = times->actime;
ut.modtime = times->modtime;
ret = _wutime64(wname, &ut);
free(wname);
return ret;
}
}
int flac_internal_unlink_utf8(const char *filename)
{
if (!utf8_filenames) {
return _unlink(filename);
} else {
wchar_t *wname;
int ret;
if (!(wname = wchar_from_utf8(filename))) return -1;
ret = _wunlink(wname);
free(wname);
return ret;
}
}
int flac_internal_rename_utf8(const char *oldname, const char *newname)
{
if (!utf8_filenames) {
return rename(oldname, newname);
} else {
wchar_t *wold = NULL;
wchar_t *wnew = NULL;
int ret = -1;
do {
if (!(wold = wchar_from_utf8(oldname))) break;
if (!(wnew = wchar_from_utf8(newname))) break;
ret = _wrename(wold, wnew);
} while(0);
free(wold);
free(wnew);
return ret;
}
}
HANDLE WINAPI flac_internal_CreateFile_utf8(const char *lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
{
if (!utf8_filenames) {
return CreateFileA(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
} else {
wchar_t *wname;
HANDLE handle = INVALID_HANDLE_VALUE;
if ((wname = wchar_from_utf8(lpFileName)) != NULL) {
handle = CreateFileW(wname, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
free(wname);
}
return handle;
}
}

65
dist-scripts/dist-cores.sh
View File

@ -134,32 +134,7 @@ if [ $SALAMANDER = "yes" ]; then
vita-mksfoex -s TITLE_ID=RETROVITA "RetroArch" ../pkg/${platform}/retroarch.vpk/vpk/sce_sys/param.sfo
cp ../pkg/${platform}/assets/ICON0.PNG ../pkg/${platform}/retroarch.vpk/vpk/sce_sys/icon0.png
cp -R ../pkg/${platform}/assets/livearea ../pkg/${platform}/retroarch.vpk/vpk/sce_sys/
mkdir -p ../pkg/${platform}/retroarch.vpk/vpk/assets
if [ -d ../media/assets/glui ]; then
cp -r ../media/assets/glui ../pkg/${platform}/retroarch.vpk/vpk/assets
fi
if [ -d ../media/assets/xmb ]; then
cp -r ../media/assets/xmb ../pkg/${platform}/retroarch.vpk/vpk/assets
# Strip source SVG files
rm -rf ../pkg/${platform}/retroarch.vpk/vpk/assets/xmb/flatui/src
rm -rf ../pkg/${platform}/retroarch.vpk/vpk/assets/xmb/monochrome/src
rm -rf ../pkg/${platform}/retroarch.vpk/vpk/assets/xmb/retroactive/src
rm -rf ../pkg/${platform}/retroarch.vpk/vpk/assets/xmb/retroactive_marked/src
rm -rf ../pkg/${platform}/retroarch.vpk/vpk/assets/xmb/dot-art/src
fi
if [ -d ../media/libretrodb/rdb ]; then
mkdir -p ../pkg/${platform}/retroarch.vpk/vpk/database/rdb
cp -r ../media/libretrodb/rdb/* ../pkg/${platform}/retroarch.vpk/vpk/database/rdb
fi
if [ -d ../media/libretrodb/cursors ]; then
mkdir -p ../pkg/${platform}/retroarch.vpk/vpk/database/cursors
cp -r ../media/libretrodb/cursors/* ../pkg/${platform}/retroarch.vpk/vpk/database/cursors
fi
if [ -d ../../dist/info ]; then
mkdir -p ../pkg/${platform}/retroarch.vpk/vpk/info
cp -fv ../../dist/info/*.info ../pkg/${platform}/retroarch.vpk/vpk/info/
fi
make -C ../ -f Makefile.${platform}.salamander clean || exit 1
make -C ../ -f Makefile.${platform}.salamander clean || exit 1
fi
if [ $PLATFORM = "ctr" ] ; then
mv -f ../retroarch_3ds_salamander.cia ../pkg/3ds/cia/retroarch_3ds.cia
@ -259,44 +234,10 @@ for f in `ls -v *_${platform}.${EXT}`; do
elif [ $PLATFORM = "vita" ] ; then
COUNTER=$((COUNTER + 1))
COUNTER_ID=`printf "%05d" ${COUNTER}`
mkdir -p ../pkg/${platform}/${name}_libretro.vpk/vpk/sce_sys/
mkdir -p ../pkg/${platform}/${name}_libretro.vpk/vpk/sce_sys/livearea
mkdir -p ../pkg/${platform}/${name}_libretro.vpk/vpk/sce_sys/livearea/contents
mkdir -p ../pkg/${platform}/${name}_libretro.vpk/vpk/assets/
mkdir -p ../pkg/${platform}/${name}_libretro.vpk/vpk/database/rdb
mkdir -p ../pkg/${platform}/${name}_libretro.vpk/vpk/database/cursors
mkdir -p ../pkg/${platform}/${name}_libretro.vpk/vpk/info
cp ../retroarch_${platform}.self ../pkg/${platform}/${name}_libretro.vpk/vpk/eboot.bin
cp ../pkg/${platform}/${name}_libretro.vpk/vpk/eboot.bin ../pkg/${platform}/retroarch.vpk/vpk/${name}_libretro.self
vita-mksfoex -s TITLE_ID=RETR${COUNTER_ID} "RetroArch ${name}" ../pkg/${platform}/${name}_libretro.vpk/vpk/sce_sys/param.sfo
cp ../pkg/${platform}/assets/ICON0.PNG ../pkg/${platform}/${name}_libretro.vpk/vpk/sce_sys/icon0.png
cp ../pkg/${platform}/assets/livearea/contents/bg.png ../pkg/${platform}/${name}_libretro.vpk/vpk/sce_sys/livearea/contents/bg.png
cp ../pkg/${platform}/assets/livearea/contents/startup.png ../pkg/${platform}/${name}_libretro.vpk/vpk/sce_sys/livearea/contents/startup.png
cp ../pkg/${platform}/assets/livearea/contents/website.png ../pkg/${platform}/${name}_libretro.vpk/vpk/sce_sys/livearea/contents/website.png
cp ../pkg/${platform}/assets/livearea/contents/template.xml ../pkg/${platform}/${name}_libretro.vpk/vpk/sce_sys/livearea/contents/template.xml
mkdir -p ../pkg/${platform}/${name}_libretro.vpk/vpk/assets
if [ -d ../media/assets/glui ]; then
cp -r ../media/assets/glui ../pkg/${platform}/${name}_libretro.vpk/vpk/assets
fi
if [ -d ../media/assets/xmb ]; then
cp -r ../media/assets/xmb ../pkg/${platform}/${name}_libretro.vpk/vpk/assets
# Strip source SVG files
rm -rf ../pkg/${platform}/${name}_libretro.vpk/vpk/assets/xmb/flatui/src
rm -rf ../pkg/${platform}/${name}_libretro.vpk/vpk/assets/xmb/monochrome/src
rm -rf ../pkg/${platform}/${name}_libretro.vpk/vpk/assets/xmb/retroactive/src
rm -rf ../pkg/${platform}/${name}_libretro.vpk/vpk/assets/xmb/retroactive_marked/src
fi
if [ -d ../media/libretrodb/rdb ]; then
mkdir -p ../pkg/${platform}/retroarch.vpk/vpk/database/rdb
cp -r ../media/libretrodb/rdb/* ../pkg/${platform}/${name}_libretro.vpk/vpk/database/rdb
fi
if [ -d ../media/libretrodb/cursors ]; then
mkdir -p ../pkg/${platform}/retroarch.vpk/vpk/database/cursors
cp -r ../media/libretrodb/cursors/* ../pkg/${platform}/${name}_libretro.vpk/vpk/database/cursors
fi
cp ../retroarch_${platform}.self ../pkg/${platform}/retroarch.vpk/vpk/${name}_libretro.self
if [ -d ../../dist/info ]; then
mkdir -p ../pkg/${platform}/retroarch.vpk/vpk/info
cp -fv ../../dist/info/"${name}_libretro.info" ../pkg/${platform}/${name}_libretro.vpk/vpk/info/"${name}_libretro.info"
cp -fv ../../dist/info/"${name}_libretro.info" ../pkg/${platform}/retroarch.vpk/vpk/info/"${name}_libretro.info"
fi
elif [ $PLATFORM = "ctr" ] ; then
mv -f ../retroarch_3ds.cia ../pkg/3ds/cia/${name}_libretro.cia

14
frontend/drivers/platform_psp.c
View File

@ -115,15 +115,15 @@ static void frontend_psp_get_environment_settings(int *argc, char *argv[],
/* bundle data*/
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CORE], g_defaults.dirs[DEFAULT_DIR_PORT],
"", sizeof(g_defaults.dirs[DEFAULT_DIR_CORE]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_ASSETS], g_defaults.dirs[DEFAULT_DIR_PORT],
"assets", sizeof(g_defaults.dirs[DEFAULT_DIR_ASSETS]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CORE_INFO], g_defaults.dirs[DEFAULT_DIR_CORE],
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CORE_INFO], g_defaults.dirs[DEFAULT_DIR_PORT],
"info", sizeof(g_defaults.dirs[DEFAULT_DIR_CORE_INFO]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_DATABASE], g_defaults.dirs[DEFAULT_DIR_PORT],
"database/rdb", sizeof(g_defaults.dirs[DEFAULT_DIR_DATABASE]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CURSOR], g_defaults.dirs[DEFAULT_DIR_PORT],
"database/cursors", sizeof(g_defaults.dirs[DEFAULT_DIR_CURSOR]));
/* user data*/
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_ASSETS], user_path,
"assets", sizeof(g_defaults.dirs[DEFAULT_DIR_ASSETS]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_DATABASE], user_path,
"database/rdb", sizeof(g_defaults.dirs[DEFAULT_DIR_DATABASE]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CURSOR], user_path,
"database/cursors", sizeof(g_defaults.dirs[DEFAULT_DIR_CURSOR]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_CHEATS], user_path,
"cheats", sizeof(g_defaults.dirs[DEFAULT_DIR_CHEATS]));
fill_pathname_join(g_defaults.dirs[DEFAULT_DIR_MENU_CONFIG], user_path,

2
frontend/drivers/platform_unix.c
View File

@ -616,7 +616,7 @@ static bool make_proc_acpi_key_val(char **_ptr, char **_key, char **_val)
*(ptr++) = '\0'; /* terminate the key. */
while ((*ptr == ' ') && (*ptr != '\0'))
while (*ptr == ' ')
ptr++; /* skip whitespace. */
if (*ptr == '\0')

5
frontend/drivers/platform_wiiu.c
View File

@ -308,6 +308,7 @@ frontend_ctx_driver_t frontend_ctx_wiiu =
NULL, /* attach_console */
NULL, /* detach_console */
"wiiu",
NULL, /* get_video_driver */
};
static int wiiu_log_socket = -1;
@ -379,6 +380,7 @@ void net_print_exp(const char *str)
send(wiiu_log_socket, str, strlen(str), 0);
}
#if defined(PC_DEVELOPMENT_IP_ADDRESS) && defined(PC_DEVELOPMENT_TCP_PORT)
static devoptab_t dotab_stdout =
{
"stdout_net", // device name
@ -389,6 +391,7 @@ static devoptab_t dotab_stdout =
NULL,
/* ... */
};
#endif
void SaveCallback()
{
@ -642,7 +645,7 @@ void _start(int argc, char **argv)
__init();
fsdev_init();
int ret = main(argc, argv);
main(argc, argv);
fsdev_exit();
// __fini();

104
gfx/common/gl_common.h
View File

@ -38,6 +38,10 @@ RETRO_BEGIN_DECLS
#define MAX_FENCES 4
#ifndef ARB_sync
typedef struct __GLsync *GLsync;
#endif
typedef struct gl
{
GLenum internal_fmt;
@ -47,44 +51,34 @@ typedef struct gl
bool vsync;
bool tex_mipmap;
#ifdef HAVE_FBO
bool fbo_inited;
bool fbo_feedback_enable;
bool hw_render_fbo_init;
bool hw_render_depth_init;
bool has_fbo;
bool has_srgb_fbo_gles3;
#endif
bool has_fp_fbo;
bool has_srgb_fbo;
bool hw_render_use;
bool core_context_in_use;
bool should_resize;
bool quitting;
bool fullscreen;
bool keep_aspect;
#ifdef HAVE_OPENGLES
bool support_unpack_row_length;
#else
bool have_es2_compat;
#endif
bool have_full_npot_support;
bool have_mipmap;
bool egl_images;
#ifdef HAVE_OVERLAY
bool overlay_enable;
bool overlay_full_screen;
#endif
#ifdef HAVE_MENU
bool menu_texture_enable;
bool menu_texture_full_screen;
#endif
#ifdef HAVE_GL_SYNC
bool have_sync;
#endif
#ifdef HAVE_GL_ASYNC_READBACK
bool pbo_readback_valid[4];
bool pbo_readback_enable;
#endif
int version_major;
int version_minor;
@ -92,131 +86,77 @@ typedef struct gl
GLuint tex_mag_filter;
GLuint tex_min_filter;
#ifdef HAVE_FBO
GLuint fbo_feedback;
GLuint fbo_feedback_texture;
#endif
GLuint pbo;
#ifdef HAVE_OVERLAY
GLuint *overlay_tex;
#endif
#if defined(HAVE_MENU)
GLuint menu_texture;
#endif
GLuint vao;
#ifdef HAVE_GL_ASYNC_READBACK
GLuint pbo_readback[4];
#endif
GLuint texture[GFX_MAX_TEXTURES];
#ifdef HAVE_FBO
GLuint fbo[GFX_MAX_SHADERS];
GLuint fbo_texture[GFX_MAX_SHADERS];
GLuint hw_render_fbo[GFX_MAX_TEXTURES];
GLuint hw_render_depth[GFX_MAX_TEXTURES];
#endif
unsigned tex_index; /* For use with PREV. */
unsigned textures;
#ifdef HAVE_FBO
unsigned fbo_feedback_pass;
#endif
unsigned rotation;
unsigned vp_out_width;
unsigned vp_out_height;
unsigned tex_w;
unsigned tex_h;
unsigned base_size; /* 2 or 4 */
#ifdef HAVE_OVERLAY
unsigned overlays;
#endif
#ifdef HAVE_GL_ASYNC_READBACK
unsigned pbo_readback_index;
#endif
#ifdef HAVE_GL_SYNC
unsigned fence_count;
#endif
unsigned last_width[GFX_MAX_TEXTURES];
unsigned last_height[GFX_MAX_TEXTURES];
#if defined(HAVE_MENU)
float menu_texture_alpha;
#endif
void *empty_buf;
void *conv_buffer;
void *readback_buffer_screenshot;
const float *vertex_ptr;
const float *white_color_ptr;
#ifdef HAVE_OVERLAY
float *overlay_vertex_coord;
float *overlay_tex_coord;
float *overlay_color_coord;
#endif
struct video_tex_info tex_info;
#ifdef HAVE_GL_ASYNC_READBACK
struct scaler_ctx pbo_readback_scaler;
#endif
struct video_viewport vp;
math_matrix_4x4 mvp, mvp_no_rot;
struct video_coords coords;
struct scaler_ctx scaler;
video_info_t video_info;
struct video_tex_info prev_info[GFX_MAX_TEXTURES];
#ifdef HAVE_FBO
struct video_fbo_rect fbo_rect[GFX_MAX_SHADERS];
struct gfx_fbo_scale fbo_scale[GFX_MAX_SHADERS];
#endif
#ifdef HAVE_GL_SYNC
GLsync fences[MAX_FENCES];
#endif
const gl_renderchain_driver_t *renderchain_driver;
void *renderchain_data;
} gl_t;
bool gl_load_luts(const struct video_shader *generic_shader,
GLuint *lut_textures);
#ifdef NO_GL_FF_VERTEX
#define gl_ff_vertex(coords) ((void)0)
#else
static INLINE void gl_ff_vertex(const struct video_coords *coords)
static INLINE void gl_bind_texture(GLuint id, GLint wrap_mode, GLint mag_filter,
GLint min_filter)
{
/* Fall back to fixed function-style if needed and possible. */
glClientActiveTexture(GL_TEXTURE1);
glTexCoordPointer(2, GL_FLOAT, 0, coords->lut_tex_coord);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(GL_TEXTURE0);
glVertexPointer(2, GL_FLOAT, 0, coords->vertex);
glEnableClientState(GL_VERTEX_ARRAY);
glColorPointer(4, GL_FLOAT, 0, coords->color);
glEnableClientState(GL_COLOR_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, coords->tex_coord);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glBindTexture(GL_TEXTURE_2D, id);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap_mode);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap_mode);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter);
}
#endif
#ifdef NO_GL_FF_MATRIX
#define gl_ff_matrix(mat) ((void)0)
#else
static INLINE void gl_ff_matrix(const math_matrix_4x4 *mat)
{
math_matrix_4x4 ident;
/* Fall back to fixed function-style if needed and possible. */
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(mat->data);
glMatrixMode(GL_MODELVIEW);
matrix_4x4_identity(ident);
glLoadMatrixf(ident.data);
}
#endif
static INLINE unsigned gl_wrap_type_to_enum(enum gfx_wrap_type type)
{
switch (type)
{
#ifndef HAVE_OPENGLES
case RARCH_WRAP_BORDER:
case RARCH_WRAP_BORDER: /* GL_CLAMP_TO_BORDER: Available since GL 1.3 */
return GL_CLAMP_TO_BORDER;
#else
case RARCH_WRAP_BORDER:
@ -232,8 +172,8 @@ static INLINE unsigned gl_wrap_type_to_enum(enum gfx_wrap_type type)
return 0;
}
bool gl_query_core_context_in_use(void);
void gl_load_texture_image(GLenum target,
GLint level,
GLint internalFormat,
@ -244,6 +184,14 @@ void gl_load_texture_image(GLenum target,
GLenum type,
const GLvoid * data);
void gl_load_texture_data(
uint32_t id_data,
enum gfx_wrap_type wrap_type,
enum texture_filter_type filter_type,
unsigned alignment,
unsigned width, unsigned height,
const void *frame, unsigned base_size);
RETRO_END_DECLS
#endif

6
gfx/drivers/caca_gfx.c
View File

@ -305,6 +305,8 @@ static void caca_set_osd_msg(void *data,
}
static const video_poke_interface_t caca_poke_interface = {
NULL, /* set_coords */
NULL, /* set_mvp */
NULL,
NULL,
NULL,
@ -312,11 +314,7 @@ static const video_poke_interface_t caca_poke_interface = {
NULL,
NULL,
NULL,
#ifdef HAVE_FBO
NULL,
#else
NULL,
#endif
NULL,
NULL,
NULL,

10
gfx/drivers/ctr_gfx.c
View File

@ -1120,14 +1120,16 @@ static void ctr_set_osd_msg(void *data,
}
static const video_poke_interface_t ctr_poke_interface = {
NULL, /* set_coords */
NULL, /* set_mvp */
ctr_load_texture,
ctr_unload_texture,
NULL,
ctr_set_filtering,
NULL, /* get_video_output_size */
NULL, /* get_video_output_prev */
NULL, /* get_video_output_next */
NULL, /* get_current_framebuffer */
NULL, /* get_video_output_size */
NULL, /* get_video_output_prev */
NULL, /* get_video_output_next */
NULL, /* get_current_framebuffer */
NULL,
ctr_set_aspect_ratio,
ctr_apply_state_changes,

107
gfx/drivers/d3d.c
View File

@ -66,40 +66,23 @@
#endif
#endif
#ifdef _XBOX
#ifndef HAVE_FBO
#define HAVE_FBO
#endif
#endif
static LPDIRECT3D g_pD3D;
static bool d3d_init_luts(d3d_video_t *d3d)
{
unsigned i;
settings_t *settings = config_get_ptr();
if (!d3d->renderchain_driver || !d3d->renderchain_driver->add_lut)
return true;
for (i = 0; i < d3d->shader.luts; i++)
{
if (!d3d->renderchain_driver->add_lut(
d3d->renderchain_data,
d3d->shader.lut[i].id, d3d->shader.lut[i].path,
d3d->shader.lut[i].filter == RARCH_FILTER_UNSPEC ?
settings->bools.video_smooth :
(d3d->shader.lut[i].filter == RARCH_FILTER_LINEAR)))
return false;
}
return true;
}
static bool d3d_init_imports(d3d_video_t *d3d)
{
retro_ctx_memory_info_t mem_info;
state_tracker_t *state_tracker = NULL;
state_tracker_t *state_tracker = NULL;
struct state_tracker_info tracker_info = {0};
if (!d3d->shader.variables)
return true;
if (!d3d->renderchain_driver || !d3d->renderchain_driver->add_state_tracker)
return true;
mem_info.id = RETRO_MEMORY_SYSTEM_RAM;
@ -205,15 +188,36 @@ static bool d3d_init_chain(d3d_video_t *d3d, const video_info_t *video_info)
}
#endif
if (!d3d_init_luts(d3d))
if (d3d->renderchain_driver)
{
RARCH_ERR("[D3D]: Failed to init LUTs.\n");
return false;
}
if (!d3d_init_imports(d3d))
{
RARCH_ERR("[D3D]: Failed to init imports.\n");
return false;
if (d3d->renderchain_driver->add_lut)
{
unsigned i;
settings_t *settings = config_get_ptr();
for (i = 0; i < d3d->shader.luts; i++)
{
if (!d3d->renderchain_driver->add_lut(
d3d->renderchain_data,
d3d->shader.lut[i].id, d3d->shader.lut[i].path,
d3d->shader.lut[i].filter == RARCH_FILTER_UNSPEC ?
settings->bools.video_smooth :
(d3d->shader.lut[i].filter == RARCH_FILTER_LINEAR)))
{
RARCH_ERR("[D3D]: Failed to init LUTs.\n");
return false;
}
}
}
if (d3d->renderchain_driver->add_state_tracker)
{
if (!d3d_init_imports(d3d))
{
RARCH_ERR("[D3D]: Failed to init imports.\n");
return false;
}
}
}
return true;
@ -961,9 +965,7 @@ static void d3d_set_osd_msg(void *data,
font_driver_render_msg(video_info, NULL, msg, params);
}
/* Delay constructor due to lack of exceptions. */
static bool d3d_construct(d3d_video_t *d3d,
static bool d3d_init_internal(d3d_video_t *d3d,
const video_info_t *info, const input_driver_t **input,
void **input_data)
{
@ -1062,11 +1064,20 @@ static bool d3d_construct(d3d_video_t *d3d,
* later. */
type =
video_shader_parse_type(settings->paths.path_shader, RARCH_SHADER_NONE);
if (settings->bools.video_shader_enable && type == RARCH_SHADER_CG)
if (settings->bools.video_shader_enable)
{
if (!string_is_empty(d3d->shader_path))
free(d3d->shader_path);
d3d->shader_path = strdup(settings->paths.path_shader);
switch (type)
{
case RARCH_SHADER_CG:
if (!string_is_empty(d3d->shader_path))
free(d3d->shader_path);
if (!string_is_empty(settings->paths.path_shader))
d3d->shader_path = strdup(settings->paths.path_shader);
break;
default:
break;
}
}
if (!d3d_process_shader(d3d))
@ -1171,7 +1182,7 @@ static void *d3d_init(const video_info_t *info,
video_context_driver_set((const gfx_ctx_driver_t*)ctx_driver);
if (!d3d_construct(d3d, info, input, input_data))
if (!d3d_init_internal(d3d, info, input, input_data))
{
RARCH_ERR("[D3D]: Failed to init D3D.\n");
goto error;
@ -1708,7 +1719,21 @@ static void d3d_unload_texture(void *data, uintptr_t id)
d3d_texture_free(texid);
}
static void d3d_set_mvp(void *data,
void *shader_data,
const void *mat_data)
{
d3d_video_t *d3d = (d3d_video_t*)data;
if (d3d && d3d->renderchain_driver->set_mvp)
d3d->renderchain_driver->set_mvp(
d3d->renderchain_data,
data,
640, 480, 0);
}
static const video_poke_interface_t d3d_poke_interface = {
NULL, /* set_coords */
d3d_set_mvp,
d3d_load_texture,
d3d_unload_texture,
NULL,

2
gfx/drivers/dispmanx_gfx.c
View File

@ -631,6 +631,8 @@ static void dispmanx_set_aspect_ratio (void *data, unsigned aspect_ratio_idx)
}
static const video_poke_interface_t dispmanx_poke_interface = {
NULL, /* set_coords */
NULL, /* set_mvp */
NULL,
NULL,
NULL, /* set_video_mode */

2
gfx/drivers/drm_gfx.c
View File

@ -959,6 +959,8 @@ static void drm_set_aspect_ratio (void *data, unsigned aspect_ratio_idx)
}
static const video_poke_interface_t drm_poke_interface = {
NULL, /* set_coords */
NULL, /* set_mvp */
NULL,
NULL,
NULL, /* set_video_mode */

2
gfx/drivers/exynos_gfx.c
View File

@ -1478,6 +1478,8 @@ static void exynos_show_mouse(void *data, bool state)
}
static const video_poke_interface_t exynos_poke_interface = {
NULL, /* set_coords */
NULL, /* set_mvp */
NULL,
NULL,
NULL, /* set_video_mode */

6
gfx/drivers/gdi_gfx.c
View File

@ -531,6 +531,8 @@ static void gdi_set_video_mode(void *data, unsigned width, unsigned height,
}
static const video_poke_interface_t gdi_poke_interface = {
NULL, /* set_coords */
NULL, /* set_mvp */
NULL,
NULL,
gdi_set_video_mode,
@ -538,11 +540,7 @@ static const video_poke_interface_t gdi_poke_interface = {
gdi_get_video_output_size,
gdi_get_video_output_prev,
gdi_get_video_output_next,
#ifdef HAVE_FBO
NULL,
#else
NULL,
#endif
NULL,
NULL,
NULL,

1047
gfx/drivers/gl.c
View File

File diff suppressed because it is too large Load Diff

29
gfx/drivers/gl_symlinks.h
View File

@ -27,7 +27,7 @@
#include "config.h"
#endif
#if defined(HAVE_FBO) && defined(HAVE_PSGL)
#if defined(HAVE_PSGL)
#define glGenFramebuffers glGenFramebuffersOES
#define glBindFramebuffer glBindFramebufferOES
#define glFramebufferTexture2D glFramebufferTexture2DOES
@ -40,12 +40,6 @@
#define glDeleteRenderbuffers glDeleteRenderbuffersOES
#endif
#if (!defined(HAVE_OPENGLES) || defined(HAVE_OPENGLES3))
#ifdef GL_PIXEL_PACK_BUFFER
#define HAVE_GL_ASYNC_READBACK
#endif
#endif
#if defined(HAVE_PSGL)
#define RARCH_GL_FRAMEBUFFER GL_FRAMEBUFFER_OES
#define RARCH_GL_FRAMEBUFFER_COMPLETE GL_FRAMEBUFFER_COMPLETE_OES
@ -98,14 +92,10 @@
#define glGenerateMipmap glGenerateMipmapOES
#endif
#ifdef HAVE_FBO
#if defined(__APPLE__) || defined(HAVE_PSGL)
#define GL_RGBA32F GL_RGBA32F_ARB
#endif
#endif
#if defined(HAVE_PSGL)
#define RARCH_GL_INTERNAL_FORMAT32 GL_ARGB_SCE
#define RARCH_GL_INTERNAL_FORMAT16 GL_RGB5 /* TODO: Verify if this is really 565 or just 555. */
@ -152,23 +142,6 @@
#define RARCH_GL_FORMAT16_565 GL_UNSIGNED_SHORT_5_6_5
#endif
/* Platform specific workarounds/hacks. */
#if defined(__CELLOS_LV2__)
#define NO_GL_READ_PIXELS
#endif
#if defined(HAVE_OPENGL_MODERN) || defined(HAVE_OPENGLES2) || defined(HAVE_OPENGLES3) || defined(HAVE_OPENGLES_3_1) || defined(HAVE_OPENGLES_3_2) || defined(HAVE_PSGL)
#ifndef NO_GL_FF_VERTEX
#define NO_GL_FF_VERTEX
#endif
#ifndef NO_GL_FF_MATRIX
#define NO_GL_FF_MATRIX
#endif
#endif
#if defined(HAVE_OPENGLES2) /* TODO: Figure out exactly what. */
#define NO_GL_CLAMP_TO_BORDER
#endif

2
gfx/drivers/gx_gfx.c
View File

@ -1262,6 +1262,8 @@ static void gx_get_video_output_next(void *data)
}
static const video_poke_interface_t gx_poke_interface = {
NULL, /* set_coords */
NULL, /* set_mvp */
NULL,
NULL,
gx_set_video_mode,

2
gfx/drivers/omap_gfx.c
View File

@ -1130,6 +1130,8 @@ static void omap_gfx_set_texture_enable(void *data, bool state, bool full_screen
}
static const video_poke_interface_t omap_gfx_poke_interface = {
NULL, /* set_coords */
NULL, /* set_mvp */
NULL,
NULL,
NULL,

2
gfx/drivers/psp1_gfx.c
View File

@ -831,6 +831,8 @@ static void psp_viewport_info(void *data, struct video_viewport *vp)
}
static const video_poke_interface_t psp_poke_interface = {
NULL, /* set_coords */
NULL, /* set_mvp */
NULL,
NULL,
NULL,

2
gfx/drivers/sdl2_gfx.c
View File

@ -718,6 +718,8 @@ static void sdl2_grab_mouse_toggle(void *data)
#endif
static video_poke_interface_t sdl2_video_poke_interface = {
NULL, /* set_coords */
NULL, /* set_mvp */
NULL,
NULL,
NULL,

2
gfx/drivers/sdl_gfx.c
View File

@ -517,6 +517,8 @@ static void sdl_grab_mouse_toggle(void *data)
}
static const video_poke_interface_t sdl_poke_interface = {
NULL, /* set_coords */
NULL, /* set_mvp */
NULL,
NULL,
NULL,

2
gfx/drivers/sunxi_gfx.c
View File

@ -932,6 +932,8 @@ static void sunxi_set_aspect_ratio (void *data, unsigned aspect_ratio_idx)
}
static const video_poke_interface_t sunxi_poke_interface = {
NULL, /* set_coords */
NULL, /* set_mvp */
NULL,
NULL,
NULL, /* set_video_mode */

6
gfx/drivers/vga_gfx.c
View File

@ -392,6 +392,8 @@ static void vga_set_osd_msg(void *data,
}
static const video_poke_interface_t vga_poke_interface = {
NULL, /* set_coords */
NULL, /* set_mvp */
NULL,
NULL,
NULL,
@ -399,11 +401,7 @@ static const video_poke_interface_t vga_poke_interface = {
NULL,
NULL,
NULL,
#ifdef HAVE_FBO
NULL,
#else
NULL,
#endif
NULL,
NULL,
NULL,

2
gfx/drivers/vita2d_gfx.c
View File

@ -779,6 +779,8 @@ static bool vita_get_current_sw_framebuffer(void *data,
}
static const video_poke_interface_t vita_poke_interface = {
NULL, /* set_coords */
NULL, /* set_mvp */
vita_load_texture,
vita_unload_texture,
NULL,

2
gfx/drivers/vulkan.c
View File

@ -2242,6 +2242,8 @@ static void vulkan_unload_texture(void *data, uintptr_t handle)
}
static const video_poke_interface_t vulkan_poke_interface = {
NULL, /* set_coords */
NULL, /* set_mvp */
vulkan_load_texture,
vulkan_unload_texture,
vulkan_set_video_mode,

30
gfx/drivers/wiiu_gfx.c
View File

@ -51,7 +51,7 @@ static const wiiu_render_mode_t wiiu_render_mode_map[] =
{1920, 1080, GX2_TV_RENDER_MODE_WIDE_1080P} /* GX2_TV_SCAN_MODE_1080P */
};
static int wiiu_set_position(position_t* position, GX2ColorBuffer* draw_buffer, float x0, float y0, float x1, float y1)
static void wiiu_set_position(position_t* position, GX2ColorBuffer* draw_buffer, float x0, float y0, float x1, float y1)
{
position[0].x = (2.0f * x0 / draw_buffer->surface.width) - 1.0f;
position[0].y = (2.0f * y0 / draw_buffer->surface.height) - 1.0f;
@ -194,7 +194,6 @@ static void wiiu_gfx_set_aspect_ratio(void* data, unsigned aspect_ratio_idx)
static void* wiiu_gfx_init(const video_info_t* video,
const input_driver_t** input, void** input_data)
{
int i;
float refresh_rate = 60.0f / 1.001f;
u32 size = 0;
u32 tmp = 0;
@ -387,9 +386,9 @@ static void* wiiu_gfx_init(const video_info_t* video,
wiiu->vertex_cache.size = 0x1000;
wiiu->vertex_cache.current = 0;
wiiu->vertex_cache.positions = MEM2_alloc(wiiu->vertex_cache.size
wiiu->vertex_cache.positions = MEM2_alloc(wiiu->vertex_cache.size
* sizeof(position_t), GX2_VERTEX_BUFFER_ALIGNMENT);
wiiu->vertex_cache.tex_coords = MEM2_alloc(wiiu->vertex_cache.size
wiiu->vertex_cache.tex_coords = MEM2_alloc(wiiu->vertex_cache.size
* sizeof(tex_coord_t), GX2_VERTEX_BUFFER_ALIGNMENT);
/* Initialize samplers */
@ -498,7 +497,7 @@ static bool wiiu_gfx_frame(void* data, const void* frame,
static u32 lastTick , currentTick;
u32 diff;
#endif
int i;
uint32_t i;
wiiu_video_t* wiiu = (wiiu_video_t*) data;
(void)msg;
@ -572,7 +571,7 @@ static bool wiiu_gfx_frame(void* data, const void* frame,
for (i = 0; i < height; i++)
{
int j;
uint32_t j;
for(j = 0; j < width; j++)
dst[j] = src[j];
dst += wiiu->texture.surface.pitch;
@ -725,7 +724,7 @@ static bool wiiu_gfx_read_viewport(void* data, uint8_t* buffer, bool is_idle)
static uintptr_t wiiu_gfx_load_texture(void* video_data, void* data,
bool threaded, enum texture_filter_type filter_type)
{
int i;
uint32_t i;
wiiu_video_t* wiiu = (wiiu_video_t*) video_data;
struct texture_image *image = (struct texture_image*)data;
@ -785,7 +784,7 @@ static void wiiu_gfx_apply_state_changes(void* data)
static void wiiu_gfx_set_texture_frame(void* data, const void* frame, bool rgb32,
unsigned width, unsigned height, float alpha)
{
int i;
uint32_t i;
const uint16_t *src = NULL;
uint16_t *dst = NULL;
wiiu_video_t* wiiu = (wiiu_video_t*) data;
@ -849,15 +848,17 @@ static void wiiu_gfx_set_osd_msg(void* data,
static const video_poke_interface_t wiiu_poke_interface =
{
NULL, /* set_coords */
NULL, /* set_mvp */
wiiu_gfx_load_texture,
wiiu_gfx_unload_texture,
NULL,
NULL, /* set_video_mode */
wiiu_gfx_set_filtering,
NULL, /* get_video_output_size */
NULL, /* get_video_output_prev */
NULL, /* get_video_output_next */
NULL, /* get_current_framebuffer */
NULL,
NULL, /* get_proc_address */
wiiu_gfx_set_aspect_ratio,
wiiu_gfx_apply_state_changes,
#ifdef HAVE_MENU
@ -865,9 +866,11 @@ static const video_poke_interface_t wiiu_poke_interface =
#endif
wiiu_gfx_set_texture_enable,
wiiu_gfx_set_osd_msg,
NULL,
NULL,
NULL
NULL, /* show_mouse */
NULL, /* grab_mouse_toggle */
NULL, /* get_current_shader */
NULL, /* get_current_software_framebuffer */
NULL, /* get_hw_render_interface */
};
static void wiiu_gfx_get_poke_interface(void* data,
@ -898,4 +901,5 @@ video_driver_t video_wiiu =
NULL, /* overlay_interface */
#endif
wiiu_gfx_get_poke_interface,
NULL, /* wrap_type_to_enum */
};

2
gfx/drivers/xshm_gfx.c
View File

@ -205,6 +205,8 @@ static void xshm_grab_mouse_toggle(void *data)
#endif
static video_poke_interface_t xshm_video_poke_interface = {
NULL, /* set_coords */
NULL, /* set_mvp */
NULL,
NULL,
NULL,

17
gfx/drivers_context/drm_ctx.c
View File

@ -28,13 +28,13 @@
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/poll.h>
#include <libdrm/drm.h>
#include <gbm.h>
#include <lists/dir_list.h>
#include <streams/file_stream.h>
#include <string/stdstring.h>
#include "../../configuration.h"
@ -80,7 +80,7 @@ typedef struct gfx_ctx_drm_data
#ifdef HAVE_EGL
egl_ctx_data_t egl;
#endif
RFILE *drm;
int fd;
unsigned interval;
unsigned fb_width;
unsigned fb_height;
@ -294,12 +294,14 @@ static void free_drm_resources(gfx_ctx_drm_data_t *drm)
drm_free();
if (drm->drm)
if (drm->fd >= 0)
{
if (g_drm_fd >= 0)
{
drmDropMaster(g_drm_fd);
filestream_close(drm->drm);
close(drm->fd);
}
}
g_gbm_surface = NULL;
g_gbm_dev = NULL;
@ -353,6 +355,7 @@ static void *gfx_ctx_drm_init(video_frame_info_t *video_info, void *video_driver
if (!drm)
return NULL;
drm->fd = -1;
gpu_descriptors = dir_list_new("/dev/dri", NULL, false, true, false, false);
@ -366,14 +369,14 @@ nextgpu:
}
gpu = gpu_descriptors->elems[gpu_index++].data;
drm->drm = filestream_open(gpu, RFILE_MODE_READ_WRITE, -1);
if (!drm->drm)
drm->fd = open(gpu, O_RDWR);
if (drm->fd < 0)
{
RARCH_WARN("[KMS]: Couldn't open DRM device.\n");
goto nextgpu;
}
fd = filestream_get_fd(drm->drm);
fd = drm->fd;
if (!drm_get_resources(fd))
goto nextgpu;

28
gfx/drivers_context/mali_fbdev_ctx.c
View File

@ -17,13 +17,13 @@
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <fcntl.h>
/* Includes and defines for framebuffer size retrieval */
#include <linux/fb.h>
#include <linux/vt.h>
#include <streams/file_stream.h>
#ifdef HAVE_CONFIG_H
#include "../../config.h"
#endif
@ -56,8 +56,7 @@ static enum gfx_ctx_api mali_api = GFX_CTX_NONE;
static void gfx_ctx_mali_fbdev_destroy(void *data)
{
int fb;
RFILE *fd = NULL;
int fd;
mali_ctx_data_t *mali = (mali_ctx_data_t*)data;
if (mali)
@ -71,12 +70,11 @@ static void gfx_ctx_mali_fbdev_destroy(void *data)
}
/* Clear framebuffer and set cursor on again */
fd = filestream_open("/dev/tty", RFILE_MODE_READ_WRITE, -1);
fb = filestream_get_fd(fd);
fd = open("/dev/tty", O_RDWR);
ioctl(fd, VT_ACTIVATE, 5);
ioctl(fd, VT_ACTIVATE, 1);
close(fd);
ioctl(fb, VT_ACTIVATE,5);
ioctl(fb, VT_ACTIVATE,1);
filestream_close(fd);
system("setterm -cursor on");
}
@ -160,16 +158,16 @@ static bool gfx_ctx_mali_fbdev_set_video_mode(void *data,
EGL_NONE
};
mali_ctx_data_t *mali = (mali_ctx_data_t*)data;
RFILE *fd = filestream_open("/dev/fb0", RFILE_MODE_READ_WRITE, -1);
int fb = filestream_get_fd(fd);
int fd = open("/dev/fb0", O_RDWR);
if (ioctl(fb, FBIOGET_VSCREENINFO, &vinfo) < 0)
if (ioctl(fd, FBIOGET_VSCREENINFO, &vinfo) < 0)
{
RARCH_ERR("Error obtaining framebuffer info.\n");
goto error;
}
filestream_close(fd);
close(fd);
fd = -1;
width = vinfo.xres;
height = vinfo.yres;
@ -196,8 +194,8 @@ static bool gfx_ctx_mali_fbdev_set_video_mode(void *data,
return true;
error:
if (fd)
filestream_close(fd);
if (fd >= 0)
close(fd);
RARCH_ERR("[Mali fbdev]: EGL error: %d.\n", eglGetError());
gfx_ctx_mali_fbdev_destroy(data);
return false;

14
gfx/drivers_context/vc_egl_ctx.c
View File

@ -198,11 +198,13 @@ static void *gfx_ctx_vc_init(video_frame_info_t *video_info, void *video_driver)
/* If we set this env variable, Broadcom's EGL implementation will block
* on vsync with a double buffer when we call eglSwapBuffers. Less input lag!
* Has to be done before any EGL call. */
/*if (video_info->max_swapchain_images <= 2)
* Has to be done before any EGL call.
* NOTE this is commented out because it should be the right way to do it, but
* currently it doesn't work, so we are using an vsync callback based solution.*/
/* if (video_info->max_swapchain_images <= 2)
setenv("V3D_DOUBLE_BUFFER", "1", 1);
else
setenv("V3D_DOUBLE_BUFFER", "0", 1);*/
setenv("V3D_DOUBLE_BUFFER", "0", 1); */
bcm_host_init();
@ -464,6 +466,10 @@ static void gfx_ctx_vc_destroy(void *data)
vc->vgimage[i] = 0;
}
/* Stop generating vsync callbacks if we are doing so. Don't destroy the context while cbs are being generated! */
if (vc->vsync_callback_set) {
vc_dispmanx_vsync_callback(vc->dispman_display, NULL, NULL);
}
/* Destroy mutexes and conditions. */
slock_free(vc->vsync_condition_mutex);
scond_free(vc->vsync_condition);
@ -629,7 +635,7 @@ static void gfx_ctx_vc_swap_buffers(void *data, void *data2)
#ifdef HAVE_EGL
egl_swap_buffers(&vc->egl);
/* Wait for vsync immediately if we don't wait egl_swap_buffers to triple-buffer */
/* Wait for vsync immediately if we don't want egl_swap_buffers to triple-buffer */
if (video_info->max_swapchain_images <= 2) {
/* We DON'T wait to wait without callback function ready! */
if(!vc->vsync_callback_set) {

10
gfx/drivers_context/wayland_ctx.c
View File

@ -480,22 +480,22 @@ static void registry_handle_global(void *data, struct wl_registry *reg,
(void)version;
if (string_is_equal_fast(interface, "wl_compositor", 13))
if (string_is_equal(interface, "wl_compositor"))
wl->compositor = (struct wl_compositor*)wl_registry_bind(reg,
id, &wl_compositor_interface, 3);
else if (string_is_equal_fast(interface, "wl_output", 9))
else if (string_is_equal(interface, "wl_output"))
{
output = (struct wl_output*)wl_registry_bind(reg,
id, &wl_output_interface, 2);
wl_output_add_listener(output, &output_listener, wl);
wl_display_roundtrip(wl->input.dpy);
}
else if (string_is_equal_fast(interface, "wl_shell", 8))
else if (string_is_equal(interface, "wl_shell"))
wl->shell = (struct wl_shell*)
wl_registry_bind(reg, id, &wl_shell_interface, 1);
else if (string_is_equal_fast(interface, "wl_shm", 6))
else if (string_is_equal(interface, "wl_shm"))
wl->shm = (struct wl_shm*)wl_registry_bind(reg, id, &wl_shm_interface, 1);
else if (string_is_equal_fast(interface, "wl_seat", 7))
else if (string_is_equal(interface, "wl_seat"))
{
wl->seat = (struct wl_seat*)wl_registry_bind(reg, id, &wl_seat_interface, 4);
wl_seat_add_listener(wl->seat, &seat_listener, wl);

8
gfx/drivers_font/caca_font.c
View File

@ -129,12 +129,6 @@ static void caca_render_msg(video_frame_info_t *video_info,
caca_refresh_display(*font->caca->caca_display);
}
static void caca_font_flush_block(unsigned width, unsigned height,
void* data)
{
(void)data;
}
static void caca_font_bind_block(void* data, void* userdata)
{
(void)data;
@ -147,6 +141,6 @@ font_renderer_t caca_font = {
"caca font",
caca_font_get_glyph, /* get_glyph */
caca_font_bind_block, /* bind_block */
caca_font_flush_block, /* flush */
NULL, /* flush */
caca_get_message_width /* get_message_width */
};

7
gfx/drivers_font/ctr_font.c
View File

@ -441,11 +441,6 @@ static const struct font_glyph* ctr_font_get_glyph(
return font->font_driver->get_glyph((void*)font->font_driver, code);
}
static void ctr_font_flush_block(unsigned width, unsigned height, void* data)
{
(void)data;
}
static void ctr_font_bind_block(void* data, void* userdata)
{
(void)data;
@ -460,6 +455,6 @@ font_renderer_t ctr_font =
"ctrfont",
ctr_font_get_glyph,
ctr_font_bind_block,
ctr_font_flush_block,
NULL, /* flush_block */
ctr_font_get_message_width,
};

3
gfx/drivers_font/gdi_font.c
View File

@ -140,7 +140,8 @@ static void gdi_render_msg(
SelectObject(font->gdi->memDC, font->gdi->bmp_old);
}
static void gdi_font_flush_block(unsigned width, unsigned height, void* data)
static void gdi_font_flush_block(unsigned width, unsigned height, void* data,
video_frame_info_t *video_info)
{
(void)data;
}

46
gfx/drivers_font/gl_raster_font.c
View File

@ -118,7 +118,7 @@ static bool gl_raster_font_upload_atlas(gl_raster_t *font)
#if defined(GL_VERSION_3_0)
struct retro_hw_render_callback *hwr = video_driver_get_hw_context();
if (gl_query_core_context_in_use() ||
if (font->gl->core_context_in_use ||
(hwr->context_type == RETRO_HW_CONTEXT_OPENGL &&
hwr->version_major >= 3))
{
@ -190,11 +190,8 @@ static void *gl_raster_font_init_font(void *data,
video_context_driver_make_current(false);
glGenTextures(1, &font->tex);
glBindTexture(GL_TEXTURE_2D, font->tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
gl_bind_texture(font->tex, GL_CLAMP_TO_EDGE, GL_LINEAR, GL_LINEAR);
font->atlas = font->font_driver->get_atlas(font->font_data);
font->tex_width = next_pow2(font->atlas->width);
@ -247,9 +244,9 @@ static int gl_get_message_width(void *data, const char *msg,
return delta_x * scale;
}
static void gl_raster_font_draw_vertices(gl_raster_t *font, const video_coords_t *coords)
static void gl_raster_font_draw_vertices(gl_raster_t *font, const video_coords_t *coords,
video_frame_info_t *video_info)
{
video_shader_ctx_mvp_t mvp;
video_shader_ctx_coords_t coords_data;
if (font->atlas->dirty)
@ -261,12 +258,10 @@ static void gl_raster_font_draw_vertices(gl_raster_t *font, const video_coords_t
coords_data.handle_data = NULL;
coords_data.data = coords;
video_shader_driver_set_coords(coords_data);
video_driver_set_coords(&coords_data);
mvp.data = font->gl;
mvp.matrix = &font->gl->mvp_no_rot;
video_shader_driver_set_mvp(mvp);
video_info->cb_set_mvp(font->gl,
video_info->shader_data, &font->gl->mvp_no_rot);
glDrawArrays(GL_TRIANGLES, 0, coords->vertices);
}
@ -274,7 +269,8 @@ static void gl_raster_font_draw_vertices(gl_raster_t *font, const video_coords_t
static void gl_raster_font_render_line(
gl_raster_t *font, const char *msg, unsigned msg_len,
GLfloat scale, const GLfloat color[4], GLfloat pos_x,
GLfloat pos_y, unsigned text_align)
GLfloat pos_y, unsigned text_align,
video_frame_info_t *video_info)
{
unsigned i;
struct video_coords coords;
@ -349,14 +345,15 @@ static void gl_raster_font_render_line(
if (font->block)
video_coord_array_append(&font->block->carr, &coords, coords.vertices);
else
gl_raster_font_draw_vertices(font, &coords);
gl_raster_font_draw_vertices(font, &coords, video_info);
}
}
static void gl_raster_font_render_message(
gl_raster_t *font, const char *msg, GLfloat scale,
const GLfloat color[4], GLfloat pos_x, GLfloat pos_y,
unsigned text_align)
unsigned text_align,
video_frame_info_t *video_info)
{
float line_height;
int lines = 0;
@ -366,7 +363,8 @@ static void gl_raster_font_render_message(
{
gl_raster_font_render_line(font,
msg, (unsigned)strlen(msg), scale, color, pos_x,
pos_y, text_align);
pos_y, text_align,
video_info);
return;
}
@ -382,7 +380,8 @@ static void gl_raster_font_render_message(
/* Draw the line */
gl_raster_font_render_line(font,
msg, msg_len, scale, color, pos_x,
pos_y - (float)lines*line_height, text_align);
pos_y - (float)lines*line_height, text_align,
video_info);
if (!delim)
break;
@ -490,11 +489,13 @@ static void gl_raster_font_render_msg(
if (font->gl)
gl_raster_font_render_message(font, msg, scale, color_dark,
x + scale * drop_x / font->gl->vp.width, y +
scale * drop_y / font->gl->vp.height, text_align);
scale * drop_y / font->gl->vp.height, text_align,
video_info);
}
if (font->gl)
gl_raster_font_render_message(font, msg, scale, color, x, y, text_align);
gl_raster_font_render_message(font, msg, scale, color,
x, y, text_align, video_info);
}
if (!font->block && font->gl)
@ -520,7 +521,7 @@ static const struct font_glyph *gl_raster_font_get_glyph(
}
static void gl_raster_font_flush_block(unsigned width, unsigned height,
void *data)
void *data, video_frame_info_t *video_info)
{
gl_raster_t *font = (gl_raster_t*)data;
video_font_raster_block_t *block = font ? font->block : NULL;
@ -529,7 +530,8 @@ static void gl_raster_font_flush_block(unsigned width, unsigned height,
return;
gl_raster_font_setup_viewport(width, height, font, block->fullscreen);
gl_raster_font_draw_vertices(font, (video_coords_t*)&block->carr.coords);
gl_raster_font_draw_vertices(font, (video_coords_t*)&block->carr.coords,
video_info);
if (font->gl)
{

8
gfx/drivers_font/vga_font.c
View File

@ -129,12 +129,6 @@ static void vga_render_msg(video_frame_info_t *video_info,
}
}
static void vga_font_flush_block(unsigned width, unsigned height,
void* data)
{
(void)data;
}
static void vga_font_bind_block(void* data, void* userdata)
{
(void)data;
@ -147,6 +141,6 @@ font_renderer_t vga_font = {
"vga font",
vga_font_get_glyph, /* get_glyph */
vga_font_bind_block, /* bind_block */
vga_font_flush_block, /* flush */
NULL, /* flush */
vga_get_message_width /* get_message_width */
};

8
gfx/drivers_font/vita2d_font.c
View File

@ -346,12 +346,6 @@ static const struct font_glyph *vita2d_font_get_glyph(
return font->font_driver->get_glyph((void*)font->font_driver, code);
}
static void vita2d_font_flush_block(unsigned width, unsigned height,
void *data)
{
(void)data;
}
static void vita2d_font_bind_block(void *data, void *userdata)
{
(void)data;
@ -364,6 +358,6 @@ font_renderer_t vita2d_vita_font = {
"vita2dfont",
vita2d_font_get_glyph,
vita2d_font_bind_block,
vita2d_font_flush_block,
NULL, /* flush */
vita2d_font_get_message_width,
};

2
gfx/drivers_font/vulkan_raster_font.c
View File

@ -436,7 +436,7 @@ static const struct font_glyph *vulkan_raster_font_get_glyph(
}
static void vulkan_raster_font_flush_block(unsigned width, unsigned height,
void *data)
void *data, video_frame_info_t *video_info)
{
(void)data;
}

9
gfx/drivers_font/wiiu_font.c
View File

@ -40,7 +40,7 @@ typedef struct
static void* wiiu_font_init_font(void* data, const char* font_path,
float font_size, bool is_threaded)
{
int i;
uint32_t i;
wiiu_font_t* font = (wiiu_font_t*)calloc(1, sizeof(*font));
if (!font)
@ -401,11 +401,6 @@ static const struct font_glyph* wiiu_font_get_glyph(
return font->font_driver->get_glyph((void*)font->font_driver, code);
}
static void wiiu_font_flush_block(unsigned width, unsigned height, void* data)
{
(void)data;
}
static void wiiu_font_bind_block(void* data, void* userdata)
{
(void)data;
@ -420,6 +415,6 @@ font_renderer_t wiiu_font =
"wiiufont",
wiiu_font_get_glyph,
wiiu_font_bind_block,
wiiu_font_flush_block,
NULL, /* flush */
wiiu_font_get_message_width,
};

30
gfx/drivers_renderchain/d3d8_renderchain.c
View File

@ -43,13 +43,17 @@ typedef struct d3d8_renderchain
uint64_t frame_count;
} d3d8_renderchain_t;
static void renderchain_set_mvp(void *data, unsigned vp_width,
static void d3d8_renderchain_set_mvp(
void *chain_data,
void *data, unsigned vp_width,
unsigned vp_height, unsigned rotation)
{
d3d_video_t *d3d = (d3d_video_t*)data;
LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)d3d->dev;
D3DMATRIX p_out, p_rotate, mat;
(void)chain_data;
d3d_matrix_ortho_off_center_lh(&mat, 0, vp_width, vp_height, 0, 0.0f, 1.0f);
d3d_matrix_identity(&p_out);
d3d_matrix_rotation_z(&p_rotate, rotation * (M_PI / 2.0));
@ -67,7 +71,7 @@ static void d3d8_renderchain_clear(void *data)
d3d_vertex_buffer_free(chain->vertex_buf, chain->vertex_decl);
}
static bool renderchain_create_first_pass(void *data,
static bool d3d8_renderchain_create_first_pass(void *data,
const video_info_t *info)
{
d3d_video_t *d3d = (d3d_video_t*)data;
@ -106,7 +110,7 @@ static bool renderchain_create_first_pass(void *data,
return true;
}
static void renderchain_set_vertices(void *data, unsigned pass,
static void d3d8_renderchain_set_vertices(void *data, unsigned pass,
unsigned vert_width, unsigned vert_height, uint64_t frame_count)
{
unsigned width, height;
@ -171,7 +175,7 @@ static void renderchain_set_vertices(void *data, unsigned pass,
}
}
static void renderchain_blit_to_texture(void *data, const void *frame,
static void d3d8_renderchain_blit_to_texture(void *data, const void *frame,
unsigned width, unsigned height, unsigned pitch)
{
D3DLOCKED_RECT d3dlr;
@ -254,7 +258,7 @@ static bool d3d8_renderchain_init(void *data,
chain->tex_w = link_info->tex_w;
chain->tex_h = link_info->tex_h;
if (!renderchain_create_first_pass(d3d, video_info))
if (!d3d8_renderchain_create_first_pass(d3d, video_info))
return false;
/* FIXME */
@ -283,17 +287,17 @@ static bool d3d8_renderchain_render(void *data, const void *frame,
{
unsigned i;
unsigned width, height;
d3d_video_t *d3d = (d3d_video_t*)data;
LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)d3d->dev;
settings_t *settings = config_get_ptr();
d3d_video_t *d3d = (d3d_video_t*)data;
LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)d3d->dev;
settings_t *settings = config_get_ptr();
d3d8_renderchain_t *chain = (d3d8_renderchain_t*)d3d->renderchain_data;
chain->frame_count++;
video_driver_get_size(&width, &height);
renderchain_blit_to_texture(chain, frame, frame_width, frame_height, pitch);
renderchain_set_vertices(d3d, 1, frame_width, frame_height, chain->frame_count);
d3d8_renderchain_blit_to_texture(chain, frame, frame_width, frame_height, pitch);
d3d8_renderchain_set_vertices(d3d, 1, frame_width, frame_height, chain->frame_count);
d3d_set_texture(d3dr, 0, chain->tex);
d3d_set_viewports(chain->dev, &d3d->final_viewport);
@ -307,7 +311,7 @@ static bool d3d8_renderchain_render(void *data, const void *frame,
d3d_set_stream_source(d3dr, i, chain->vertex_buf, 0, sizeof(Vertex));
d3d_draw_primitive(d3dr, D3DPT_TRIANGLESTRIP, 0, 2);
renderchain_set_mvp(d3d, width, height, d3d->dev_rotation);
d3d8_renderchain_set_mvp(chain, d3d, width, height, d3d->dev_rotation);
return true;
}
@ -365,7 +369,8 @@ static bool d3d8_renderchain_reinit(void *data,
return true;
}
static void d3d8_renderchain_viewport_info(void *data, struct video_viewport *vp)
static void d3d8_renderchain_viewport_info(void *data,
struct video_viewport *vp)
{
unsigned width, height;
d3d_video_t *d3d = (d3d_video_t*)data;
@ -385,6 +390,7 @@ static void d3d8_renderchain_viewport_info(void *data, struct video_viewport *vp
}
d3d_renderchain_driver_t d3d8_d3d_renderchain = {
d3d8_renderchain_set_mvp,
d3d8_renderchain_free,
d3d8_renderchain_new,
d3d8_renderchain_reinit,

8
gfx/drivers_renderchain/d3d9_cg_renderchain.c
View File

@ -1191,13 +1191,14 @@ static void d3d9_cg_renderchain_end_render(cg_renderchain_t *chain)
}
static void d3d9_cg_renderchain_set_mvp(
cg_renderchain_t *chain,
void *vertex_program,
void *chain_data,
void *data,
unsigned vp_width, unsigned vp_height,
unsigned rotation)
{
D3DMATRIX proj, ortho, rot, tmp;
CGprogram vPrg = (CGprogram)vertex_program;
CGprogram vPrg = (CGprogram)data;
cg_renderchain_t *chain = (cg_renderchain_t*)chain_data;
d3d_matrix_ortho_off_center_lh(&ortho, 0, vp_width, 0, vp_height, 0, 1);
d3d_matrix_identity(&rot);
@ -1686,6 +1687,7 @@ static void d3d9_cg_renderchain_viewport_info(
}
d3d_renderchain_driver_t cg_d3d9_renderchain = {
d3d9_cg_renderchain_set_mvp,
d3d9_cg_renderchain_free,
d3d9_cg_renderchain_new,
NULL,

59
gfx/drivers_renderchain/d3d9_hlsl_renderchain.cpp → gfx/drivers_renderchain/d3d9_hlsl_renderchain.c
View File

@ -44,19 +44,22 @@ typedef struct hlsl_d3d9_renderchain
/* TODO/FIXME - this forward declaration should not be necesary */
void hlsl_set_proj_matrix(void *data, XMMATRIX rotation_value);
static void renderchain_set_mvp(void *data, unsigned vp_width,
static void hlsl_d3d9_renderchain_set_mvp(
void *chain_data,
void *data, unsigned vp_width,
unsigned vp_height, unsigned rotation)
{
video_shader_ctx_mvp_t mvp;
d3d_video_t *d3d = (d3d_video_t*)data;
LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)d3d->dev;
hlsl_set_proj_matrix((void*)&d3d->shader, XMMatrixRotationZ(rotation * (M_PI / 2.0)));
hlsl_set_proj_matrix((void*)&d3d->shader,
XMMatrixRotationZ(rotation * (M_PI / 2.0)));
mvp.data = d3d;
mvp.matrix = NULL;
video_shader_driver_set_mvp(mvp);
video_driver_set_mvp(&mvp);
}
static void hlsl_d3d9_renderchain_clear(void *data)
@ -75,10 +78,11 @@ static bool hlsl_d3d9_renderchain_init_shader_fvf(void *data, void *pass_data)
{ 0, 2 * sizeof(float), D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },
D3DDECL_END()
};
d3d_video_t *d3d = (d3d_video_t*)data;
d3d_video_t *pass = (d3d_video_t*)data;
LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)d3d->dev;
hlsl_d3d9_renderchain_t *chain = (hlsl_d3d9_renderchain_t*)d3d->renderchain_data;
d3d_video_t *d3d = (d3d_video_t*)data;
d3d_video_t *pass = (d3d_video_t*)data;
LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)d3d->dev;
hlsl_d3d9_renderchain_t *chain = (hlsl_d3d9_renderchain_t*)
d3d->renderchain_data;
(void)pass_data;
@ -86,14 +90,16 @@ static bool hlsl_d3d9_renderchain_init_shader_fvf(void *data, void *pass_data)
VertexElements, (void**)&chain->vertex_decl);
}
static bool renderchain_create_first_pass(void *data,
static bool hlsl_d3d9_renderchain_create_first_pass(void *data,
const video_info_t *info)
{
d3d_video_t *d3d = (d3d_video_t*)data;
LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)d3d->dev;
hlsl_d3d9_renderchain_t *chain = (hlsl_d3d9_renderchain_t*)d3d->renderchain_data;
hlsl_d3d9_renderchain_t *chain = (hlsl_d3d9_renderchain_t*)
d3d->renderchain_data;
chain->vertex_buf = d3d_vertex_buffer_new(d3dr, 4 * sizeof(Vertex),
chain->vertex_buf = d3d_vertex_buffer_new(
d3dr, 4 * sizeof(Vertex),
D3DUSAGE_WRITEONLY, D3DFVF_CUSTOMVERTEX, D3DPOOL_MANAGED,
NULL);
@ -123,7 +129,8 @@ static bool renderchain_create_first_pass(void *data,
return true;
}
static void renderchain_set_vertices(void *data, unsigned pass,
static void hlsl_d3d9_renderchain_set_vertices(
void *data, unsigned pass,
unsigned vert_width, unsigned vert_height, uint64_t frame_count)
{
video_shader_ctx_params_t params;
@ -184,7 +191,8 @@ static void renderchain_set_vertices(void *data, unsigned pass,
d3d_vertex_buffer_unlock(chain->vertex_buf);
}
renderchain_set_mvp(d3d, width, height, d3d->dev_rotation);
hlsl_d3d9_renderchain_set_mvp(chain,
d3d, width, height, d3d->dev_rotation);
shader_info.data = d3d;
shader_info.idx = pass;
@ -209,8 +217,9 @@ static void renderchain_set_vertices(void *data, unsigned pass,
video_shader_driver_set_parameters(params);
}
static void renderchain_blit_to_texture(void *data, const void *frame,
unsigned width, unsigned height, unsigned pitch)
static void hlsl_d3d9_renderchain_blit_to_texture(
void *data, const void *frame,
unsigned width, unsigned height, unsigned pitch)
{
D3DLOCKED_RECT d3dlr;
hlsl_d3d9_renderchain_t *chain = (hlsl_d3d9_renderchain_t*)data;
@ -258,7 +267,6 @@ static void hlsl_d3d9_renderchain_free(void *data)
hlsl_d3d9_renderchain_clear(chain->renderchain_data);
}
void *hlsl_d3d9_renderchain_new(void)
{
hlsl_d3d9_renderchain_t *renderchain =
@ -324,7 +332,7 @@ static bool hlsl_d3d9_renderchain_init(void *data,
chain->tex_w = link_info->tex_w;
chain->tex_h = link_info->tex_h;
if (!renderchain_create_first_pass(d3d, video_info))
if (!hlsl_d3d9_renderchain_create_first_pass(d3d, video_info))
return false;
/* FIXME */
@ -363,8 +371,10 @@ static bool hlsl_d3d9_renderchain_render(void *data, const void *frame,
video_driver_get_size(&width, &height);
renderchain_blit_to_texture(chain, frame, frame_width, frame_height, pitch);
renderchain_set_vertices(d3d, 1, frame_width, frame_height, chain->frame_count);
hlsl_d3d9_renderchain_blit_to_texture(chain,
frame, frame_width, frame_height, pitch);
hlsl_d3d9_renderchain_set_vertices(d3d,
1, frame_width, frame_height, chain->frame_count);
d3d_set_texture(d3dr, 0, chain->tex);
d3d_set_viewports(chain->dev, &d3d->final_viewport);
@ -378,12 +388,14 @@ static bool hlsl_d3d9_renderchain_render(void *data, const void *frame,
d3d_set_stream_source(d3dr, i, chain->vertex_buf, 0, sizeof(Vertex));
d3d_draw_primitive(d3dr, D3DPT_TRIANGLESTRIP, 0, 2);
renderchain_set_mvp(d3d, width, height, d3d->dev_rotation);
hlsl_d3d9_renderchain_set_mvp(
chain, d3d, width, height, d3d->dev_rotation);
return true;
}
static bool hlsl_d3d9_renderchain_add_pass(void *data, const void *info_data)
static bool hlsl_d3d9_renderchain_add_pass(
void *data, const void *info_data)
{
(void)data;
(void)info_data;
@ -392,7 +404,8 @@ static bool hlsl_d3d9_renderchain_add_pass(void *data, const void *info_data)
return true;
}
static void hlsl_d3d9_renderchain_add_state_tracker(void *data, void *tracker_data)
static void hlsl_d3d9_renderchain_add_state_tracker(
void *data, void *tracker_data)
{
(void)data;
(void)tracker_data;
@ -438,7 +451,8 @@ static bool hlsl_d3d9_renderchain_reinit(void *data,
return true;
}
static void hlsl_d3d9_renderchain_viewport_info(void *data, struct video_viewport *vp)
static void hlsl_d3d9_renderchain_viewport_info(
void *data, struct video_viewport *vp)
{
unsigned width, height;
d3d_video_t *d3d = (d3d_video_t*)data;
@ -458,6 +472,7 @@ static void hlsl_d3d9_renderchain_viewport_info(void *data, struct video_viewpor
}
d3d_renderchain_driver_t hlsl_d3d9_renderchain = {
hlsl_d3d9_renderchain_set_mvp,
hlsl_d3d9_renderchain_free,
hlsl_d3d9_renderchain_new,
hlsl_d3d9_renderchain_reinit,

329
gfx/drivers_renderchain/gl1_renderchain.c Normal file
View File

@ -0,0 +1,329 @@
/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
* Copyright (C) 2011-2017 - Daniel De Matteis
* Copyright (C) 2012-2015 - Michael Lelli
*
* RetroArch 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 Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* RetroArch 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 RetroArch.
* If not, see <http://www.gnu.org/licenses/>.
*/
#ifdef _MSC_VER
#pragma comment(lib, "opengl32")
#endif
#include <stdio.h>
#include <stdint.h>
#include <math.h>
#include <string.h>
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <retro_common_api.h>
#include <libretro.h>
#include <compat/strl.h>
#include <gfx/scaler/scaler.h>
#include <formats/image.h>
#include <retro_inline.h>
#include <retro_miscellaneous.h>
#include <retro_math.h>
#include <string/stdstring.h>
#include <gfx/gl_capabilities.h>
#include <gfx/video_frame.h>
#include "../video_driver.h"
#include "../video_shader_parse.h"
#include "../common/gl_common.h"
#include "../../driver.h"
#include "../../configuration.h"
#include "../../verbosity.h"
typedef struct gl1_renderchain
{
void *empty;
} gl1_renderchain_t;
GLenum min_filter_to_mag(GLenum type);
void gl1_renderchain_free(void *data)
{
gl_t *gl = (gl_t*)data;
(void)gl;
}
static void gl1_renderchain_bind_prev_texture(
void *data,
const struct video_tex_info *tex_info)
{
gl_t *gl = (gl_t*)data;
memmove(gl->prev_info + 1, gl->prev_info,
sizeof(*tex_info) * (gl->textures - 1));
memcpy(&gl->prev_info[0], tex_info,
sizeof(*tex_info));
}
static void gl1_renderchain_viewport_info(
void *data, struct video_viewport *vp)
{
unsigned width, height;
unsigned top_y, top_dist;
gl_t *gl = (gl_t*)data;
video_driver_get_size(&width, &height);
*vp = gl->vp;
vp->full_width = width;
vp->full_height = height;
/* Adjust as GL viewport is bottom-up. */
top_y = vp->y + vp->height;
top_dist = height - top_y;
vp->y = top_dist;
}
static bool gl1_renderchain_read_viewport(
void *data, uint8_t *buffer, bool is_idle)
{
unsigned num_pixels = 0;
gl_t *gl = (gl_t*)data;
if (!gl)
return false;
num_pixels = gl->vp.width * gl->vp.height;
/* Use slow synchronous readbacks. Use this with plain screenshots
as we don't really care about performance in this case. */
/* GLES2 only guarantees GL_RGBA/GL_UNSIGNED_BYTE
* readbacks so do just that.
* GLES2 also doesn't support reading back data
* from front buffer, so render a cached frame
* and have gl_frame() do the readback while it's
* in the back buffer.
*
* Keep codepath similar for GLES and desktop GL.
*/
gl->readback_buffer_screenshot = malloc(num_pixels * sizeof(uint32_t));
if (!gl->readback_buffer_screenshot)
return false;
if (!is_idle)
video_driver_cached_frame();
video_frame_convert_rgba_to_bgr(
(const void*)gl->readback_buffer_screenshot,
buffer,
num_pixels);
free(gl->readback_buffer_screenshot);
gl->readback_buffer_screenshot = NULL;
return true;
}
void gl1_renderchain_free_internal(void *data)
{
gl1_renderchain_t *cg_data = (gl1_renderchain_t*)data;
if (!cg_data)
return;
free(cg_data);
}
static void *gl1_renderchain_new(void)
{
gl1_renderchain_t *renderchain = (gl1_renderchain_t*)
calloc(1, sizeof(*renderchain));
if (!renderchain)
return NULL;
return renderchain;
}
static void gl1_renderchain_ff_vertex(const void *data)
{
const struct video_coords *coords = (const struct video_coords*)data;
/* Fall back to fixed function-style if needed and possible. */
glClientActiveTexture(GL_TEXTURE1);
glTexCoordPointer(2, GL_FLOAT, 0, coords->lut_tex_coord);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(GL_TEXTURE0);
glVertexPointer(2, GL_FLOAT, 0, coords->vertex);
glEnableClientState(GL_VERTEX_ARRAY);
glColorPointer(4, GL_FLOAT, 0, coords->color);
glEnableClientState(GL_COLOR_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, coords->tex_coord);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
}
static void gl1_renderchain_ff_matrix(const void *data)
{
math_matrix_4x4 ident;
const math_matrix_4x4 *mat = (const math_matrix_4x4*)data;
/* Fall back to fixed function-style if needed and possible. */
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(mat->data);
glMatrixMode(GL_MODELVIEW);
matrix_4x4_identity(ident);
glLoadMatrixf(ident.data);
}
static void gl1_renderchain_disable_client_arrays(void)
{
if (gl_query_core_context_in_use())
return;
glClientActiveTexture(GL_TEXTURE1);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(GL_TEXTURE0);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
static void gl1_renderchain_restore_default_state(void *data)
{
gl_t *gl = (gl_t*)data;
if (!gl)
return;
glEnable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glDisable(GL_DITHER);
}
static void gl1_renderchain_copy_frame(
void *data,
video_frame_info_t *video_info,
const void *frame,
unsigned width, unsigned height, unsigned pitch)
{
gl_t *gl = (gl_t*)data;
const GLvoid *data_buf = frame;
glPixelStorei(GL_UNPACK_ALIGNMENT, video_pixel_get_alignment(pitch));
if (gl->base_size == 2 && !gl->have_es2_compat)
{
/* Convert to 32-bit textures on desktop GL.
*
* It is *much* faster (order of magnitude on my setup)
* to use a custom SIMD-optimized conversion routine
* than letting GL do it. */
video_frame_convert_rgb16_to_rgb32(
&gl->scaler,
gl->conv_buffer,
frame,
width,
height,
pitch);
data_buf = gl->conv_buffer;
}
else
glPixelStorei(GL_UNPACK_ROW_LENGTH, pitch / gl->base_size);
glTexSubImage2D(GL_TEXTURE_2D,
0, 0, 0, width, height, gl->texture_type,
gl->texture_fmt, data_buf);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
}
static void gl1_renderchain_readback(void *data,
unsigned alignment,
unsigned fmt, unsigned type,
void *src)
{
gl_t *gl = (gl_t*)data;
glPixelStorei(GL_PACK_ALIGNMENT, alignment);
glPixelStorei(GL_PACK_ROW_LENGTH, 0);
glReadBuffer(GL_BACK);
glReadPixels(gl->vp.x, gl->vp.y,
gl->vp.width, gl->vp.height,
(GLenum)fmt, (GLenum)type, (GLvoid*)src);
}
static void gl1_renderchain_set_mvp(void *data,
void *shader_data, const void *mat_data)
{
math_matrix_4x4 ident;
const math_matrix_4x4 *mat = (const math_matrix_4x4*)mat_data;
/* Fall back to fixed function-style if needed and possible. */
glMatrixMode(GL_PROJECTION);
glLoadMatrixf(mat->data);
glMatrixMode(GL_MODELVIEW);
matrix_4x4_identity(ident);
glLoadMatrixf(ident.data);
}
static void gl1_renderchain_set_coords(void *handle_data,
void *shader_data, const struct video_coords *coords)
{
/* Fall back to fixed function-style if needed and possible. */
glClientActiveTexture(GL_TEXTURE1);
glTexCoordPointer(2, GL_FLOAT, 0, coords->lut_tex_coord);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glClientActiveTexture(GL_TEXTURE0);
glVertexPointer(2, GL_FLOAT, 0, coords->vertex);
glEnableClientState(GL_VERTEX_ARRAY);
glColorPointer(4, GL_FLOAT, 0, coords->color);
glEnableClientState(GL_COLOR_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, coords->tex_coord);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
}
gl_renderchain_driver_t gl2_renderchain = {
gl1_renderchain_set_coords,
gl1_renderchain_set_mvp,
NULL, /* init_textures_reference */
NULL, /* fence_iterate */
NULL, /* fence_free */
gl1_renderchain_readback,
NULL, /* renderchain_init_pbo */
NULL, /* renderchain_bind_pbo */
NULL, /* renderchain_unbind_pbo */
gl1_renderchain_copy_frame,
gl1_renderchain_restore_default_state,
NULL, /* new_vao */
NULL, /* free_vao */
NULL, /* bind_vao */
NULL, /* unbind_vao */
gl1_renderchain_disable_client_arrays, /* disable_client_arrays */
gl1_renderchain_ff_vertex, /* ff_vertex */
gl1_renderchain_ff_matrix,
NULL, /* bind_backbuffer */
NULL, /* deinit_fbo */
gl1_renderchain_viewport_info,
gl1_renderchain_read_viewport,
gl1_renderchain_bind_prev_texture,
gl1_renderchain_free_internal,
gl1_renderchain_new,
NULL, /* renderchain_init */
NULL, /* init_hw_render */
gl1_renderchain_free,
NULL, /* deinit_hw_render */
NULL, /* start_render */
NULL, /* check_fbo_dimensions */
NULL, /* recompute_pass_sizes */
NULL, /* renderchain_render */
"gl1",
};

542
gfx/drivers_renderchain/gl2_renderchain.c
View File

@ -28,6 +28,9 @@
#include "config.h"
#endif
#include <retro_common_api.h>
#include <libretro.h>
#include <compat/strl.h>
#include <gfx/scaler/scaler.h>
#include <formats/image.h>
@ -39,16 +42,23 @@
#include <gfx/gl_capabilities.h>
#include <gfx/video_frame.h>
#include "gl2_renderchain.h"
#include "../video_driver.h"
#include "../video_shader_parse.h"
#include "../common/gl_common.h"
#include "../../driver.h"
#include "../../configuration.h"
#include "../../verbosity.h"
#if defined(_WIN32) && !defined(_XBOX)
#include "../common/win32_common.h"
typedef struct gl2_renderchain
{
void *empty;
} gl2_renderchain_t;
#if (!defined(HAVE_OPENGLES) || defined(HAVE_OPENGLES3))
#ifdef GL_PIXEL_PACK_BUFFER
#define HAVE_GL_ASYNC_READBACK
#endif
#endif
#define set_texture_coords(coords, xamt, yamt) \
@ -57,24 +67,47 @@
coords[5] = yamt; \
coords[7] = yamt
#ifdef IOS
/* There is no default frame buffer on iOS. */
void cocoagl_bind_game_view_fbo(void);
#define gl_bind_backbuffer() cocoagl_bind_game_view_fbo()
#else
#define gl_bind_backbuffer() glBindFramebuffer(RARCH_GL_FRAMEBUFFER, 0)
#define gl2_bind_fb(id) glBindFramebuffer(RARCH_GL_FRAMEBUFFER, id)
#ifndef GL_SYNC_GPU_COMMANDS_COMPLETE
#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117
#endif
#ifndef GL_SYNC_FLUSH_COMMANDS_BIT
#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001
#endif
/* Prototypes */
static void gl2_renderchain_bind_backbuffer(void)
{
#ifdef IOS
/* There is no default frame buffer on iOS. */
void cocoagl_bind_game_view_fbo(void);
cocoagl_bind_game_view_fbo();
#else
gl2_bind_fb(0);
#endif
}
void context_bind_hw_render(bool enable);
GLenum min_filter_to_mag(GLenum type);
void gl_load_texture_data(
uint32_t id_data,
enum gfx_wrap_type wrap_type,
enum texture_filter_type filter_type,
unsigned alignment,
unsigned width, unsigned height,
const void *frame, unsigned base_size);
void gl_set_viewport(
void *data, video_frame_info_t *video_info,
unsigned viewport_width,
unsigned viewport_height,
bool force_full, bool allow_rotate);
#ifdef HAVE_FBO
void gl2_renderchain_convert_geometry(
static void gl2_renderchain_convert_geometry(
void *data,
struct video_fbo_rect *fbo_rect,
struct gfx_fbo_scale *fbo_scale,
@ -125,7 +158,7 @@ static bool gl_recreate_fbo(
GLuint* texture
)
{
glBindFramebuffer(RARCH_GL_FRAMEBUFFER, fbo);
gl2_bind_fb(fbo);
glDeleteTextures(1, texture);
glGenTextures(1, texture);
glBindTexture(GL_TEXTURE_2D, *texture);
@ -185,7 +218,7 @@ static void gl_check_fbo_dimension(gl_t *gl, unsigned i,
/* On resize, we might have to recreate our FBOs
* due to "Viewport" scale, and set a new viewport. */
void gl2_renderchain_check_fbo_dimensions(void *data)
static void gl2_renderchain_check_fbo_dimensions(void *data)
{
int i;
gl_t *gl = (gl_t*)data;
@ -206,7 +239,7 @@ void gl2_renderchain_check_fbo_dimensions(void *data)
}
}
void gl2_renderchain_render(
static void gl2_renderchain_render(
void *data,
video_frame_info_t *video_info,
uint64_t frame_count,
@ -214,7 +247,6 @@ void gl2_renderchain_render(
const struct video_tex_info *feedback_info)
{
int i;
video_shader_ctx_mvp_t mvp;
video_shader_ctx_coords_t coords;
video_shader_ctx_params_t params;
video_shader_ctx_info_t shader_info;
@ -237,7 +269,6 @@ void gl2_renderchain_render(
* and render all passes from FBOs, to another FBO. */
for (i = 1; i < gl->fbo_pass; i++)
{
video_shader_ctx_mvp_t mvp;
video_shader_ctx_coords_t coords;
video_shader_ctx_params_t params;
const struct video_fbo_rect *rect = &gl->fbo_rect[i];
@ -258,7 +289,7 @@ void gl2_renderchain_render(
memcpy(fbo_info->coord, fbo_tex_coords, sizeof(fbo_tex_coords));
fbo_tex_info_cnt++;
glBindFramebuffer(RARCH_GL_FRAMEBUFFER, gl->fbo[i]);
gl2_bind_fb(gl->fbo[i]);
shader_info.data = gl;
shader_info.idx = i + 1;
@ -270,7 +301,7 @@ void gl2_renderchain_render(
mip_level = i + 1;
if (video_shader_driver_mipmap_input(&mip_level)
&& gl_check_capability(GL_CAPS_MIPMAP))
&& gl->have_mipmap)
glGenerateMipmap(GL_TEXTURE_2D);
glClear(GL_COLOR_BUFFER_BIT);
@ -300,12 +331,10 @@ void gl2_renderchain_render(
coords.handle_data = NULL;
coords.data = &gl->coords;
video_shader_driver_set_coords(coords);
video_driver_set_coords(&coords);
mvp.data = gl;
mvp.matrix = &gl->mvp;
video_shader_driver_set_mvp(mvp);
video_info->cb_set_mvp(gl,
video_info->shader_data, &gl->mvp);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
@ -334,7 +363,7 @@ void gl2_renderchain_render(
fbo_tex_info_cnt++;
/* Render our FBO texture to back buffer. */
gl_bind_backbuffer();
gl2_renderchain_bind_backbuffer();
shader_info.data = gl;
shader_info.idx = gl->fbo_pass + 1;
@ -347,7 +376,7 @@ void gl2_renderchain_render(
mip_level = gl->fbo_pass + 1;
if (video_shader_driver_mipmap_input(&mip_level)
&& gl_check_capability(GL_CAPS_MIPMAP))
&& gl->have_mipmap)
glGenerateMipmap(GL_TEXTURE_2D);
glClear(GL_COLOR_BUFFER_BIT);
@ -377,22 +406,19 @@ void gl2_renderchain_render(
coords.handle_data = NULL;
coords.data = &gl->coords;
video_shader_driver_set_coords(coords);
video_driver_set_coords(&coords);
mvp.data = gl;
mvp.matrix = &gl->mvp;
video_info->cb_set_mvp(gl,
video_info->shader_data, &gl->mvp);
video_shader_driver_set_mvp(mvp);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
gl->coords.tex_coord = gl->tex_info.coord;
}
void gl2_renderchain_deinit_fbo(void *data)
static void gl2_renderchain_deinit_fbo(void *data)
{
gl_t *gl = (gl_t*)data;
if (!gl->fbo_inited)
return;
glDeleteTextures(gl->fbo_pass, gl->fbo_texture);
glDeleteFramebuffers(gl->fbo_pass, gl->fbo);
@ -412,7 +438,7 @@ void gl2_renderchain_deinit_fbo(void *data)
gl->fbo_feedback = 0;
}
void gl2_renderchain_deinit_hw_render(void *data)
static void gl2_renderchain_deinit_hw_render(void *data)
{
gl_t *gl = (gl_t*)data;
if (!gl)
@ -448,7 +474,7 @@ static bool gl_create_fbo_targets(gl_t *gl)
{
GLenum status;
glBindFramebuffer(RARCH_GL_FRAMEBUFFER, gl->fbo[i]);
gl2_bind_fb(gl->fbo[i]);
glFramebufferTexture2D(RARCH_GL_FRAMEBUFFER,
RARCH_GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, gl->fbo_texture[i], 0);
@ -462,7 +488,7 @@ static bool gl_create_fbo_targets(gl_t *gl)
GLenum status;
glGenFramebuffers(1, &gl->fbo_feedback);
glBindFramebuffer(RARCH_GL_FRAMEBUFFER, gl->fbo_feedback);
gl2_bind_fb(gl->fbo_feedback);
glFramebufferTexture2D(RARCH_GL_FRAMEBUFFER,
RARCH_GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
gl->fbo_feedback_texture, 0);
@ -489,23 +515,19 @@ error:
static void gl_create_fbo_texture(gl_t *gl, unsigned i, GLuint texture)
{
unsigned mip_level;
GLenum min_filter, mag_filter, wrap_enum;
GLenum mag_filter, wrap_enum;
video_shader_ctx_filter_t filter_type;
video_shader_ctx_wrap_t wrap = {0};
bool fp_fbo = false;
bool mipmapped = false;
bool smooth = false;
settings_t *settings = config_get_ptr();
GLuint base_filt = settings->bools.video_smooth ? GL_LINEAR : GL_NEAREST;
GLuint base_mip_filt = settings->bools.video_smooth ?
GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST;
unsigned mip_level = i + 2;
bool mipmapped = video_shader_driver_mipmap_input(&mip_level);
GLenum min_filter = mipmapped ? base_mip_filt : base_filt;
glBindTexture(GL_TEXTURE_2D, texture);
mip_level = i + 2;
mipmapped = video_shader_driver_mipmap_input(&mip_level);
min_filter = mipmapped ? base_mip_filt : base_filt;
filter_type.index = i + 2;
filter_type.smooth = &smooth;
@ -523,10 +545,7 @@ static void gl_create_fbo_texture(gl_t *gl, unsigned i, GLuint texture)
wrap_enum = gl_wrap_type_to_enum(wrap.type);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, mag_filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, min_filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap_enum);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap_enum);
gl_bind_texture(texture, wrap_enum, mag_filter, min_filter);
fp_fbo = gl->fbo_scale[i].fp_fbo;
@ -619,7 +638,7 @@ static void gl_create_fbo_textures(gl_t *gl)
* When width/height changes or window sizes change,
* we have to recalculate geometry of our FBO. */
void gl2_renderchain_recompute_pass_sizes(
static void gl2_renderchain_recompute_pass_sizes(
void *data,
unsigned width, unsigned height,
unsigned vp_width, unsigned vp_height)
@ -682,7 +701,8 @@ void gl2_renderchain_recompute_pass_sizes(
}
}
void gl2_renderchain_start_render(void *data, video_frame_info_t *video_info)
static void gl2_renderchain_start_render(void *data,
video_frame_info_t *video_info)
{
/* Used when rendering to an FBO.
* Texture coords have to be aligned
@ -696,7 +716,7 @@ void gl2_renderchain_start_render(void *data, video_frame_info_t *video_info)
gl_t *gl = (gl_t*)data;
glBindTexture(GL_TEXTURE_2D, gl->texture[gl->tex_index]);
glBindFramebuffer(RARCH_GL_FRAMEBUFFER, gl->fbo[0]);
gl2_bind_fb(gl->fbo[0]);
gl_set_viewport(gl,
video_info, gl->fbo_rect[0].img_width,
@ -747,7 +767,7 @@ void gl2_renderchain_init(
if (shader_info.num == 1 && !scale.valid)
return;
if (!gl_check_capability(GL_CAPS_FBO))
if (!gl->has_fbo)
{
RARCH_ERR("[GL]: Failed to locate FBO functions. Won't be able to use render-to-texture.\n");
return;
@ -822,7 +842,8 @@ void gl2_renderchain_init(
gl->fbo_inited = true;
}
bool gl2_renderchain_init_hw_render(void *data,
static bool gl2_renderchain_init_hw_render(
void *data,
unsigned width, unsigned height)
{
GLenum status;
@ -845,7 +866,7 @@ bool gl2_renderchain_init_hw_render(void *data,
RARCH_LOG("[GL]: Max texture size: %d px, renderbuffer size: %d px.\n",
max_fbo_size, max_renderbuffer_size);
if (!gl_check_capability(GL_CAPS_FBO))
if (!gl->has_fbo)
return false;
RARCH_LOG("[GL]: Supports FBO (render-to-texture).\n");
@ -864,7 +885,7 @@ bool gl2_renderchain_init_hw_render(void *data,
for (i = 0; i < gl->textures; i++)
{
glBindFramebuffer(RARCH_GL_FRAMEBUFFER, gl->hw_render_fbo[i]);
gl2_bind_fb(gl->hw_render_fbo[i]);
glFramebufferTexture2D(RARCH_GL_FRAMEBUFFER,
RARCH_GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, gl->texture[i], 0);
@ -911,16 +932,14 @@ bool gl2_renderchain_init_hw_render(void *data,
}
}
gl_bind_backbuffer();
gl2_renderchain_bind_backbuffer();
gl->hw_render_fbo_init = true;
context_bind_hw_render(false);
return true;
}
#endif
void gl_renderchain_bind_prev_texture(
static void gl2_renderchain_bind_prev_texture(
void *data,
const struct video_tex_info *tex_info)
{
@ -931,7 +950,6 @@ void gl_renderchain_bind_prev_texture(
memcpy(&gl->prev_info[0], tex_info,
sizeof(*tex_info));
#ifdef HAVE_FBO
/* Implement feedback by swapping out FBO/textures
* for FBO pass #N and feedbacks. */
if (gl->fbo_feedback_enable)
@ -943,54 +961,10 @@ void gl_renderchain_bind_prev_texture(
gl->fbo[gl->fbo_feedback_pass] = tmp_fbo;
gl->fbo_texture[gl->fbo_feedback_pass] = tmp_tex;
}
#endif
}
bool gl2_renderchain_add_lut(
const struct video_shader *shader,
unsigned i, void *textures_data)
{
struct texture_image img;
GLuint *textures_lut = (GLuint*)textures_data;
enum texture_filter_type filter_type = TEXTURE_FILTER_LINEAR;
img.width = 0;
img.height = 0;
img.pixels = NULL;
img.supports_rgba = video_driver_supports_rgba();
if (!image_texture_load(&img, shader->lut[i].path))
{
RARCH_ERR("[GL]: Failed to load texture image from: \"%s\"\n",
shader->lut[i].path);
return false;
}
RARCH_LOG("[GL]: Loaded texture image from: \"%s\" ...\n",
shader->lut[i].path);
if (shader->lut[i].filter == RARCH_FILTER_NEAREST)
filter_type = TEXTURE_FILTER_NEAREST;
if (shader->lut[i].mipmap)
{
if (filter_type == TEXTURE_FILTER_NEAREST)
filter_type = TEXTURE_FILTER_MIPMAP_NEAREST;
else
filter_type = TEXTURE_FILTER_MIPMAP_LINEAR;
}
gl_load_texture_data(textures_lut[i],
shader->lut[i].wrap,
filter_type, 4,
img.width, img.height,
img.pixels, sizeof(uint32_t));
image_texture_free(&img);
return true;
}
void gl_renderchain_viewport_info(void *data, struct video_viewport *vp)
static void gl2_renderchain_viewport_info(
void *data, struct video_viewport *vp)
{
unsigned width, height;
unsigned top_y, top_dist;
@ -1008,9 +982,9 @@ void gl_renderchain_viewport_info(void *data, struct video_viewport *vp)
vp->y = top_dist;
}
bool gl_renderchain_read_viewport(void *data, uint8_t *buffer, bool is_idle)
static bool gl2_renderchain_read_viewport(
void *data, uint8_t *buffer, bool is_idle)
{
#ifndef NO_GL_READ_PIXELS
unsigned num_pixels = 0;
gl_t *gl = (gl_t*)data;
@ -1069,10 +1043,12 @@ bool gl_renderchain_read_viewport(void *data, uint8_t *buffer, bool is_idle)
glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
}
else /* Use slow synchronous readbacks. Use this with plain screenshots
as we don't really care about performance in this case. */
else
#endif
{
/* Use slow synchronous readbacks. Use this with plain screenshots
as we don't really care about performance in this case. */
/* GLES2 only guarantees GL_RGBA/GL_UNSIGNED_BYTE
* readbacks so do just that.
* GLES2 also doesn't support reading back data
@ -1104,12 +1080,358 @@ bool gl_renderchain_read_viewport(void *data, uint8_t *buffer, bool is_idle)
error:
context_bind_hw_render(true);
#endif
return false;
}
void gl2_renderchain_free_internal(void *data)
{
gl2_renderchain_t *cg_data = (gl2_renderchain_t*)data;
if (!cg_data)
return;
free(cg_data);
}
static void *gl2_renderchain_new(void)
{
gl2_renderchain_t *renderchain = (gl2_renderchain_t*)calloc(1, sizeof(*renderchain));
if (!renderchain)
return NULL;
return renderchain;
}
#ifndef HAVE_OPENGLES
static void gl2_renderchain_bind_vao(void *data)
{
gl_t *gl = (gl_t*)data;
if (!gl)
return;
glBindVertexArray(gl->vao);
}
static void gl2_renderchain_unbind_vao(void *data)
{
gl_t *gl = (gl_t*)data;
if (!gl)
return;
glBindVertexArray(0);
}
static void gl2_renderchain_new_vao(void *data)
{
gl_t *gl = (gl_t*)data;
if (!gl)
return;
glGenVertexArrays(1, &gl->vao);
}
static void gl2_renderchain_free_vao(void *data)
{
gl_t *gl = (gl_t*)data;
if (!gl)
return;
glDeleteVertexArrays(1, &gl->vao);
}
#endif
static void gl2_renderchain_restore_default_state(void *data)
{
gl_t *gl = (gl_t*)data;
if (!gl)
return;
#ifndef HAVE_OPENGLES
if (!gl->core_context_in_use)
glEnable(GL_TEXTURE_2D);
#endif
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glDisable(GL_DITHER);
}
static void gl2_renderchain_copy_frame(
void *data,
video_frame_info_t *video_info,
const void *frame,
unsigned width, unsigned height, unsigned pitch)
{
gl_t *gl = (gl_t*)data;
#if defined(HAVE_PSGL)
{
unsigned h;
size_t buffer_addr = gl->tex_w * gl->tex_h *
gl->tex_index * gl->base_size;
size_t buffer_stride = gl->tex_w * gl->base_size;
const uint8_t *frame_copy = frame;
size_t frame_copy_size = width * gl->base_size;
uint8_t *buffer = (uint8_t*)glMapBuffer(
GL_TEXTURE_REFERENCE_BUFFER_SCE, GL_READ_WRITE) + buffer_addr;
for (h = 0; h < height; h++, buffer += buffer_stride, frame_copy += pitch)
memcpy(buffer, frame_copy, frame_copy_size);
glUnmapBuffer(GL_TEXTURE_REFERENCE_BUFFER_SCE);
}
#elif defined(HAVE_OPENGLES)
#if defined(HAVE_EGL)
if (gl->egl_images)
{
gfx_ctx_image_t img_info;
bool new_egl = false;
EGLImageKHR img = 0;
img_info.frame = frame;
img_info.width = width;
img_info.height = height;
img_info.pitch = pitch;
img_info.index = gl->tex_index;
img_info.rgb32 = (gl->base_size == 4);
img_info.handle = &img;
new_egl =
video_context_driver_write_to_image_buffer(&img_info);
if (img == EGL_NO_IMAGE_KHR)
{
RARCH_ERR("[GL]: Failed to create EGL image.\n");
return;
}
if (new_egl)
glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)img);
}
else
#endif
{
glPixelStorei(GL_UNPACK_ALIGNMENT,
video_pixel_get_alignment(width * gl->base_size));
/* Fallback for GLES devices without GL_BGRA_EXT. */
if (gl->base_size == 4 && video_info->use_rgba)
{
video_frame_convert_argb8888_to_abgr8888(
&gl->scaler,
gl->conv_buffer,
frame, width, height, pitch);
glTexSubImage2D(GL_TEXTURE_2D,
0, 0, 0, width, height, gl->texture_type,
gl->texture_fmt, gl->conv_buffer);
}
else if (gl->support_unpack_row_length)
{
glPixelStorei(GL_UNPACK_ROW_LENGTH, pitch / gl->base_size);
glTexSubImage2D(GL_TEXTURE_2D,
0, 0, 0, width, height, gl->texture_type,
gl->texture_fmt, frame);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
}
else
{
/* No GL_UNPACK_ROW_LENGTH. */
const GLvoid *data_buf = frame;
unsigned pitch_width = pitch / gl->base_size;
if (width != pitch_width)
{
/* Slow path - conv_buffer is preallocated
* just in case we hit this path. */
unsigned h;
const unsigned line_bytes = width * gl->base_size;
uint8_t *dst = (uint8_t*)gl->conv_buffer;
const uint8_t *src = (const uint8_t*)frame;
for (h = 0; h < height; h++, src += pitch, dst += line_bytes)
memcpy(dst, src, line_bytes);
data_buf = gl->conv_buffer;
}
glTexSubImage2D(GL_TEXTURE_2D,
0, 0, 0, width, height, gl->texture_type,
gl->texture_fmt, data_buf);
}
}
#else
{
const GLvoid *data_buf = frame;
glPixelStorei(GL_UNPACK_ALIGNMENT, video_pixel_get_alignment(pitch));
if (gl->base_size == 2 && !gl->have_es2_compat)
{
/* Convert to 32-bit textures on desktop GL.
*
* It is *much* faster (order of magnitude on my setup)
* to use a custom SIMD-optimized conversion routine
* than letting GL do it. */
video_frame_convert_rgb16_to_rgb32(
&gl->scaler,
gl->conv_buffer,
frame,
width,
height,
pitch);
data_buf = gl->conv_buffer;
}
else
glPixelStorei(GL_UNPACK_ROW_LENGTH, pitch / gl->base_size);
glTexSubImage2D(GL_TEXTURE_2D,
0, 0, 0, width, height, gl->texture_type,
gl->texture_fmt, data_buf);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
}
#endif
}
#if !defined(HAVE_OPENGLES2) && !defined(HAVE_PSGL)
static void gl2_renderchain_bind_pbo(unsigned idx)
{
glBindBuffer(GL_PIXEL_PACK_BUFFER, (GLuint)idx);
}
static void gl2_renderchain_unbind_pbo(void)
{
glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
}
static void gl2_renderchain_init_pbo(unsigned size,
const void *data)
{
glBufferData(GL_PIXEL_PACK_BUFFER, size,
(const GLvoid*)data, GL_STREAM_READ);
}
#endif
static void gl2_renderchain_readback(void *data,
unsigned alignment,
unsigned fmt, unsigned type,
void *src)
{
gl_t *gl = (gl_t*)data;
glPixelStorei(GL_PACK_ALIGNMENT, alignment);
#ifndef HAVE_OPENGLES
glPixelStorei(GL_PACK_ROW_LENGTH, 0);
glReadBuffer(GL_BACK);
#endif
glReadPixels(gl->vp.x, gl->vp.y,
gl->vp.width, gl->vp.height,
(GLenum)fmt, (GLenum)type, (GLvoid*)src);
}
#ifndef HAVE_OPENGLES
static void gl2_renderchain_fence_iterate(void *data, unsigned
hard_sync_frames)
{
gl_t *gl = (gl_t*)data;
gl->fences[gl->fence_count++] =
glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0);
while (gl->fence_count > hard_sync_frames)
{
glClientWaitSync(gl->fences[0],
GL_SYNC_FLUSH_COMMANDS_BIT, 1000000000);
glDeleteSync(gl->fences[0]);
gl->fence_count--;
memmove(gl->fences, gl->fences + 1,
gl->fence_count * sizeof(GLsync));
}
}
static void gl2_renderchain_fence_free(void *data)
{
unsigned i;
gl_t *gl = (gl_t*)data;
for (i = 0; i < gl->fence_count; i++)
{
glClientWaitSync(gl->fences[i],
GL_SYNC_FLUSH_COMMANDS_BIT, 1000000000);
glDeleteSync(gl->fences[i]);
}
gl->fence_count = 0;
}
#endif
static void gl2_renderchain_init_textures_reference(
void *data, unsigned i,
unsigned internal_fmt, unsigned texture_fmt,
unsigned texture_type)
{
gl_t *gl = (gl_t*)data;
#ifdef HAVE_PSGL
glTextureReferenceSCE(GL_TEXTURE_2D, 1,
gl->tex_w, gl->tex_h, 0,
(GLenum)internal_fmt,
gl->tex_w * gl->base_size,
gl->tex_w * gl->tex_h * i * gl->base_size);
#else
if (gl->egl_images)
return;
gl_load_texture_image(GL_TEXTURE_2D,
0,
(GLenum)internal_fmt,
gl->tex_w, gl->tex_h, 0,
(GLenum)texture_type,
(GLenum)texture_fmt,
gl->empty_buf ? gl->empty_buf : NULL);
#endif
}
gl_renderchain_driver_t gl2_renderchain = {
NULL, /* set_coords */
NULL, /* set_mvp */
gl2_renderchain_init_textures_reference,
#ifdef HAVE_OPENGLES
NULL,
NULL,
#else
gl2_renderchain_fence_iterate,
gl2_renderchain_fence_free,
#endif
gl2_renderchain_readback,
#if !defined(HAVE_OPENGLES2) && !defined(HAVE_PSGL)
gl2_renderchain_init_pbo,
gl2_renderchain_bind_pbo,
gl2_renderchain_unbind_pbo,
#else
NULL,
NULL,
NULL,
#endif
gl2_renderchain_copy_frame,
gl2_renderchain_restore_default_state,
#ifdef HAVE_OPENGLES
NULL,
NULL,
NULL,
NULL,
#else
gl2_renderchain_new_vao,
gl2_renderchain_free_vao,
gl2_renderchain_bind_vao,
gl2_renderchain_unbind_vao,
#endif
NULL,
NULL,
NULL,
gl2_renderchain_bind_backbuffer,
gl2_renderchain_deinit_fbo,
gl2_renderchain_viewport_info,
gl2_renderchain_read_viewport,
gl2_renderchain_bind_prev_texture,
gl2_renderchain_free_internal,
gl2_renderchain_new,
gl2_renderchain_init,
gl2_renderchain_init_hw_render,
gl2_renderchain_free,

89
gfx/drivers_renderchain/gl2_renderchain.h
View File

@ -1,89 +0,0 @@
/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
* Copyright (C) 2011-2017 - Daniel De Matteis
*
* RetroArch 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 Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* RetroArch 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 RetroArch.
* If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __GL2_RENDER_CHAIN_H
#define __GL2_RENDER_CHAIN_H
#include <retro_common_api.h>
#include <libretro.h>
#include "../video_driver.h"
#include "../video_shader_parse.h"
RETRO_BEGIN_DECLS
void gl2_renderchain_convert_geometry(
void *data,
struct video_fbo_rect *fbo_rect,
struct gfx_fbo_scale *fbo_scale,
unsigned last_width, unsigned last_max_width,
unsigned last_height, unsigned last_max_height,
unsigned vp_width, unsigned vp_height);
void gl_renderchain_bind_prev_texture(
void *data,
const struct video_tex_info *tex_info);
bool gl2_renderchain_add_lut(const struct video_shader *shader,
unsigned i, void *textures_lut);
void gl_load_texture_data(
uint32_t id_data,
enum gfx_wrap_type wrap_type,
enum texture_filter_type filter_type,
unsigned alignment,
unsigned width, unsigned height,
const void *frame, unsigned base_size);
void gl2_renderchain_render(void *data,
video_frame_info_t *video_info,
uint64_t frame_count,
const struct video_tex_info *tex_info,
const struct video_tex_info *feedback_info);
void gl2_renderchain_init(
void *data, unsigned fbo_width, unsigned fbo_height);
void gl2_renderchain_deinit_hw_render(void *data);
void gl2_renderchain_recompute_pass_sizes(void *data,
unsigned width, unsigned height,
unsigned vp_width, unsigned vp_height);
void gl2_renderchain_deinit_fbo(void *data);
void gl2_renderchain_start_render(void *data,
video_frame_info_t *video_info);
void gl2_renderchain_check_fbo_dimensions(void *data);
void gl2_renderchain_free(void *data);
bool gl2_renderchain_init_hw_render(void *data,
unsigned width, unsigned height);
void gl_renderchain_viewport_info(
void *data, struct video_viewport *vp);
bool gl_renderchain_read_viewport(
void *data, uint8_t *buffer, bool is_idle);
void context_bind_hw_render(bool enable);
RETRO_END_DECLS
#endif

3
gfx/drivers_renderchain/null_renderchain.c
View File

@ -118,7 +118,8 @@ static void null_renderchain_convert_geometry(
(void)final_viewport_data;
}
d3d_renderchain_driver_t null_renderchain = {
d3d_renderchain_driver_t null_d3d_renderchain = {
NULL,
null_renderchain_free,
null_renderchain_new,
NULL,

106
gfx/drivers_shader/shader_gl_cg.c
View File

@ -110,12 +110,8 @@ typedef struct cg_shader_data
struct video_shader *shader;
char alias_define[GFX_MAX_SHADERS][128];
unsigned active_idx;
struct
{
CGparameter elems[32 * PREV_TEXTURES + 2 + 4 + GFX_MAX_SHADERS];
unsigned index;
} attribs;
unsigned attribs_index;
CGparameter attribs_elems[32 * PREV_TEXTURES + 2 + 4 + GFX_MAX_SHADERS];
CGprofile cgVProf;
CGprofile cgFProf;
struct shader_program_cg prg[GFX_MAX_SHADERS];
@ -133,7 +129,7 @@ struct uniform_cg
{ \
cgGLSetParameterPointer(param, len, GL_FLOAT, 0, ptr); \
cgGLEnableClientState(param); \
cg->attribs.elems[cg->attribs.index++] = param; \
cg->attribs_elems[cg->attribs_index++] = param; \
}
#define cg_gl_set_texture_parameter(param, texture) \
@ -250,24 +246,25 @@ static void gl_cg_reset_attrib(void *data)
cg_shader_data_t *cg = (cg_shader_data_t*)data;
/* Add sanity check that we did not overflow. */
retro_assert(cg->attribs.index <= ARRAY_SIZE(cg->attribs.elems));
retro_assert(cg->attribs_index <= ARRAY_SIZE(cg->attribs_elems));
for (i = 0; i < cg->attribs.index; i++)
cgGLDisableClientState(cg->attribs.elems[i]);
cg->attribs.index = 0;
for (i = 0; i < cg->attribs_index; i++)
cgGLDisableClientState(cg->attribs_elems[i]);
cg->attribs_index = 0;
}
static bool gl_cg_set_mvp(void *data, void *shader_data, const math_matrix_4x4 *mat)
static bool gl_cg_set_mvp(void *data, void *shader_data,
const void *mat_data)
{
cg_shader_data_t *cg = (cg_shader_data_t*)shader_data;
if (!cg || !cg->prg[cg->active_idx].mvp)
if (cg && cg->prg[cg->active_idx].mvp)
{
gl_ff_matrix(mat);
return false;
const math_matrix_4x4 *mat = (const math_matrix_4x4*)mat_data;
cgGLSetMatrixParameterfc(cg->prg[cg->active_idx].mvp, mat->data);
return true;
}
cgGLSetMatrixParameterfc(cg->prg[cg->active_idx].mvp, mat->data);
return true;
return false;
}
static bool gl_cg_set_coords(void *handle_data, void *shader_data, const struct video_coords *coords)
@ -296,12 +293,6 @@ static bool gl_cg_set_coords(void *handle_data, void *shader_data, const struct
return true;
}
static bool gl_cg_set_coords_fallback(void *handle_data, void *shader_data, const struct video_coords *coords)
{
gl_ff_vertex(coords);
return true;
}
static void gl_cg_set_texture_info(
cg_shader_data_t *cg,
const struct cg_fbo_params *params,
@ -781,6 +772,72 @@ static bool gl_cg_load_shader(void *data, unsigned i)
return true;
}
static bool gl_cg_add_lut(
const struct video_shader *shader,
unsigned i, void *textures_data)
{
struct texture_image img;
GLuint *textures_lut = (GLuint*)textures_data;
enum texture_filter_type filter_type = TEXTURE_FILTER_LINEAR;
img.width = 0;
img.height = 0;
img.pixels = NULL;
img.supports_rgba = video_driver_supports_rgba();
if (!image_texture_load(&img, shader->lut[i].path))
{
RARCH_ERR("[GL]: Failed to load texture image from: \"%s\"\n",
shader->lut[i].path);
return false;
}
RARCH_LOG("[GL]: Loaded texture image from: \"%s\" ...\n",
shader->lut[i].path);
if (shader->lut[i].filter == RARCH_FILTER_NEAREST)
filter_type = TEXTURE_FILTER_NEAREST;
if (shader->lut[i].mipmap)
{
if (filter_type == TEXTURE_FILTER_NEAREST)
filter_type = TEXTURE_FILTER_MIPMAP_NEAREST;
else
filter_type = TEXTURE_FILTER_MIPMAP_LINEAR;
}
gl_load_texture_data(textures_lut[i],
shader->lut[i].wrap,
filter_type, 4,
img.width, img.height,
img.pixels, sizeof(uint32_t));
image_texture_free(&img);
return true;
}
static bool gl_cg_load_luts(
const struct video_shader *shader,
GLuint *textures_lut)
{
unsigned i;
unsigned num_luts = MIN(shader->luts, GFX_MAX_TEXTURES);
if (!shader->luts)
return true;
glGenTextures(num_luts, textures_lut);
for (i = 0; i < num_luts; i++)
{
if (!gl_cg_add_lut(shader, i, textures_lut))
return false;
}
glBindTexture(GL_TEXTURE_2D, 0);
return true;
}
static bool gl_cg_load_preset(void *data, const char *path)
{
unsigned i;
@ -841,7 +898,7 @@ static bool gl_cg_load_preset(void *data, const char *path)
}
}
if (!gl_load_luts(cg->shader, cg->lut_textures))
if (!gl_cg_load_luts(cg->shader, cg->lut_textures))
{
RARCH_ERR("Failed to load lookup textures ...\n");
return false;
@ -1233,7 +1290,6 @@ const shader_backend_t gl_cg_backend = {
gl_cg_wrap_type,
gl_cg_shader_scale,
gl_cg_set_coords,
gl_cg_set_coords_fallback,
gl_cg_set_mvp,
gl_cg_get_prev_textures,
gl_cg_get_feedback_pass,

144
gfx/drivers_shader/shader_glsl.c
View File

@ -43,12 +43,11 @@
struct cache_vbo
{
GLuint vbo_primary;
GLfloat *buffer_primary;
size_t size_primary;
GLuint vbo_secondary;
GLfloat *buffer_secondary;
size_t size_primary;
size_t size_secondary;
GLfloat *buffer_primary;
GLfloat *buffer_secondary;
};
struct shader_program_glsl_data
@ -89,10 +88,10 @@ struct shader_uniforms
int texture_size;
int frame_count;
unsigned frame_count_mod;
int frame_direction;
int lut_texture[GFX_MAX_TEXTURES];
unsigned frame_count_mod;
struct shader_uniforms_frame orig;
struct shader_uniforms_frame feedback;
@ -134,28 +133,90 @@ static const char *glsl_prefixes[] = {
typedef struct glsl_shader_data
{
struct video_shader *shader;
char alias_define[1024];
GLint attribs_elems[32 * PREV_TEXTURES + 2 + 4 + GFX_MAX_SHADERS];
unsigned attribs_index;
unsigned active_idx;
unsigned current_idx;
GLuint lut_textures[GFX_MAX_TEXTURES];
float current_mat_data[GFX_MAX_SHADERS];
float* current_mat_data_pointer[GFX_MAX_SHADERS];
struct shader_uniforms uniforms[GFX_MAX_SHADERS];
struct cache_vbo vbo[GFX_MAX_SHADERS];
char alias_define[1024];
unsigned active_idx;
struct
{
GLint elems[32 * PREV_TEXTURES + 2 + 4 + GFX_MAX_SHADERS];
unsigned index;
} attribs;
struct shader_program_glsl_data prg[GFX_MAX_SHADERS];
GLuint lut_textures[GFX_MAX_TEXTURES];
struct video_shader *shader;
state_tracker_t *state_tracker;
} glsl_shader_data_t;
static bool glsl_core;
static unsigned glsl_major;
static unsigned glsl_minor;
static float* current_mat_data_pointer[GFX_MAX_SHADERS];
static float current_mat_data[GFX_MAX_SHADERS];
static unsigned current_idx;
static bool gl_glsl_add_lut(
const struct video_shader *shader,
unsigned i, void *textures_data)
{
struct texture_image img;
GLuint *textures_lut = (GLuint*)textures_data;
enum texture_filter_type filter_type = TEXTURE_FILTER_LINEAR;
img.width = 0;
img.height = 0;
img.pixels = NULL;
img.supports_rgba = video_driver_supports_rgba();
if (!image_texture_load(&img, shader->lut[i].path))
{
RARCH_ERR("[GL]: Failed to load texture image from: \"%s\"\n",
shader->lut[i].path);
return false;
}
RARCH_LOG("[GL]: Loaded texture image from: \"%s\" ...\n",
shader->lut[i].path);
if (shader->lut[i].filter == RARCH_FILTER_NEAREST)
filter_type = TEXTURE_FILTER_NEAREST;
if (shader->lut[i].mipmap)
{
if (filter_type == TEXTURE_FILTER_NEAREST)
filter_type = TEXTURE_FILTER_MIPMAP_NEAREST;
else
filter_type = TEXTURE_FILTER_MIPMAP_LINEAR;
}
gl_load_texture_data(textures_lut[i],
shader->lut[i].wrap,
filter_type, 4,
img.width, img.height,
img.pixels, sizeof(uint32_t));
image_texture_free(&img);
return true;
}
static bool gl_glsl_load_luts(
const struct video_shader *shader,
GLuint *textures_lut)
{
unsigned i;
unsigned num_luts = MIN(shader->luts, GFX_MAX_TEXTURES);
if (!shader->luts)
return true;
glGenTextures(num_luts, textures_lut);
for (i = 0; i < num_luts; i++)
{
if (!gl_glsl_add_lut(shader, i, textures_lut))
return false;
}
glBindTexture(GL_TEXTURE_2D, 0);
return true;
}
static GLint gl_glsl_get_uniform(glsl_shader_data_t *glsl,
GLuint prog, const char *base)
@ -497,11 +558,11 @@ static void gl_glsl_reset_attrib(glsl_shader_data_t *glsl)
unsigned i;
/* Add sanity check that we did not overflow. */
retro_assert(glsl->attribs.index <= ARRAY_SIZE(glsl->attribs.elems));
retro_assert(glsl->attribs_index <= ARRAY_SIZE(glsl->attribs_elems));
for (i = 0; i < glsl->attribs.index; i++)
glDisableVertexAttribArray(glsl->attribs.elems[i]);
glsl->attribs.index = 0;
for (i = 0; i < glsl->attribs_index; i++)
glDisableVertexAttribArray(glsl->attribs_elems[i]);
glsl->attribs_index = 0;
}
static void gl_glsl_set_vbo(GLfloat **buffer, size_t *buffer_elems,
@ -537,14 +598,14 @@ static INLINE void gl_glsl_set_attribs(glsl_shader_data_t *glsl,
for (i = 0; i < num_attrs; i++)
{
if (glsl->attribs.index < ARRAY_SIZE(glsl->attribs.elems))
if (glsl->attribs_index < ARRAY_SIZE(glsl->attribs_elems))
{
GLint loc = attrs[i].loc;
glEnableVertexAttribArray(loc);
glVertexAttribPointer(loc, attrs[i].size, GL_FLOAT, GL_FALSE, 0,
(const GLvoid*)(uintptr_t)attrs[i].offset);
glsl->attribs.elems[glsl->attribs.index++] = loc;
glsl->attribs_elems[glsl->attribs_index++] = loc;
}
else
RARCH_WARN("Attrib array buffer was overflown!\n");
@ -674,8 +735,10 @@ static void gl_glsl_destroy_resources(glsl_shader_data_t *glsl)
if (!glsl)
return;
current_idx = 0;
glsl->current_idx = 0;
glUseProgram(0);
for (i = 0; i < GFX_MAX_SHADERS; i++)
{
if (glsl->prg[i].id == 0 || (i && glsl->prg[i].id == glsl->prg[0].id))
@ -876,7 +939,7 @@ static void *gl_glsl_init(void *data, const char *path)
if (!gl_glsl_compile_programs(glsl, &glsl->prg[1]))
goto error;
if (!gl_load_luts(glsl->shader, glsl->lut_textures))
if (!gl_glsl_load_luts(glsl->shader, glsl->lut_textures))
{
RARCH_ERR("[GL]: Failed to load LUTs.\n");
goto error;
@ -1371,30 +1434,29 @@ static void gl_glsl_set_params(void *data, void *shader_data,
}
}
static bool gl_glsl_set_mvp(void *data, void *shader_data, const math_matrix_4x4 *mat)
static bool gl_glsl_set_mvp(void *data, void *shader_data, const void *mat_data)
{
int loc;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)shader_data;
glsl_shader_data_t *glsl = (glsl_shader_data_t*)shader_data;
(void)data;
if (!glsl || !glsl->shader->modern)
{
gl_ff_matrix(mat);
return false;
}
loc = glsl->uniforms[glsl->active_idx].mvp;
if (loc >= 0)
{
if ( (current_idx != glsl->active_idx) ||
(mat->data != current_mat_data_pointer[glsl->active_idx]) ||
(*mat->data != current_mat_data[glsl->active_idx]))
const math_matrix_4x4 *mat = (const math_matrix_4x4*)mat_data;
if ( (glsl->current_idx != glsl->active_idx) ||
(mat->data != glsl->current_mat_data_pointer[glsl->active_idx]) ||
(*mat->data != glsl->current_mat_data[glsl->active_idx]))
{
glUniformMatrix4fv(loc, 1, GL_FALSE, mat->data);
current_idx = glsl->active_idx;
current_mat_data_pointer[glsl->active_idx] = (float*)mat->data;
current_mat_data[glsl->active_idx] = *mat->data;
glsl->current_idx = glsl->active_idx;
glsl->current_mat_data_pointer[glsl->active_idx] = (float*)mat->data;
glsl->current_mat_data[glsl->active_idx] = *mat->data;
}
}
@ -1489,13 +1551,6 @@ static bool gl_glsl_set_coords(void *handle_data, void *shader_data,
return true;
}
static bool gl_glsl_set_coords_fallback(void *handle_data, void *shader_data,
const struct video_coords *coords)
{
gl_ff_vertex(coords);
return true;
}
static void gl_glsl_use(void *data, void *shader_data, unsigned idx, bool set_active)
{
GLuint id;
@ -1622,7 +1677,6 @@ const shader_backend_t gl_glsl_backend = {
gl_glsl_wrap_type,
gl_glsl_shader_scale,
gl_glsl_set_coords,
gl_glsl_set_coords_fallback,
gl_glsl_set_mvp,
gl_glsl_get_prev_textures,
gl_glsl_get_feedback_pass,

4
gfx/drivers_shader/shader_hlsl.cpp → gfx/drivers_shader/shader_hlsl.c
View File

@ -497,11 +497,12 @@ static void hlsl_shader_scale(void *data, unsigned idx, struct gfx_fbo_scale *sc
scale->valid = false;
}
static bool hlsl_set_mvp(void *data, void *shader_data, const math_matrix_4x4 *mat)
static bool hlsl_set_mvp(void *data, void *shader_data, const void *mat_data)
{
d3d_video_t *d3d = (d3d_video_t*)data;
LPDIRECT3DDEVICE d3dr = (LPDIRECT3DDEVICE)d3d->dev;
hlsl_shader_data_t *hlsl_data = (hlsl_shader_data_t*)shader_data;
const math_matrix_4x4 *mat = (const math_matrix_4x4*)mat_data;
if(hlsl_data && hlsl_data->prg[hlsl_data->active_idx].mvp)
{
@ -542,7 +543,6 @@ const shader_backend_t hlsl_backend = {
NULL, /* hlsl_wrap_type */
hlsl_shader_scale,
NULL, /* hlsl_set_coords */
NULL, /* hlsl_set_coords_fallback */
hlsl_set_mvp,
NULL, /* hlsl_get_prev_textures */
hlsl_get_feedback_pass,

1
gfx/drivers_shader/shader_null.c
View File

@ -88,7 +88,6 @@ const shader_backend_t shader_null_backend = {
NULL,
NULL,
NULL,
NULL,
shader_null_get_prev_textures,
NULL,
NULL,

6
gfx/font_driver.c
View File

@ -452,13 +452,15 @@ void font_driver_bind_block(void *font_data, void *block)
font->renderer->bind_block(font->renderer_data, block);
}
void font_driver_flush(unsigned width, unsigned height, void *font_data)
void font_driver_flush(unsigned width, unsigned height, void *font_data,
video_frame_info_t *video_info)
{
font_data_t *font = (font_data_t*)(font_data ? font_data : video_font_driver);
if (font && font->renderer && font->renderer->flush)
font->renderer->flush(width, height, font->renderer_data);
font->renderer->flush(width, height, font->renderer_data, video_info);
}
int font_driver_get_message_width(void *font_data,
const char *msg, unsigned len, float scale)
{

6
gfx/font_driver.h
View File

@ -113,7 +113,8 @@ typedef struct font_renderer
const struct font_glyph *(*get_glyph)(void *data, uint32_t code);
void (*bind_block)(void *data, void *block);
void (*flush)(unsigned width, unsigned height, void *data);
void (*flush)(unsigned width, unsigned height, void *data,
video_frame_info_t *video_info);
int (*get_message_width)(void *data, const char *msg, unsigned msg_len_full, float scale);
} font_renderer_t;
@ -154,7 +155,8 @@ void font_driver_bind_block(void *font_data, void *block);
int font_driver_get_message_width(void *font_data, const char *msg, unsigned len, float scale);
void font_driver_flush(unsigned width, unsigned height, void *font_data);
void font_driver_flush(unsigned width, unsigned height, void *font_data,
video_frame_info_t *video_info);
void font_driver_free(void *font_data);

189
gfx/video_driver.c
View File

@ -127,7 +127,7 @@ typedef struct video_pixel_scaler
static void (*video_driver_cb_shader_use)(void *data,
void *shader_data, unsigned index, bool set_active);
static bool (*video_driver_cb_shader_set_mvp)(void *data,
void *shader_data, const math_matrix_4x4 *mat);
void *shader_data, const void *mat_data);
bool (*video_driver_cb_has_focus)(void);
/* Opaque handles to currently running window.
@ -407,7 +407,7 @@ static const shader_backend_t *shader_ctx_drivers[] = {
NULL
};
static const d3d_renderchain_driver_t *renderchain_drivers[] = {
static const d3d_renderchain_driver_t *renderchain_d3d_drivers[] = {
#if defined(_WIN32) && defined(HAVE_D3D9) && defined(HAVE_CG)
&cg_d3d9_renderchain,
#endif
@ -417,7 +417,14 @@ static const d3d_renderchain_driver_t *renderchain_drivers[] = {
#if defined(_WIN32) && defined(HAVE_D3D8)
&d3d8_renderchain,
#endif
&null_renderchain,
&null_d3d_renderchain,
NULL
};
static const gl_renderchain_driver_t *renderchain_gl_drivers[] = {
#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES)
&gl2_renderchain,
#endif
NULL
};
@ -1789,21 +1796,21 @@ bool video_driver_find_driver(void)
current_video = NULL;
#if defined(HAVE_VULKAN)
if (hwr && hw_render_context_is_vulkan(hwr->context_type))
{
#if defined(HAVE_VULKAN)
RARCH_LOG("[Video]: Using HW render, Vulkan driver forced.\n");
current_video = &video_vulkan;
#endif
}
#endif
#if defined(HAVE_OPENGL)
if (hwr && hw_render_context_is_gl(hwr->context_type))
{
#if defined(HAVE_OPENGL) && defined(HAVE_FBO)
RARCH_LOG("[Video]: Using HW render, OpenGL driver forced.\n");
current_video = &video_gl;
#endif
}
#endif
if (current_video)
return true;
@ -2380,9 +2387,18 @@ void video_driver_frame(const void *data, unsigned width,
video_driver_msg[0] = '\0';
if ( video_info.font_enable
&& runloop_msg_queue_pull((const char**)&msg)
&& runloop_msg_queue_pull((const char**)&msg)
&& msg)
{
#ifdef HAVE_THREADS
/* the msg pointer may point to data modified by another thread */
runloop_msg_queue_lock();
#endif
strlcpy(video_driver_msg, msg, sizeof(video_driver_msg));
#ifdef HAVE_THREADS
runloop_msg_queue_unlock();
#endif
}
video_driver_active = current_video->frame(
video_driver_data, data, width, height,
@ -2391,8 +2407,9 @@ void video_driver_frame(const void *data, unsigned width,
video_driver_frame_count++;
// Display the FPS, with a higher priority.
if (video_info.fps_show)
runloop_msg_queue_push(video_info.fps_text, 1, 1, false);
runloop_msg_queue_push(video_info.fps_text, 2, 1, true);
}
void video_driver_display_type_set(enum rarch_display_type type)
@ -2457,6 +2474,17 @@ static void video_shader_driver_use_null(void *data,
(void)set_active;
}
static bool video_driver_cb_set_coords(void *handle_data,
void *shader_data, const struct video_coords *coords)
{
video_shader_ctx_coords_t ctx_coords;
ctx_coords.handle_data = handle_data;
ctx_coords.data = coords;
video_driver_set_coords(&ctx_coords);
return true;
}
void video_driver_build_info(video_frame_info_t *video_info)
{
bool is_perfcnt_enable = false;
@ -2563,7 +2591,11 @@ void video_driver_build_info(video_frame_info_t *video_info)
video_info->cb_set_resize = current_video_context.set_resize;
video_info->cb_shader_use = video_driver_cb_shader_use;
video_info->cb_shader_set_mvp = video_driver_cb_shader_set_mvp;
video_info->cb_set_mvp = video_driver_cb_shader_set_mvp;
#if 0
video_info->cb_set_coords = video_driver_cb_set_coords;
#endif
#ifdef HAVE_THREADS
video_driver_threaded_unlock(is_threaded);
@ -3179,39 +3211,16 @@ static enum gfx_wrap_type video_shader_driver_wrap_type_null(
return RARCH_WRAP_BORDER;
}
static bool video_shader_driver_set_mvp_null(void *data,
void *shader_data, const math_matrix_4x4 *mat)
static bool video_driver_cb_set_mvp(void *data,
void *shader_data, const void *mat_data)
{
return false;
}
video_shader_ctx_mvp_t mvp;
mvp.data = data;
mvp.matrix = mat_data;
#ifdef HAVE_OPENGL
#ifndef NO_GL_FF_MATRIX
static bool video_shader_driver_set_mvp_null_gl(void *data,
void *shader_data, const math_matrix_4x4 *mat)
{
gl_ff_matrix(mat);
return false;
video_driver_set_mvp(&mvp);
return true;
}
#endif
#endif
static bool video_shader_driver_set_coords_null(void *handle_data,
void *shader_data, const struct video_coords *coords)
{
return false;
}
#ifdef HAVE_OPENGL
#ifndef NO_GL_FF_VERTEX
static bool video_shader_driver_set_coords_null_gl(void *handle_data,
void *shader_data, const struct video_coords *coords)
{
gl_ff_vertex(coords);
return false;
}
#endif
#endif
static struct video_shader *video_shader_driver_get_current_shader_null(void *data)
{
@ -3270,32 +3279,12 @@ static void video_shader_driver_reset_to_defaults(void)
video_driver_cb_shader_set_mvp = current_shader->set_mvp;
else
{
#ifdef HAVE_OPENGL
#ifndef NO_GL_FF_MATRIX
if (string_is_equal_fast(video_driver_get_ident(), "gl", 2))
{
current_shader->set_mvp = video_shader_driver_set_mvp_null_gl;
video_driver_cb_shader_set_mvp = video_shader_driver_set_mvp_null_gl;
}
else
#endif
#endif
{
current_shader->set_mvp = video_shader_driver_set_mvp_null;
video_driver_cb_shader_set_mvp = video_shader_driver_set_mvp_null;
}
current_shader->set_mvp = video_driver_cb_set_mvp;
video_driver_cb_shader_set_mvp = video_driver_cb_set_mvp;
}
if (!current_shader->set_coords)
{
#ifdef HAVE_OPENGL
#ifndef NO_GL_FF_VERTEX
if (string_is_equal_fast(video_driver_get_ident(), "gl", 2))
current_shader->set_coords = video_shader_driver_set_coords_null_gl;
else
#endif
#endif
current_shader->set_coords = video_shader_driver_set_coords_null;
}
current_shader->set_coords = video_driver_cb_set_coords;
if (current_shader->use)
video_driver_cb_shader_use = current_shader->use;
else
@ -3384,14 +3373,19 @@ bool video_shader_driver_info(video_shader_ctx_info_t *shader_info)
bool video_shader_driver_filter_type(video_shader_ctx_filter_t *filter)
{
return (filter) ? current_shader->filter_type(shader_data,
filter->index, filter->smooth) : false;
if (filter)
return current_shader->filter_type(shader_data,
filter->index, filter->smooth);
return false;
}
bool video_shader_driver_compile_program(struct shader_program_info *program_info)
bool video_shader_driver_compile_program(
struct shader_program_info *program_info)
{
return (program_info) ? current_shader->compile_program(program_info->data,
program_info->idx, NULL, program_info) : false;
if (program_info)
return current_shader->compile_program(program_info->data,
program_info->idx, NULL, program_info);
return false;
}
bool video_shader_driver_wrap_type(video_shader_ctx_wrap_t *wrap)
@ -3400,19 +3394,66 @@ bool video_shader_driver_wrap_type(video_shader_ctx_wrap_t *wrap)
return true;
}
bool renderchain_d3d_init_first(const d3d_renderchain_driver_t **renderchain_driver,
void **renderchain_handle)
void video_driver_set_coords(video_shader_ctx_coords_t *coords)
{
if (current_shader && current_shader->set_coords)
current_shader->set_coords(coords->handle_data, shader_data, (const struct video_coords*)coords->data);
else
{
if (video_driver_poke && video_driver_poke->set_coords)
video_driver_poke->set_coords(coords->handle_data, shader_data, (const struct video_coords*)coords->data);
}
}
void video_driver_set_mvp(video_shader_ctx_mvp_t *mvp)
{
if (!mvp || !mvp->matrix)
return;
if (current_shader && current_shader->set_mvp)
current_shader->set_mvp(mvp->data, shader_data, mvp->matrix);
else
{
if (video_driver_poke && video_driver_poke->set_mvp)
video_driver_poke->set_mvp(mvp->data, shader_data, mvp->matrix);
}
}
bool renderchain_d3d_init_first(
const d3d_renderchain_driver_t **renderchain_driver,
void **renderchain_handle)
{
unsigned i;
for (i = 0; renderchain_drivers[i]; i++)
for (i = 0; renderchain_d3d_drivers[i]; i++)
{
void *data = renderchain_drivers[i]->chain_new();
void *data = renderchain_d3d_drivers[i]->chain_new();
if (!data)
continue;
*renderchain_driver = renderchain_drivers[i];
*renderchain_driver = renderchain_d3d_drivers[i];
*renderchain_handle = data;
return true;
}
return false;
}
bool renderchain_gl_init_first(
const gl_renderchain_driver_t **renderchain_driver,
void **renderchain_handle)
{
unsigned i;
for (i = 0; renderchain_gl_drivers[i]; i++)
{
void *data = renderchain_gl_drivers[i]->chain_new();
if (!data)
continue;
*renderchain_driver = renderchain_gl_drivers[i];
*renderchain_handle = data;
return true;
}

78
gfx/video_driver.h
View File

@ -233,10 +233,8 @@ typedef struct shader_backend
unsigned index, struct gfx_fbo_scale *scale);
bool (*set_coords)(void *handle_data,
void *shader_data, const struct video_coords *coords);
bool (*set_coords_fallback)(void *handle_data,
void *shader_data, const struct video_coords *coords);
bool (*set_mvp)(void *data, void *shader_data,
const math_matrix_4x4 *mat);
const void *mat_data);
unsigned (*get_prev_textures)(void *data);
bool (*get_feedback_pass)(void *data, unsigned *pass);
bool (*mipmap_input)(void *data, unsigned index);
@ -301,7 +299,7 @@ typedef struct video_shader_ctx_info
typedef struct video_shader_ctx_mvp
{
void *data;
const math_matrix_4x4 *matrix;
const void *matrix;
} video_shader_ctx_mvp_t;
typedef struct video_shader_ctx_filter
@ -468,8 +466,12 @@ typedef struct video_frame_info
bool (*cb_set_resize)(void*, unsigned, unsigned);
void (*cb_shader_use)(void *data, void *shader_data, unsigned index, bool set_active);
bool (*cb_shader_set_mvp)(void *data, void *shader_data,
const math_matrix_4x4 *mat);
#if 0
bool (*cb_set_coords)(void *handle_data,
void *shader_data, const struct video_coords *coords);
#endif
bool (*cb_set_mvp)(void *data, void *shader_data,
const void *mat_data);
void *context_data;
void *shader_data;
@ -671,6 +673,10 @@ struct aspect_ratio_elem
typedef struct video_poke_interface
{
void (*set_coords)(void *handle_data, void *shader_data,
const struct video_coords *coords);
void (*set_mvp)(void *data, void *shader_data,
const void *mat_data);
uintptr_t (*load_texture)(void *video_data, void *data,
bool threaded, enum texture_filter_type filter_type);
void (*unload_texture)(void *data, uintptr_t id);
@ -797,6 +803,9 @@ typedef struct video_driver
typedef struct d3d_renderchain_driver
{
void (*set_mvp)(void *chain_data,
void *data, unsigned vp_width,
unsigned vp_height, unsigned rotation);
void (*chain_free)(void *data);
void *(*chain_new)(void);
bool (*reinit)(void *data, const void *info_data);
@ -827,6 +836,47 @@ typedef struct d3d_renderchain_driver
typedef struct gl_renderchain_driver
{
void (*set_coords)(void *handle_data,
void *shader_data, const struct video_coords *coords);
void (*set_mvp)(void *data, void *shader_data,
const void *mat_data);
void (*init_texture_reference)(
void *data, unsigned i,
unsigned internal_fmt, unsigned texture_fmt,
unsigned texture_type);
void (*fence_iterate)(void *data, unsigned hard_sync_frames);
void (*fence_free)(void *data);
void (*readback)(void *data,
unsigned alignment,
unsigned fmt, unsigned type,
void *src);
void (*init_pbo)(unsigned size, const void *data);
void (*bind_pbo)(unsigned idx);
void (*unbind_pbo)(void);
void (*copy_frame)(
void *data,
video_frame_info_t *video_info,
const void *frame,
unsigned width, unsigned height, unsigned pitch);
void (*restore_default_state)(void *data);
void (*new_vao)(void *data);
void (*free_vao)(void *data);
void (*bind_vao)(void *data);
void (*unbind_vao)(void *data);
void (*disable_client_arrays)(void);
void (*ff_vertex)(const void *data);
void (*ff_matrix)(const void *data);
void (*bind_backbuffer)(void);
void (*deinit_fbo)(void *data);
void (*viewport_info)(
void *data, struct video_viewport *vp);
bool (*read_viewport)(
void *data, uint8_t *buffer, bool is_idle);
void (*bind_prev_texture)(
void *data,
const struct video_tex_info *tex_info);
void (*chain_free)(void *data);
void *(*chain_new)(void);
void (*init)(void *data, unsigned fbo_width, unsigned fbo_height);
bool (*init_hw_render)(void *data, unsigned width, unsigned height);
void (*free)(void *data);
@ -1236,17 +1286,13 @@ bool video_shader_driver_get_feedback_pass(unsigned *data);
bool video_shader_driver_mipmap_input(unsigned *index);
#define video_shader_driver_set_coords(coords) \
if (!current_shader->set_coords(coords.handle_data, shader_data, (const struct video_coords*)coords.data) && current_shader->set_coords_fallback) \
current_shader->set_coords_fallback(coords.handle_data, shader_data, (const struct video_coords*)coords.data)
void video_driver_set_coords(video_shader_ctx_coords_t *coords);
bool video_shader_driver_scale(video_shader_ctx_scale_t *scaler);
bool video_shader_driver_info(video_shader_ctx_info_t *shader_info);
#define video_shader_driver_set_mvp(mvp) \
if (mvp.matrix) \
current_shader->set_mvp(mvp.data, shader_data, mvp.matrix) \
void video_driver_set_mvp(video_shader_ctx_mvp_t *mvp);
bool video_shader_driver_filter_type(video_shader_ctx_filter_t *filter);
@ -1261,6 +1307,10 @@ bool renderchain_d3d_init_first(
const d3d_renderchain_driver_t **renderchain_driver,
void **renderchain_handle);
bool renderchain_gl_init_first(
const gl_renderchain_driver_t **renderchain_driver,
void **renderchain_handle);
extern bool (*video_driver_cb_has_focus)(void);
extern shader_backend_t *current_shader;
@ -1321,7 +1371,9 @@ extern const shader_backend_t shader_null_backend;
extern d3d_renderchain_driver_t d3d8_renderchain;
extern d3d_renderchain_driver_t cg_d3d9_renderchain;
extern d3d_renderchain_driver_t hlsl_d3d9_renderchain;
extern d3d_renderchain_driver_t null_renderchain;
extern d3d_renderchain_driver_t null_d3d_renderchain;
extern gl_renderchain_driver_t gl2_renderchain;
RETRO_END_DECLS

2
gfx/video_thread_wrapper.c
View File

@ -1257,6 +1257,8 @@ static struct video_shader *thread_get_current_shader(void *data)
}
static const video_poke_interface_t thread_poke = {
NULL, /* set_coords */
NULL, /* set_mvp */
thread_load_texture,
thread_unload_texture,
thread_set_video_mode,

11
griffin/griffin.c
View File

@ -279,6 +279,13 @@ VIDEO SHADERS
#include "../gfx/drivers_shader/shader_glsl.c"
#endif
#if defined(HAVE_D3D)
#ifdef HAVE_HLSL
#include "../gfx/drivers_shader/shader_hlsl.c"
#endif
#endif
/*============================================================
VIDEO IMAGE
============================================================ */
@ -322,6 +329,10 @@ VIDEO DRIVER
#if defined(HAVE_D3D9)
#ifdef HAVE_HLSL
#include "../gfx/drivers_renderchain/d3d9_hlsl_renderchain.c"
#endif
#ifdef HAVE_CG
#include "../gfx/drivers_renderchain/d3d9_cg_renderchain.c"
#endif

15
griffin/griffin_cpp.cpp
View File

@ -97,17 +97,6 @@ MENU
#include "../menu/drivers/xui.cpp"
#endif
/*============================================================
VIDEO CONTEXT
============================================================ */
#if defined(HAVE_D3D)
#ifdef HAVE_HLSL
#include "../gfx/drivers_shader/shader_hlsl.cpp"
#endif
#endif
/*============================================================
UI
============================================================ */
@ -127,10 +116,6 @@ UI
/*============================================================
VIDEO DRIVER
============================================================ */
#if defined(HAVE_D3D) && defined(HAVE_D3D9) && defined(HAVE_HLSL)
#include "../gfx/drivers_renderchain/d3d9_hlsl_renderchain.cpp"
#endif
#ifdef HAVE_VULKAN
#include "../gfx/drivers_shader/shader_vulkan.cpp"
#include "../gfx/drivers_shader/glslang_util.cpp"

12
input/connect/connect_nesusb.c
View File

@ -86,10 +86,10 @@ static void hidpad_nesusb_packet_handler(void *data, uint8_t *packet, uint16_t s
uint32_t i, pressed_keys;
static const uint32_t button_mapping[17] =
{
NO_BTN,
NO_BTN,
NO_BTN,
NO_BTN,
RETRO_DEVICE_ID_JOYPAD_L2,
RETRO_DEVICE_ID_JOYPAD_R2,
RETRO_DEVICE_ID_JOYPAD_L,
RETRO_DEVICE_ID_JOYPAD_R,
RETRO_DEVICE_ID_JOYPAD_SELECT,
RETRO_DEVICE_ID_JOYPAD_START,
NO_BTN,
@ -100,8 +100,8 @@ static void hidpad_nesusb_packet_handler(void *data, uint8_t *packet, uint16_t s
NO_BTN,
RETRO_DEVICE_ID_JOYPAD_B,
RETRO_DEVICE_ID_JOYPAD_A,
NO_BTN,
NO_BTN,
RETRO_DEVICE_ID_JOYPAD_Y,
RETRO_DEVICE_ID_JOYPAD_X,
16, /* HOME BUTTON when pressing SELECT+START */
};
struct hidpad_nesusb_data *device = (struct hidpad_nesusb_data*)data;

2
input/connect/connect_psxadapter.c
View File

@ -25,7 +25,7 @@
struct hidpad_psxadapter_data
{
struct pad_connection* connection;
uint8_t data[8];
uint8_t data[64];
uint32_t slot;
uint64_t buttons;
};

8
input/drivers/dinput.c
View File

@ -85,7 +85,7 @@ struct dinput_input
int mouse_rel_y;
int mouse_x;
int mouse_y;
bool mouse_l, mouse_r, mouse_m, mouse_wu, mouse_wd, mouse_hwu, mouse_hwd;
bool mouse_l, mouse_r, mouse_m, mouse_b4, mouse_b5, mouse_wu, mouse_wd, mouse_hwu, mouse_hwd;
struct pointer_status pointer_head; /* dummy head for easier iteration */
};
@ -246,6 +246,8 @@ static void dinput_poll(void *data)
di->mouse_l = mouse_state.rgbButtons[0];
di->mouse_r = mouse_state.rgbButtons[1];
di->mouse_m = mouse_state.rgbButtons[2];
di->mouse_b4 = mouse_state.rgbButtons[3];
di->mouse_b5 = mouse_state.rgbButtons[4];
/* No simple way to get absolute coordinates
* for RETRO_DEVICE_POINTER. Just use Win32 APIs. */
@ -368,6 +370,10 @@ static int16_t dinput_mouse_state(struct dinput_input *di, unsigned id)
return state;
case RETRO_DEVICE_ID_MOUSE_MIDDLE:
return di->mouse_m;
case RETRO_DEVICE_ID_MOUSE_BUTTON_4:
return di->mouse_b4;
case RETRO_DEVICE_ID_MOUSE_BUTTON_5:
return di->mouse_b5;
}
return 0;

8
input/drivers/sdl_input.c
View File

@ -38,7 +38,7 @@ typedef struct sdl_input
int mouse_x, mouse_y;
int mouse_abs_x, mouse_abs_y;
int mouse_l, mouse_r, mouse_m, mouse_wu, mouse_wd, mouse_wl, mouse_wr;
int mouse_l, mouse_r, mouse_m, mouse_b4, mouse_b5, mouse_wu, mouse_wd, mouse_wl, mouse_wr;
} sdl_input_t;
static void *sdl_input_init(const char *joypad_driver)
@ -131,6 +131,10 @@ static int16_t sdl_mouse_device_state(sdl_input_t *sdl, unsigned id)
return sdl->mouse_y;
case RETRO_DEVICE_ID_MOUSE_MIDDLE:
return sdl->mouse_m;
case RETRO_DEVICE_ID_MOUSE_BUTTON_4:
return sdl->mouse_b4;
case RETRO_DEVICE_ID_MOUSE_BUTTON_5:
return sdl->mouse_b5;
}
return 0;
@ -310,6 +314,8 @@ static void sdl_poll_mouse(sdl_input_t *sdl)
sdl->mouse_l = (SDL_BUTTON(SDL_BUTTON_LEFT) & btn) ? 1 : 0;
sdl->mouse_r = (SDL_BUTTON(SDL_BUTTON_RIGHT) & btn) ? 1 : 0;
sdl->mouse_m = (SDL_BUTTON(SDL_BUTTON_MIDDLE) & btn) ? 1 : 0;
sdl->mouse_b4 = (SDL_BUTTON(SDL_BUTTON_X1) & btn) ? 1 : 0;
sdl->mouse_b5 = (SDL_BUTTON(SDL_BUTTON_X2) & btn) ? 1 : 0;
#ifndef HAVE_SDL2
sdl->mouse_wu = (SDL_BUTTON(SDL_BUTTON_WHEELUP) & btn) ? 1 : 0;
sdl->mouse_wd = (SDL_BUTTON(SDL_BUTTON_WHEELDOWN) & btn) ? 1 : 0;

2
input/drivers/wiiu_input.c
View File

@ -105,7 +105,7 @@ static int16_t wiiu_pointer_device_state(wiiu_input_t* wiiu, unsigned id)
switch (id)
{
case RETRO_DEVICE_ID_POINTER_PRESSED:
return wiiu->joypad->get_buttons(0) & VPAD_BUTTON_TOUCH;
return (wiiu->joypad->get_buttons(0) & VPAD_BUTTON_TOUCH) ? 1 : 0;
case RETRO_DEVICE_ID_POINTER_X:
return wiiu->joypad->axis(0, 0xFFFF0004UL);
case RETRO_DEVICE_ID_POINTER_Y:

18
input/drivers/winraw_input.c
View File

@ -32,7 +32,7 @@ typedef struct
HANDLE hnd;
LONG x, y, dlt_x, dlt_y;
LONG whl_u, whl_d;
bool btn_l, btn_m, btn_r;
bool btn_l, btn_m, btn_r, btn_b4, btn_b5;
} winraw_mouse_t;
typedef struct
@ -279,6 +279,10 @@ static int16_t winraw_mouse_state(winraw_input_t *wr,
return mouse->whl_d ? 1 : 0;
case RETRO_DEVICE_ID_MOUSE_MIDDLE:
return mouse->btn_m ? 1 : 0;
case RETRO_DEVICE_ID_MOUSE_BUTTON_4:
return mouse->btn_b4 ? 1 : 0;
case RETRO_DEVICE_ID_MOUSE_BUTTON_5:
return mouse->btn_b5 ? 1 : 0;
}
return 0;
@ -419,6 +423,16 @@ static void winraw_update_mouse_state(winraw_mouse_t *mouse, RAWMOUSE *state)
else if (state->usButtonFlags & RI_MOUSE_RIGHT_BUTTON_UP)
mouse->btn_r = false;
if (state->usButtonFlags & RI_MOUSE_BUTTON_4_DOWN)
mouse->btn_b4 = true;
else if (state->usButtonFlags & RI_MOUSE_BUTTON_4_UP)
mouse->btn_b4 = false;
if (state->usButtonFlags & RI_MOUSE_BUTTON_5_DOWN)
mouse->btn_b5 = true;
else if (state->usButtonFlags & RI_MOUSE_BUTTON_5_UP)
mouse->btn_b5 = false;
if (state->usButtonFlags & RI_MOUSE_WHEEL)
{
if ((SHORT)state->usButtonData > 0)
@ -566,6 +580,8 @@ static void winraw_poll(void *d)
wr->mice[i].btn_l = g_mice[i].btn_l;
wr->mice[i].btn_m = g_mice[i].btn_m;
wr->mice[i].btn_r = g_mice[i].btn_r;
wr->mice[i].btn_b4 = g_mice[i].btn_b4;
wr->mice[i].btn_b5 = g_mice[i].btn_b5;
}
if (wr->joypad)

2
input/drivers_joypad/mfi_joypad.m
View File

@ -138,7 +138,7 @@ static void apple_gamecontroller_joypad_connect(GCController *controller)
? desired_index : 0;
/* prevent same controller getting set twice */
if (mfi_controllers[desired_index] != controller.hash)
if (mfi_controllers[desired_index] != (uint32_t)controller.hash)
{
/* desired slot is unused, take it */
if (!mfi_controllers[desired_index])

71
input/drivers_joypad/wiiu_joypad.c
View File

@ -50,8 +50,6 @@
#define KPAD_OFFSET (GAMEPAD_OFFSET + GAMEPAD_COUNT)
#define HID_OFFSET (KPAD_OFFSET + KPAD_COUNT)
extern uint64_t lifecycle_state;
static uint64_t pad_state[MAX_PADS];
static uint8_t pad_type[KPAD_COUNT] = {WIIUINPUT_TYPE_NONE, WIIUINPUT_TYPE_NONE, WIIUINPUT_TYPE_NONE, WIIUINPUT_TYPE_NONE};
@ -65,17 +63,16 @@ static char hidName[HID_COUNT][255];
static const char* wiiu_joypad_name(unsigned pad)
{
if (pad == 0)
if (pad > MAX_PADS) return "N/A";
if (pad == GAMEPAD_OFFSET)
return "WIIU Gamepad";
if (pad < MAX_PADS && pad < (HID_OFFSET) && pad > GAMEPAD_OFFSET)
if (pad >= KPAD_OFFSET && pad < KPAD_OFFSET + KPAD_COUNT)
{
int i = pad - KPAD_OFFSET;
switch (pad_type[i])
{
case WIIUINPUT_TYPE_NONE:
return "N/A";
case WIIUINPUT_TYPE_PRO_CONTROLLER:
return "WIIU Pro Controller";
@ -87,13 +84,17 @@ static const char* wiiu_joypad_name(unsigned pad)
case WIIUINPUT_TYPE_CLASSIC_CONTROLLER:
return "Classic Controller";
case WIIUINPUT_TYPE_NONE:
default:
return "N/A";
}
}
if (pad < MAX_PADS)
if (pad >= HID_OFFSET && pad < HID_OFFSET + HID_COUNT)
{
s32 hid_index = pad-HID_OFFSET;
sprintf(hidName[hid_index],"HID %04X/%04X(%02X)",hid_data[hid_index].device_info.vidpid.vid,hid_data[hid_index].device_info.vidpid.pid,hid_data[hid_index].pad);
s32 hid_index = pad - HID_OFFSET;
sprintf(hidName[hid_index], "HID %04X/%04X(%02X)", hid_data[hid_index].device_info.vidpid.vid, hid_data[hid_index].device_info.vidpid.pid, hid_data[hid_index].pad);
return hidName[hid_index];
}
@ -165,13 +166,12 @@ static int16_t wiiu_joypad_axis(unsigned port_num, uint32_t joyaxis)
val = analog_state[port_num][1][1];
break;
//For position data; just return the unmodified value
case 4:
val = analog_state[port_num][2][0];
break;
return analog_state[port_num][2][0];
case 5:
val = analog_state[port_num][2][1];
break;
return analog_state[port_num][2][1];
}
if (is_neg && val > 0)
@ -182,9 +182,9 @@ static int16_t wiiu_joypad_axis(unsigned port_num, uint32_t joyaxis)
return val;
}
static float scaleTP(float oldMin, float oldMax, float newMin, float newMax, float val) {
float oldRange = (oldMax - oldMin);
float newRange = (newMax - newMin);
static int16_t scaleTP(int16_t oldMin, int16_t oldMax, int16_t newMin, int16_t newMax, int16_t val) {
int32_t oldRange = oldMax - oldMin;
int32_t newRange = newMax - newMin;
return (((val - oldMin) * newRange) / oldRange) + newMin;
}
@ -204,8 +204,6 @@ static void wiiu_joypad_poll(void)
analog_state[0][RETRO_DEVICE_INDEX_ANALOG_RIGHT] [RETRO_DEVICE_ID_ANALOG_X] = vpad.rightStick.x * 0x7FF0;
analog_state[0][RETRO_DEVICE_INDEX_ANALOG_RIGHT] [RETRO_DEVICE_ID_ANALOG_Y] = vpad.rightStick.y * 0x7FF0;
BIT64_CLEAR(lifecycle_state, RARCH_MENU_TOGGLE);
/* You can only call VPADData once every loop, else the second one
won't get any data. Thus; I had to hack touch support into the existing
joystick API. Woo-hoo? Misplaced requests for touch axis are filtered
@ -217,13 +215,38 @@ static void wiiu_joypad_poll(void)
VPADTouchData cal = {0};
/* Calibrates data to a 720p screen, seems to clamp outer 12px */
VPADGetTPCalibratedPoint(0, &cal, &(vpad.tpNormal));
/* Calibrate to viewport and save as axis 2 (idx 4,5) */
analog_state[0][2][0] = (int16_t)scaleTP(12.0f, 1268.0f, 0.0f, (float)(vp.full_width), (float)cal.x);
analog_state[0][2][1] = (int16_t)scaleTP(12.0f, 708.0f, 0.0f, (float)(vp.full_height), (float)cal.y);
/* Clamp to actual game image */
bool touchClamped = false;
if (cal.x < vp.x) {
cal.x = vp.x;
touchClamped = true;
} else if (cal.x > vp.x + vp.width) {
cal.x = vp.x + vp.width;
touchClamped = true;
}
if (cal.y < vp.y) {
cal.y = vp.y;
touchClamped = true;
} else if (cal.y > vp.y + vp.height) {
cal.y = vp.y + vp.height;
touchClamped = true;
}
/* Account for 12px clamp on VPADGetTPCalibratedPoint */
if (vp.x < 12) vp.x = 12;
if (vp.y < 12) vp.y = 12;
if (vp.x + vp.width > 1268) vp.width = 1268 - vp.x;
if (vp.y + vp.height > 708) vp.height = 708 - vp.y;
/* Calibrate to libretro spec and save as axis 2 (idx 4,5) */
analog_state[0][2][0] = scaleTP(vp.x, vp.x + vp.width, -0x7fff, 0x7fff, cal.x);
analog_state[0][2][1] = scaleTP(vp.y, vp.y + vp.height, -0x7fff, 0x7fff, cal.y);
/* Emulating a button for touch; lets people assign it to menu
/* Emulating a button (#19) for touch; lets people assign it to menu
for that traditional RetroArch Wii U feel */
pad_state[0] |= VPAD_BUTTON_TOUCH;
if (!touchClamped) {
pad_state[0] |= VPAD_BUTTON_TOUCH;
} else {
pad_state[0] &= ~VPAD_BUTTON_TOUCH;
}
} else {
/* This is probably 0 anyway */
pad_state[0] &= ~VPAD_BUTTON_TOUCH;

120
input/input_driver.c
View File

@ -1609,53 +1609,99 @@ int16_t input_joypad_analog(const input_device_driver_t *drv,
unsigned port, unsigned idx, unsigned ident,
const struct retro_keybind *binds)
{
uint32_t axis_minus, axis_plus;
int16_t pressed_minus, pressed_plus, res;
unsigned ident_minus = 0;
unsigned ident_plus = 0;
const struct retro_keybind *bind_minus = NULL;
const struct retro_keybind *bind_plus = NULL;
int16_t res;
input_conv_analog_id_to_bind_id(idx, ident, &ident_minus, &ident_plus);
if ( idx == RETRO_DEVICE_INDEX_ANALOG_BUTTON )
{
/* A RETRO_DEVICE_JOYPAD button? */
if ( ident < RARCH_FIRST_CUSTOM_BIND )
{
uint32_t axis = 0;
const struct retro_keybind *bind = NULL;
bind_minus = &binds[ident_minus];
bind_plus = &binds[ident_plus];
bind = &binds[ ident ];
if (!bind->valid)
return 0;
if (!bind_minus->valid || !bind_plus->valid)
return 0;
axis = bind->joyaxis;
if ( axis == AXIS_NONE )
axis = joypad_info.auto_binds[ ident ].joyaxis;
axis_minus = bind_minus->joyaxis;
axis_plus = bind_plus->joyaxis;
/* Analog button. */
res = abs( drv->axis( joypad_info.joy_idx, axis ) );
if (axis_minus == AXIS_NONE)
axis_minus = joypad_info.auto_binds[ident_minus].joyaxis;
if (axis_plus == AXIS_NONE)
axis_plus = joypad_info.auto_binds[ident_plus].joyaxis;
/* If the result is zero, it's got a digital button attached to it */
if ( res == 0 )
{
uint64_t key = bind->joykey;
pressed_minus = abs(drv->axis(joypad_info.joy_idx, axis_minus));
pressed_plus = abs(drv->axis(joypad_info.joy_idx, axis_plus));
res = pressed_plus - pressed_minus;
if ( key == NO_BTN )
key = joypad_info.auto_binds[ ident ].joykey;
if (res == 0)
{
int16_t digital_left = 0;
int16_t digital_right = 0;
uint64_t key_minus = bind_minus->joykey;
uint64_t key_plus = bind_plus->joykey;
if ( drv->button(joypad_info.joy_idx, (uint16_t)key))
res = 0x7fff;
}
}
else
{
/* not a suitable button */
res = 0;
}
}
else
{
/* Analog sticks. Either RETRO_DEVICE_INDEX_ANALOG_LEFT
* or RETRO_DEVICE_INDEX_ANALOG_RIGHT */
if (key_minus == NO_BTN)
key_minus = joypad_info.auto_binds[ident_minus].joykey;
if (key_plus == NO_BTN)
key_plus = joypad_info.auto_binds[ident_plus].joykey;
uint32_t axis_minus, axis_plus;
int16_t pressed_minus, pressed_plus;
unsigned ident_minus = 0;
unsigned ident_plus = 0;
const struct retro_keybind *bind_minus = NULL;
const struct retro_keybind *bind_plus = NULL;
if (drv->button(joypad_info.joy_idx, (uint16_t)key_minus))
digital_left = -0x7fff;
if (drv->button(joypad_info.joy_idx, (uint16_t)key_plus))
digital_right = 0x7fff;
return digital_right + digital_left;
}
input_conv_analog_id_to_bind_id(idx, ident, &ident_minus, &ident_plus);
return res;
bind_minus = &binds[ident_minus];
bind_plus = &binds[ident_plus];
if (!bind_minus->valid || !bind_plus->valid)
return 0;
axis_minus = bind_minus->joyaxis;
axis_plus = bind_plus->joyaxis;
if (axis_minus == AXIS_NONE)
axis_minus = joypad_info.auto_binds[ident_minus].joyaxis;
if (axis_plus == AXIS_NONE)
axis_plus = joypad_info.auto_binds[ident_plus].joyaxis;
pressed_minus = abs(drv->axis(joypad_info.joy_idx, axis_minus));
pressed_plus = abs(drv->axis(joypad_info.joy_idx, axis_plus));
res = pressed_plus - pressed_minus;
if (res == 0)
{
int16_t digital_left = 0;
int16_t digital_right = 0;
uint64_t key_minus = bind_minus->joykey;
uint64_t key_plus = bind_plus->joykey;
if (key_minus == NO_BTN)
key_minus = joypad_info.auto_binds[ident_minus].joykey;
if (key_plus == NO_BTN)
key_plus = joypad_info.auto_binds[ident_plus].joykey;
if (drv->button(joypad_info.joy_idx, (uint16_t)key_minus))
digital_left = -0x7fff;
if (drv->button(joypad_info.joy_idx, (uint16_t)key_plus))
digital_right = 0x7fff;
return digital_right + digital_left;
}
}
return res;
}
/**

1
input/input_driver.h
View File

@ -520,6 +520,7 @@ static INLINE bool input_joypad_pressed(
* E.g.:
* - RETRO_DEVICE_INDEX_ANALOG_LEFT
* - RETRO_DEVICE_INDEX_ANALOG_RIGHT
* - RETRO_DEVICE_INDEX_ANALOG_BUTTON
* @ident : Analog key identifier.
* E.g.:
* - RETRO_DEVICE_ID_ANALOG_X

8
input/input_mapper.c
View File

@ -48,12 +48,12 @@ struct input_mapper
{
/* The controller port that will be polled*/
uint8_t port;
/* This is a bitmask of (1 << key_bind_id). */
uint64_t buttons;
/* Left X, Left Y, Right X, Right Y */
int16_t analog[4];
/* the whole keyboard state */
uint32_t keys[RETROK_LAST / 32 + 1];
/* This is a bitmask of (1 << key_bind_id). */
uint64_t buttons;
};
static input_mapper_t *mapper_ptr;
@ -63,11 +63,11 @@ input_mapper_t *input_mapper_new(uint16_t port)
settings_t *settings = config_get_ptr();
input_mapper_t* handle = (input_mapper_t*)
calloc(1, sizeof(*handle));
if (!handle)
return NULL;
handle->port = port;
mapper_ptr = handle;
mapper_ptr = handle;
return handle;
}

23
input/input_overlay.c
View File

@ -39,31 +39,32 @@
typedef struct input_overlay_state
{
/* This is a bitmask of (1 << key_bind_id). */
uint64_t buttons;
/* Left X, Left Y, Right X, Right Y */
int16_t analog[4];
uint32_t keys[RETROK_LAST / 32 + 1];
/* This is a bitmask of (1 << key_bind_id). */
uint64_t buttons;
} input_overlay_state_t;
struct input_overlay
{
void *iface_data;
const video_overlay_interface_t *iface;
input_overlay_state_t overlay_state;
bool enable;
enum overlay_status state;
bool enable;
bool blocked;
bool alive;
struct overlay *overlays;
const struct overlay *active;
unsigned next_index;
size_t index;
size_t size;
unsigned next_index;
enum overlay_status state;
struct overlay *overlays;
const struct overlay *active;
void *iface_data;
const video_overlay_interface_t *iface;
input_overlay_state_t overlay_state;
};
input_overlay_t *overlay_ptr = NULL;

4
intl/msg_hash_chs.h
View File

@ -1674,6 +1674,8 @@ MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_PIXEL,
"Pixel")
MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_RETROACTIVE,
"RetroActive")
MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_RETROSYSTEM,
"Retrosystem")
MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_DOTART,
"Dot-Art")
MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME,
@ -2163,6 +2165,8 @@ MSG_HASH(MSG_SKIPPING_SRAM_LOAD,
"跳过 SRAM 加载。")
MSG_HASH(MSG_SLOW_MOTION,
"慢动作。")
MSG_HASH(MSG_FAST_FORWARD,
"快进。")
MSG_HASH(MSG_SLOW_MOTION_REWIND,
"慢动作回溯。")
MSG_HASH(MSG_SRAM_WILL_NOT_BE_SAVED,

4
intl/msg_hash_cht.h
View File

@ -1674,6 +1674,8 @@ MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_PIXEL,
"Pixel")
MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_RETROACTIVE,
"RetroActive")
MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_RETROSYSTEM,
"Retrosystem")
MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_DOTART,
"Dot-Art")
MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME,
@ -2163,6 +2165,8 @@ MSG_HASH(MSG_SKIPPING_SRAM_LOAD,
"跳過 SRAM 戴入。")
MSG_HASH(MSG_SLOW_MOTION,
"慢動作。")
MSG_HASH(MSG_FAST_FORWARD,
"快進。")
MSG_HASH(MSG_SLOW_MOTION_REWIND,
"慢動作回溯。")
MSG_HASH(MSG_SRAM_WILL_NOT_BE_SAVED,

354
intl/msg_hash_de.c
View File

@ -1,6 +1,7 @@
/* RetroArch - A frontend for libretro.
/* RetroArch - A frontend for Libretro.
* Copyright (C) 2011-2017 - Daniel De Matteis
* Copyright (C) 2017 - Lothar Serra Mari
* Copyright (C) 2016-2017 - Brad Parker
* Translation currently maintained by Lothar Serra Mari [rootfather]
*
* RetroArch 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 Found-
@ -43,7 +44,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case RARCH_FAST_FORWARD_HOLD_KEY:
snprintf(s, len,
"Halte die Taste gedrückt, um vorzuspulen.\n"
"Taste gedrückt halten, um vorzuspulen.\n"
" \n"
"Beim Loslassen wird der schnelle Vorlauf beendet."
);
@ -80,7 +81,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case RARCH_MUTE:
snprintf(s, len,
"Tonwiedergabe stummschalten bzw. Stummschaltung aufheben.");
"Tonwiedergabe ein-/ausschalten.");
break;
case RARCH_OSK:
snprintf(s, len,
@ -96,19 +97,19 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case RARCH_SLOWMOTION:
snprintf(s, len,
"Halte die Taste gedrückt, um die Zeitlupe einzuschalten.");
"Taste gedrückt halten, um die Zeitlupe einzuschalten.");
break;
case RARCH_ENABLE_HOTKEY:
snprintf(s, len,
"Andere Hotkeys aktivieren. \n"
"Andere Tastenkürzel aktivieren. \n"
" \n"
"Wenn dieser Hotkey entweder einer\n"
"Tastatur, einer Joypad-Taste oder \n"
"Joypad-Achse zugeordnet ist, werden alle \n"
"anderen Hotkeys nur aktiviert, wenn dieser \n"
"Hotkey zur gleichen Zeit gehalten wird. \n"
"Wenn dieses Tastenkürzel entweder einer\n"
"Tastatur, einer Controller-Taste oder \n"
"Controller-Achse zugeordnet ist, werden alle \n"
"anderen Tastenkürzel nur freigeschaltet, wenn \n"
"dieses Tastenkürzel zur gleichen Zeit gehalten wird. \n"
" \n"
"Alternativ können auch alle Tastatur-Hotkeys durch \n"
"Alternativ können auch alle Tastatur-Kürzel durch \n"
"den Benutzer deaktiviert werden.");
break;
case RARCH_VOLUME_UP:
@ -134,7 +135,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
snprintf(s, len,
"Wechselt durch Datenträger-Abbilder. Nach dem Auswerfen verwenden. \n"
" \n"
"Zum Abschließen, Datenträger erneut einbinden.");
"Zum Abschließen Datenträger erneut einbinden.");
break;
case RARCH_GRAB_MOUSE_TOGGLE:
snprintf(s, len,
@ -148,7 +149,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
snprintf(s, len,
"Spiel-Fokus umschalten.\n"
" \n"
"Wenn ein Spiel fokussiert ist, wird RetroArch die Hotkeys\n"
"Wenn ein Spiel fokussiert ist, wird RetroArch die Tastenkürzel\n"
"deaktivieren und den Mauszeiger im RetroArch-Fenster halten.");
break;
case RARCH_MENU_TOGGLE:
@ -156,18 +157,18 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case RARCH_LOAD_STATE_KEY:
snprintf(s, len,
"Spielstand laden.");
"Zustand (Savestate) laden.");
break;
case RARCH_FULLSCREEN_TOGGLE_KEY:
snprintf(s, len,
"Vollbildmodus umschalten");
"Vollbildmodus umschalten.");
break;
case RARCH_QUIT_KEY:
snprintf(s, len,
"Taste zum Beenden von RetroArch. \n"
" \n"
"Wenn Du RetroArch unsanft beendest (SIGKILL, etc.) wird \n"
"RetroArch beendet, ohne Arbeitsspeicher oder ähnliches zu speichern."
"Ein 'hartes' Beenden des Prozesses (SIGKILL, etc.) wird \n"
"RetroArch beenden, ohne Arbeitsspeicher oder ähnliches zu speichern."
#ifdef __unix__
"\nAuf unixoiden Systemen erlaubt SIGINT/SIGTERM ein sauberes \n"
"Beenden von RetroArch."
@ -179,7 +180,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
snprintf(s, len,
"Speicherplätze. \n"
" \n"
"Wenn der Speicherplatz 0 ausgewählt wird, ist der Name des Spielstands \n"
"Wenn der Speicherplatz 0 ausgewählt wird, ist der Name des Zustands \n"
"*.state (oder was entsprechend auf der Kommandozeile definiert wurde). \n"
" \n"
"Wenn ein anderer Speicherplatz als 0 gewählt wird, wird das Verzeichnis <path><d> \n"
@ -187,17 +188,17 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case RARCH_SAVE_STATE_KEY:
snprintf(s, len,
"Spielstand abspeichern.");
"Aktuellen Zustand (Savestate) abspeichern.");
break;
case RARCH_REWIND:
snprintf(s, len,
"Halte die Taste zum Zurückspulen gedrückt. \n"
"Taste zum Zurückspulen gedrückt halten. \n"
" \n"
"Die Zurückspulfunktion muss eingeschaltet sein.");
break;
case RARCH_MOVIE_RECORD_TOGGLE:
snprintf(s, len,
"Aufnahme starten/beenden");
"Aufnahme starten/beenden.");
break;
default:
if (string_is_empty(s))
@ -217,7 +218,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Besuche retroachievements.org und eröffne \n"
"ein kostenloses Konto. \n"
" \n"
"Nach der Registrierung musst Du deinen \n"
"Nach der Registrierung musst du deinen \n"
"Benutzernamen und dein Passwort in RetroArch \n"
"angeben.");
break;
@ -229,15 +230,15 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_USER_LANGUAGE:
snprintf(s, len, "Übersetzt das Menü und alle Bildschirm-Meldungen \n"
"in die Sprache, die Du hier ausgewählt hast. \n"
"in die Sprache, die du hier ausgewählt hast. \n"
" \n"
"Ein Neustart wird benötigt, um die geänderten \n"
"Einstellungen zu aktivieren. \n"
" \n"
"Hinweis: möglicherweise sind nicht alle Sprachen \n"
"implementiert. \n"
"Hinweis: Möglicherweise sind nicht alle Sprachen \n"
"verfügbar. \n"
" \n"
"Wenn die gewählte Sprache nicht implementiert ist, \n"
"Wenn die gewählte Sprache nicht verfügbar ist, \n"
"wird Englisch als Sprache ausgewählt.");
break;
case MENU_ENUM_LABEL_VIDEO_FONT_PATH:
@ -254,43 +255,46 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
snprintf(s, len, "Eingabebelegungsdateien automatisch laden.");
break;
case MENU_ENUM_LABEL_SORT_SAVESTATES_ENABLE:
snprintf(s, len, "Speichert Spielstand-Dateien in Ordnern, \n"
"die nach dem verwendeten libretro-Core benannt sind.");
snprintf(s, len, "Speichert Zustandsdaten (Savestates) in Ordnern, \n"
"die nach dem verwendeten Libretro-Core benannt sind.");
break;
case MENU_ENUM_LABEL_SORT_SAVEFILES_ENABLE:
snprintf(s, len, "Speichert Speicherdaten in Ordnern, \n"
"die nach dem verwendeten libretro-Core benannt sind.");
"die nach dem verwendeten Libretro-Core benannt sind.");
break;
case MENU_ENUM_LABEL_RESUME_CONTENT:
snprintf(s, len, "Verlässt das Menü und kehrt \n"
"zum Inhalt zurück.");
break;
case MENU_ENUM_LABEL_RESTART_CONTENT:
snprintf(s, len, "Startet den Inhalt vom Beginn an neu.");
snprintf(s, len, "Startet den Inhalt neu.");
break;
case MENU_ENUM_LABEL_CLOSE_CONTENT:
snprintf(s, len, "Schließt den Inhalt und entlädt ihn aus dem \n"
"Speicher.");
break;
case MENU_ENUM_LABEL_UNDO_LOAD_STATE:
snprintf(s, len, "Wenn ein Spielstand geladen war, wird der Inhalt \n"
"zum Status vor dem Laden des Spielstands zurückkehren.");
snprintf(s, len, "Wenn ein Zustand (Savestate) geladen wurde, wird der Inhalt \n"
"zum Stand vor dem Laden des Savestates zurückkehren.");
break;
case MENU_ENUM_LABEL_UNDO_SAVE_STATE:
snprintf(s, len, "Wenn ein Spielstand überschrieben wurde, wird \n"
"der Inhalt zum vorherigen Spielstand zurückkehren.");
snprintf(s, len, "Wenn ein Zustand (Savestate) überschrieben wurde, wird \n"
"der Inhalt zum vorherigen Zustand zurückkehren.");
break;
case MENU_ENUM_LABEL_TAKE_SCREENSHOT:
snprintf(s, len, "Fertigt ein Bildschirmfoto an. \n"
snprintf(s, len, "Erstellt ein Bildschirmfoto. \n"
" \n"
"Das Bildschirmfoto wird im Bildschirmfoto-Verzeichnis \n"
"gespeichert.");
break;
case MENU_ENUM_LABEL_ADD_TO_FAVORITES:
snprintf(s, len, "Fügt den Eintrag zu deinen Favoriten hinzu.");
break;
case MENU_ENUM_LABEL_RUN:
snprintf(s, len, "Startet den Inhalt.");
break;
case MENU_ENUM_LABEL_INFORMATION:
snprintf(s, len, "Zeige zusätzliche Metadaten \n"
snprintf(s, len, "Zeigt zusätzliche Metadaten \n"
"über den Inhalt an.");
break;
case MENU_ENUM_LABEL_FILE_BROWSER_CONFIG:
@ -329,14 +333,14 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Verzeichnis für Vorschaubilder. \n"
" \n"
"Verzeichnis, in welchem die Vorschaubilder \n"
"gespeichert werden.");
"gespeichert werden.");
break;
case MENU_ENUM_LABEL_LIBRETRO_INFO_PATH:
snprintf(s, len,
"Verzeichnis für Core-Informationsdateien. \n"
" \n"
"Ein Verzeichnis, in dem nach \n"
"libretro-Core-Informationen gesucht wird.");
"Libretro-Core-Informationen gesucht wird.");
break;
case MENU_ENUM_LABEL_PLAYLIST_DIRECTORY:
snprintf(s, len,
@ -430,13 +434,13 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_FILE_BROWSER_CORE_SELECT_FROM_COLLECTION:
snprintf(s, len,
"libretro-Core. \n"
"Libretro-Core. \n"
" \n"
"Auswählen, um diesen Core dem Spiel zuzuordnen.");
break;
case MENU_ENUM_LABEL_FILE_BROWSER_CORE:
snprintf(s, len,
"libretro-Core. \n"
"Libretro-Core. \n"
" \n"
"Auswählen, um diesen Core in RetroArch zu laden.");
break;
@ -451,7 +455,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Zwischenspeicher-Verzeichnis. \n"
" \n"
"Von RetroArch entpackter Inhalt wird \n"
"temporär in diesem Verzeichnis gespeichert.");
"vorübergehend in diesem Verzeichnis gespeichert.");
break;
case MENU_ENUM_LABEL_HISTORY_LIST_ENABLE:
snprintf(s, len,
@ -479,7 +483,8 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
" \n"
"Diese Option auf 'Früh' oder 'Spät' zu setzen kann \n"
"eine verringerte Latenz bewirken, \n"
"abhängig von deiner Konfiguration."
"abhängig von deiner Konfiguration.\n\n"
"Diese Einstellung wird ignoriert, wenn Netplay verwendet wird."
);
break;
case MENU_ENUM_LABEL_INPUT_DESCRIPTOR_HIDE_UNBOUND:
@ -514,14 +519,14 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_VIDEO_ALLOW_ROTATE:
snprintf(s, len,
"Erlaube Core, die Drehung festzulegen. Wenn deaktiviert, \n"
"werden Dreh-Anfragen angenommen, aber ignoriert. \n\n"
"Wird in Setups verwendet, in denen der Benutzer den \n"
"Erlaube Core, die Bilddrehung festzulegen. Wenn deaktiviert, \n"
"werden enstprechende anfragen angenommen, aber ignoriert. \n\n"
"Wird für Systeme verwendet, bei denen der Benutzer den \n"
"Monitor manuell dreht.");
break;
case MENU_ENUM_LABEL_INPUT_DESCRIPTOR_LABEL_SHOW:
snprintf(s, len,
"Zeige vom Core festgelegte Eingabe-Beschreibungen anstelle \n"
"Zeigt vom Core festgelegte Eingabe-Beschreibungen anstelle \n"
"der standardmäßigen an.");
break;
case MENU_ENUM_LABEL_CONTENT_HISTORY_SIZE:
@ -547,12 +552,12 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_FPS_SHOW:
snprintf(s, len,
"Aktiviert die Anzeige der aktuellen Bilder \n"
"pro Sekunde.");
"Aktiviert die Anzeige der aktuellen \n"
"Bildwiederholrate.");
break;
case MENU_ENUM_LABEL_VIDEO_FONT_ENABLE:
snprintf(s, len,
"Zeige und/oder verstecke Bildschirm-Meldungen.");
"Aktiviert/deaktiviert Bildschirm-Meldungen.");
break;
case MENU_ENUM_LABEL_VIDEO_MESSAGE_POS_X:
case MENU_ENUM_LABEL_VIDEO_MESSAGE_POS_Y:
@ -562,13 +567,23 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_INPUT_OVERLAY_ENABLE:
snprintf(s, len,
"Aktiviert oder deaktiviert das aktuelle Overlay.");
"Aktiviert/deaktiviert das aktuelle Overlay.");
break;
case MENU_ENUM_LABEL_INPUT_OVERLAY_HIDE_IN_MENU:
snprintf(s, len,
"Verhindert, dass das aktuelle Overlay im \n"
"Menü angezeigt wird.");
break;
case MENU_ENUM_LABEL_INPUT_OVERLAY_SHOW_PHYSICAL_INPUTS:
snprintf(s, len,
"Tastatur/Controller-Tastendrücke im \n"
"Overlay anzeigen.");
break;
case MENU_ENUM_LABEL_INPUT_OVERLAY_SHOW_PHYSICAL_INPUTS_PORT:
snprintf(s, len,
"Wählt den Port des Controllers aus, dessen \n"
"Eingaben im Overlay angezeigt werden sollen.");
break;
case MENU_ENUM_LABEL_OVERLAY_PRESET:
snprintf(s, len,
"Pfad zum Eingabe-Overlay.");
@ -601,9 +616,9 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_CORE_LIST:
snprintf(s, len,
"Lade Core. \n"
"Lädt einen Core. \n"
" \n"
"Suche nach einer libretro-Core-Implementierung. \n"
"Suche nach einer Libretro-Core-Implementierung. \n"
"In welchem Verzeichnis der Browser beginnt, \n"
"hängt von deinem Core-Verzeichnispfad \n"
"ab. Ist dieser nicht eingestellt, wird im Wurzelverzeichnis begonnen. \n"
@ -638,7 +653,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
" \n"
"Treten Probleme wie eine knackende Ton-Wiedergabe oder\n"
"eine unregelmäßige Bildwiedergabe auf, bedeutet dies in der Regel,\n"
"dass Du die Einstellungen kalibrieren musst. Du hast folgende Möglichkeiten:\n"
"dass du die Einstellungen kalibrieren musst. du hast folgende Möglichkeiten:\n"
" \n";
snprintf(u, sizeof(u), /* can't inline this due to the printf arguments */
"a) Gehe zu '%s' -> '%s', und aktiviere\n"
@ -666,7 +681,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Bei einem Treffer wird die Datei zu einer Sammlung\n"
"hinzugefügt.\n"
" \n"
"Du kannst diese Inhalte einfach aufrufen, indem Du\n"
"du kannst diese Inhalte einfach aufrufen, indem du\n"
"zu'%s' ->\n"
"'%s'\n gehst,"
"anstatt jedes Mal den Dateibrowser\n"
@ -741,12 +756,12 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Lade Inhalt. \n"
"Suche nach Inhalten. \n"
" \n"
"Um Inhalte zu laden benötigst Du den passenden \n"
"libretro-Core und die Inhalts-Datei. \n"
"Um Inhalte zu laden benötigst du den passenden \n"
"Libretro-Core und die Inhalts-Datei. \n"
" \n"
"Um einzustellen, welcher Ordner standardmäßig \n"
"geöffnet wird, um nach Inhalten zu suchen, solltest \n"
"Du das Inhalts-Verzeichnis setzen. Wenn es nicht \n"
"du das Inhalts-Verzeichnis setzen. Wenn es nicht \n"
"gesetzt ist, wird es im Hauptverzeichen starten. \n"
" \n"
"Der Browser wird nur Dateierweiterungen des \n"
@ -778,11 +793,11 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"OpenGL-Grafiktreiber. \n"
" \n"
"Dieser Treiber erlaubt es, neben software- \n"
"gerenderten Cores auch libretro-GL-Cores zu \n"
"gerenderten Cores auch Libretro-GL-Cores zu \n"
"verwenden. \n"
" \n"
"Die Leistung, sowohl bei software-gerenderten, \n"
"als auch bei libretro-GL-Cores, hängt von dem \n"
"als auch bei Libretro-GL-Cores, hängt von dem \n"
"GL-Treiber deiner Grafikkarte ab.");
}
else if (string_is_equal_fast(settings->arrays.video_driver, "sdl2", 4))
@ -804,7 +819,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Dies ist ein SDL1.2-Grafiktreiber \n"
"mit Software-Rendering."
" \n"
"Die Leistung ist suboptimal und Du \n"
"Die Leistung ist suboptimal und du \n"
"solltest diesen Treiber nur als letzte \n"
"Möglichkeit verwenden.");
}
@ -888,20 +903,15 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
);
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_SCALE_PASS:
{
/* Work around C89 limitations */
char u[501];
const char * t =
"Für diesen Durchgang skalieren. \n"
snprintf(s, len,
"Für diesen durchgang skalieren. \n"
" \n"
"Der Skalierungsfaktor wird multipliziert, \n"
"d.h. 2x im ersten Durchgang und 2x im \n"
"zweiten Durchgang bedeute eine 4x Gesamt- \n"
"d.h. 2x im ersten durchgang und 2x im \n"
"zweiten durchgang bedeute eine 4x Gesamt- \n"
"Skalierung."
" \n";
snprintf(u, sizeof(u),
"Wenn es im letzten Durchgang einen \n"
" \n"
"Wenn es im letzten durchgang einen \n"
"Skalierungsfaktor gibt, wird das Ergebnis \n"
"mit dem als 'Standardfilter' eingestellten \n"
"Filter auf die Bildschirmgröße gestreckt. \n"
@ -909,23 +919,20 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Wenn 'Ignorieren' eingestellt ist, wird \n"
"entweder einfache Skalierung oder Vollbild- \n"
"Streckung verwendet - abhängig davon, ob \n"
"es der letzte Durchgang ist oder nicht."
"es der letzte durchgang ist oder nicht."
);
strlcpy(s, t, len);
strlcat(s, u, len);
}
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_NUM_PASSES:
snprintf(s, len,
"Shader-Durchgänge. \n"
" \n"
"RetroArch erlaubt es, verschiedene Shader \n"
"in verschiedenen Durchgängen miteinander zu \n"
"in verschiedenen durchgängen miteinander zu \n"
"kombinieren. \n"
" \n"
"Diese Option legt die Anzahl der Shader- \n"
"Durchgänge fest. Wenn Du die Anzahl auf 0 setzt, \n"
"verwendest Du einen 'leeren' Shader."
"durchgänge fest. Wenn du die Anzahl auf 0 setzt, \n"
"verwendest du einen 'leeren' Shader."
" \n"
"Die 'Standardfilter'-Option beeinflusst den \n"
"Streckungsfilter");
@ -952,8 +959,8 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Alle Shader mmüssen vom selben Typ sein \n"
"(z.B. CG, GLSL oder HLSL). \n"
" \n"
"Durch das Setzen des Shader-Verzeichnisses \n"
"legst Du fest, in welchem Verzeichnis der Browser \n"
"durch das Setzen des Shader-Verzeichnisses \n"
"legst du fest, in welchem Verzeichnis der Browser \n"
"nach Shadern sucht."
);
break;
@ -978,15 +985,15 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
);
break;
case MENU_ENUM_LABEL_CONFIRM_ON_EXIT:
snprintf(s, len, "Bist Du sicher, dass Du RetroArch verlassen möchtest?");
snprintf(s, len, "Bist du sicher, dass du RetroArch verlassen möchtest?");
break;
case MENU_ENUM_LABEL_SHOW_HIDDEN_FILES:
snprintf(s, len, "Zeige versteckte Dateien \n"
"und Ordner.");
snprintf(s, len, "Zeigt versteckte Dateien \n"
"und Ordner an.");
break;
case MENU_ENUM_LABEL_VIDEO_SHADER_FILTER_PASS:
snprintf(s, len,
"Hardware-Filter für diesen Durchgang. \n"
"Hardware-Filter für diesen durchgang. \n"
" \n"
"Wenn 'Ignorieren' gewählt ist, wird der \n"
"Standard-Filter verwendet."
@ -1008,7 +1015,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Typ des Eingabe-Gerätes. \n"
" \n"
"Wählt aus, welcher Eingabe-Gerätetyp verwendet wird. \n"
"Dies ist für den libretro-Core selbst relevat."
"Dies ist für den Libretro-Core selbst relevat."
);
break;
case MENU_ENUM_LABEL_LIBRETRO_LOG_LEVEL:
@ -1016,7 +1023,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Legt das Log-Level für das \n"
"(GET_LOG_INTERFACE) der Cores fest. \n"
" \n"
" Wenn ein libretro-Core ein Log-Level unterhalb \n"
" Wenn ein Libretro-Core ein Log-Level unterhalb \n"
" des eingestellten Log-Levels ausgibt, wird \n"
" dies ignoriert.\n"
" \n"
@ -1049,9 +1056,9 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
" \n"
"Da das Ändern der Shader-Optionen \n"
"einiges an Rechenleistung erfordert, \n"
"musst Du die Option manuell auslösen. \n"
"musst du die Option manuell auslösen. \n"
" \n"
"Wenn Du Shader anwendest, werden die Menüeinstellungen \n"
"Wenn du Shader anwendest, werden die Menüeinstellungen \n"
"in einer temporären Datei gespeichert (entweder \n"
"menu.cgp oder menu.glslp) und geladen. Die Datei \n"
"bleibt nach dem Beenden von RetroArch bestehen. Die Datei \n"
@ -1060,7 +1067,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_MENU_TOGGLE:
snprintf(s, len,
"Menü aufrufen.");
"Menü aufrufen und schließen.");
break;
case MENU_ENUM_LABEL_GRAB_MOUSE_TOGGLE:
snprintf(s, len,
@ -1126,29 +1133,22 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Verwendet für Inhalt, der auf mehreren Datenträgern ausgeliefert wird. ");
break;
case MENU_ENUM_LABEL_ENABLE_HOTKEY:
{
/* Work around C89 limitations */
char u[501];
const char * t =
"Andere Hotkeys aktivieren. \n"
snprintf(s, len,
"Andere Tastenkürzel aktivieren. \n"
" \n"
"Wenn dieses Tastenkürzel entweder einer\n"
"Tastatur, einer Controller-Taste oder \n"
"Controller-Achse zugeordnet ist, werden alle \n"
"anderen Tastenkürzel nur aktiviert, wenn dieses \n"
"Tastenkürzel zur gleichen Zeit gehalten wird. \n"
" \n"
"Wenn dieser Hotkey entweder einer\n"
"Tastatur, einem Joypad-Taste oder \n"
"Joypad-Achse zugeordnet ist, werden alle \n"
"anderen Hotkeys nur aktiviert, wenn dieser \n"
"Hotkey zur gleichen Zeit gehalten wird. \n"
" \n";
snprintf(u, sizeof(u),
"Dies ist hilfreich für Implementierungen, die auf \n"
"RETRO_KEYBOARD ausgelegt sind und eine große \n"
"Fläche auf der Tastatur benötigen, wo es nicht \n"
"gewünscht ist, dass es zu Kollisionen mit Hotkeys kommt \n."
"gewünscht ist, dass es zu Kollisionen mit Tastenkürzeln kommt \n."
" \n"
"Alternativ können auch alle Tastatur-Hotkeys durch \n"
"Alternativ können auch alle Tastatur-Kürzel durch \n"
"den Benutzer deaktiviert werden.");
strlcpy(s, t, len);
strlcat(s, u, len);
}
break;
case MENU_ENUM_LABEL_REWIND_ENABLE:
snprintf(s, len,
@ -1162,20 +1162,16 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Core-Verzeichnis. \n"
" \n"
"Ein Verzeichnis, in welchem nach \n"
"libretro-Core-Implementierungen gesucht wird.");
"Libretro-Core-Implementierungen gesucht wird.");
break;
case MENU_ENUM_LABEL_VIDEO_REFRESH_RATE_AUTO:
{
/* Work around C89 limitations */
char u[501];
const char * t =
snprintf(s, len,
"Bildwiederholrate.\n"
" \n"
"Die genaue Bildwiederholrate Deines Bildschirms (Hz).\n"
"Die genaue Bildwiederholrate deines Bildschirms (Hz).\n"
"Diese wird verwendet, um die Audio-Eingaberate mithilfe \n"
"der folgenden Formel zu berechnen: \n"
" \n";
snprintf(u, sizeof(u),
" \n"
"audio_input_rate = Spiel-Eingaberate * Bildschirm- \n"
"Wiederholrate / Spiel-Wiederholrate\n"
" \n"
@ -1184,11 +1180,8 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"angenommen.\n"
" \n"
"Dieser Wert sollte nahe 60Hz liegen, um Tonsprünge zu vermeiden. \n"
"Wenn Dein Bildschirm nicht auf 60Hz oder einem ähnlichen Wert läuft, \n"
"Wenn dein Bildschirm nicht auf 60Hz oder einem ähnlichen Wert läuft, \n"
"deaktiviere VSync und lasse diese Einstellung unverändert. \n");
strlcpy(s, t, len);
strlcat(s, u, len);
}
break;
case MENU_ENUM_LABEL_VIDEO_ROTATION:
snprintf(s, len,
@ -1196,15 +1189,15 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Bildschirm-Rotation.\n"
" \n"
"Diese Drehung wird zu den Drehungen hinzugefügt, \n"
"die durch den libretro-Core festgelegt werden. (siehe 'Erlaube \n"
"die durch den Libretro-Core festgelegt werden. (siehe 'Erlaube \n"
"Bild-Drehung').");
break;
case MENU_ENUM_LABEL_VIDEO_SCALE:
snprintf(s, len,
"Vollbild-Auflösung.\n"
" \n"
"Auflösung von 0 verwendet die \n"
"Auflösung der Umgebung. \n");
"Eine Auflösung von 0 verwendet die \n"
"Auflösung des Systems. \n");
break;
case MENU_ENUM_LABEL_FASTFORWARD_RATIO:
snprintf(s, len,
@ -1288,8 +1281,8 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
snprintf(s, len,
"Wechselt zum nächsten Overlay.\n"
" \n"
/* Translation unclear, disabled for now. Some context would be really helpful.
* "Wraps around." */
"Wenn das letzte Overlay erreicht ist, wird \n"
"wieder beim ersten Overlay begonnen."
);
break;
case MENU_ENUM_LABEL_LOG_VERBOSITY:
@ -1327,11 +1320,11 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
case MENU_ENUM_LABEL_SAVESTATE_AUTO_SAVE:
case MENU_ENUM_LABEL_SAVESTATE_AUTO_LOAD:
snprintf(s, len,
"Erstellt einen Spielstand automatisch, \n"
"Speichert den aktuellen Zustand automatisch, \n"
"wenn RetroArch beendet wird .\n"
" \n"
"RetroArch wird Spielstände in diesem Pfad automatisch \n"
"nach dem Starten laden, wenn 'Spielstand automatisch laden' \n"
"RetroArch wird die Zustandsdaten in diesem Pfad automatisch \n"
"nach dem Starten laden, wenn 'Zustand automatisch laden' \n"
"aktiviert ist.");
break;
case MENU_ENUM_LABEL_VIDEO_THREADED:
@ -1359,7 +1352,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Rückspul-Genauigkeit.\n"
" \n"
"Wenn eine festgelegte Anzahl von Frames zurückgespult \n"
"wird, kannst Du mehrere Frames auf einmal \n"
"wird, kannst du mehrere Frames auf einmal \n"
"zurückspulen, was die Rückspul-Geschwindigkeit \n"
"erhöht.");
break;
@ -1416,8 +1409,8 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_BLOCK_SRAM_OVERWRITE:
snprintf(s, len,
"Verhindert, dass SRAM überschrieben wird, \n"
"wenn Spielstände geladen werden.\n"
"Verhindert, dass der SRAM-Inhalt überschrieben wird, \n"
"wenn Zustandsdaten (Savestates) geladen werden.\n"
" \n"
"Kann zu fehlerhaften Spielen führen.");
break;
@ -1458,13 +1451,13 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_SAVESTATE_DIRECTORY:
snprintf(s, len,
"Verzeichnis für Spielstände. \n"
"Verzeichnis für Zustandsdaten (Savestates). \n"
" \n"
"Speichert alle Spielstände (*.state) in diesem \n"
"Speichert alle Zustandsdaten (*.state) in diesem \n"
"Verzeichnis.\n"
" \n"
"Explizite Optionen über die Kommandozeile überschreiben \n"
"diese Einstellung.");
"Diese Einstellung kann mithilfe von Kommandozeilen-Optionen \n"
"überschrieben werden.");
break;
case MENU_ENUM_LABEL_ASSETS_DIRECTORY:
snprintf(s, len,
@ -1540,7 +1533,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_PAUSE_LIBRETRO:
snprintf(s, len,
"Wenn deaktiviert wird der libretro-Core im \n"
"Wenn deaktiviert, wird der Libretro-Core im \n"
"Hintergrund weiter laufen, wenn wir uns \n"
"im Menü befinden.");
break;
@ -1601,15 +1594,11 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"tritt keine Netplay-Verzögerung auf.\n");
break;
case MENU_ENUM_LABEL_NETPLAY_CHECK_FRAMES:
{
/* Work around C89 limitations */
char u[501];
const char *t =
snprintf(s, len,
"Die Frequenz in Einzelbildern, mit der Netplay \n"
"sicherstellen wird, dass Host und Clients \n"
"synchronisiert sind. \n"
" \n";
snprintf(u, sizeof(u),
" \n"
"Bei den meisten Cores wird diese Einstellungen \n"
"keine sichtbaren Auswirkungen haben und kann ignoriert werden. \n"
"Bei nichtdeterministischen Cores legt dieser Wert fest, \n"
@ -1619,9 +1608,6 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"Leistungsprobleme verursachen. Auf 0 setzen, um keine \n"
"Überprüfungen durchzuführen. Diese Einstellung wird nur \n"
"auf dem Netplay-Host verwendet. \n");
strlcpy(s, t, len);
strlcat(s, u, len);
}
break;
case MENU_ENUM_LABEL_NETPLAY_INPUT_LATENCY_FRAMES_MIN:
snprintf(s, len,
@ -1650,7 +1636,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_NETPLAY_NAT_TRAVERSAL:
snprintf(s, len,
"Versuche, beim Hosten eines Spiels auf eingehende \n"
"Versucht, beim Hosten eines Spiels auf eingehende \n"
"Verbindungen aus dem öffentlichen Internet zu hören. \n"
"Dabei werden UPnP oder ähnliche Techniken verwendet, \n"
"um das eigene LAN zu verlassen. \n");
@ -1712,18 +1698,18 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_DYNAMIC_WALLPAPER:
snprintf(s, len,
"Lade ein neues Hintergrundbild dynamisch, \n"
"Lädt ein neues Hintergrundbild dynamisch, \n"
"abhängig vom aktuellen Kontext.");
break;
case MENU_ENUM_LABEL_CORE_UPDATER_BUILDBOT_URL:
snprintf(s, len,
"URL zum Core-Verzeichnis auf dem \n"
"libretro-Server.");
"Libretro-Server.");
break;
case MENU_ENUM_LABEL_BUILDBOT_ASSETS_URL:
snprintf(s, len,
"URL zum Assets-Verzeichnis auf dem \n"
"libretro-Server.");
"Libretro-Server.");
break;
case MENU_ENUM_LABEL_INPUT_REMAP_BINDS_ENABLE:
snprintf(s, len,
@ -1745,13 +1731,13 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_CORE_UPDATER_AUTO_EXTRACT_ARCHIVE:
snprintf(s, len,
"Entpacke Archive, die heruntergeladenen Inhalt \n"
"Entpackt Archive, die heruntergeladenen Inhalt \n"
"enthalten, nach dem Herunterladen \n"
"automatisch.");
break;
case MENU_ENUM_LABEL_NAVIGATION_BROWSER_FILTER_SUPPORTED_EXTENSIONS_ENABLE:
snprintf(s, len,
"Filtere die angezeigten Dateien nach \n"
"Filtert die angezeigten Dateien nach \n"
"unterstützten Dateierweiterungen.");
break;
case MENU_ENUM_LABEL_NETPLAY_NICKNAME:
@ -1761,8 +1747,8 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_NETPLAY_CLIENT_SWAP_INPUT:
snprintf(s, len,
"Verwende Tastenbelegung für Spieler 1, \n"
"wenn Du Teilnehmer an einem Netplay-Spiel bist.");
"Verwendet Tastenbelegung für Spieler 1, \n"
"wenn du Teilnehmer an einem Netplay-Spiel bist.");
break;
case MENU_ENUM_LABEL_NETPLAY_TCP_UDP_PORT:
snprintf(s, len,
@ -1771,7 +1757,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_NETPLAY_SPECTATOR_MODE_ENABLE:
snprintf(s, len,
"Aktiviere oder deaktiviere Beobachtermodus\n"
"Aktiviert oder deaktiviert Beobachtermodus\n"
"für den Benutzer im Netplay-Spiel.");
break;
case MENU_ENUM_LABEL_NETPLAY_IP_ADDRESS:
@ -1791,11 +1777,11 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_STDIN_CMD_ENABLE:
snprintf(s, len,
"Aktiviere stdin-Kommandozeile.");
"Aktiviert stdin-Kommandozeile.");
break;
case MENU_ENUM_LABEL_UI_COMPANION_START_ON_BOOT:
snprintf(s, len,
"Starte begleitenden Treiber für Benutzeroberfläche \n"
"Startet begleitenden Treiber für Benutzeroberfläche \n"
"während des Bootens (wenn verfügbar).");
break;
case MENU_ENUM_LABEL_MENU_DRIVER:
@ -1803,7 +1789,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_INPUT_MENU_ENUM_TOGGLE_GAMEPAD_COMBO:
snprintf(s, len,
"Gamepad-Tastenkombination, um Menü aufzurufen. \n"
"Controller-Tastenkombination, um Menü aufzurufen. \n"
" \n"
"0 - Keine \n"
"1 - Drücke L + R + Y + D-Pad nach unten \n"
@ -1818,9 +1804,9 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_INPUT_AUTODETECT_ENABLE:
snprintf(s, len,
"Aktiviere automatische Eingabe-Erkennung.\n"
"Aktiviert automatische Eingabe-Erkennung.\n"
" \n"
"Wird versuchen, Joypads automatisch zu konfigurieren. \n"
"Wird versuchen, Controller automatisch zu konfigurieren. \n"
"(Plug-and-Play).");
break;
case MENU_ENUM_LABEL_CAMERA_ALLOW:
@ -1863,7 +1849,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
snprintf(s, len,
"Taste zum sauberen Beenden von RetroArch."
#if !defined(RARCH_MOBILE) && !defined(RARCH_CONSOLE)
"\nWenn Du RetroArch 'unsanft' beendest (SIGKILL, \n"
"\nWenn du RetroArch 'unsanft' beendest (SIGKILL, \n"
"etc), werden RAM-Speicher etc. nicht gespeichert.\n"
"Auf Unix-ähnlichen Systemen erlaubt\n"
"SIGINT/SIGTERM ein sauberes\n"
@ -1951,9 +1937,9 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
"RetroArch selbst tut nichts. \n"
" \n"
"Damit RetroArch etwas tut, musst \n"
"Du ein Programm hineinladen. \n"
"du ein Programm hineinladen. \n"
"\n"
"Wir nennen diese Programme 'libretro-Core', \n"
"Wir nennen diese Programme 'Libretro-Core', \n"
"oder einfach nur 'Core'. \n"
" \n"
"Um einen Core zu laden, verwende \n"
@ -1961,7 +1947,7 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
" \n"
#ifdef HAVE_NETWORKING
"Du kannst die Cores auf mehreren Wegen beziehen: \n"
"* Herunterladen, indem Du\n"
"* Herunterladen, indem du\n"
"'%s' -> '%s' verwendest. \n"
"* Manuell ins Verzeichnis \n"
"'%s' kopieren.",
@ -1978,27 +1964,59 @@ int menu_hash_get_help_de_enum(enum msg_hash_enums msg, char *s, size_t len)
break;
case MENU_ENUM_LABEL_VALUE_HELP_CHANGE_VIRTUAL_GAMEPAD_DESC:
snprintf(s, len,
"Du kannst das virtuelle Gamepad-Overlay ändern, indem Du \n"
"Du kannst das virtuelle Controller-Overlay ändern, indem du \n"
"zu '%s' -> '%s' gehst."
" \n"
"Hier kannst du das Overlay ändern,\n"
"die Größe und Transparenz der Tasten verändern, etc.\n"
" \n"
"HINWEIS: Standardmäßig werden virtuelle Gamepad-Overlays \n"
"versteckt, wenn Du dich im Menü befindest.\n"
"Wenn Du dieses Verhalten ändern möchtest,\n"
"kannst Du '%s' auf 'aus' setzen.",
"HINWEIS: Standardmäßig werden virtuelle Controller-Overlays \n"
"versteckt, wenn du dich im Menü befindest.\n"
"Wenn du dieses Verhalten ändern möchtest,\n"
"kannst du '%s' auf 'aus' setzen.",
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_SETTINGS),
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_OVERLAY_SETTINGS),
msg_hash_to_str(MENU_ENUM_LABEL_VALUE_INPUT_OVERLAY_HIDE_IN_MENU)
);
break;
case MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_BGCOLOR_ENABLE:
snprintf(s, len,
"Verwendet eine Hintergrundfarbe für das OSD.");
break;
case MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_BGCOLOR_RED:
snprintf(s, len,
"Legt den Rot-Anteil der OSD-Hintergrundfarbe fest. Gültige Werte liegen zwischen 0 und 255.");
break;
case MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_BGCOLOR_GREEN:
snprintf(s, len,
"Legt den Grün-Anteil der OSD-Hintergrundfarbe fest. Gültige Werte liegen zwischen 0 und 255.");
break;
case MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_BGCOLOR_BLUE:
snprintf(s, len,
"Legt den Blau-Anteil der OSD-Hintergrundfarbe fest. Gültige Werte liegen zwischen 0 und 255.");
break;
case MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_BGCOLOR_OPACITY:
snprintf(s, len,
"Legt die Transparenz der OSD-Hintergrundfarbe fest. Gültige Werte liegen zwischen 0.0 und 1.0.");
break;
case MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_COLOR_RED:
snprintf(s, len,
"Legt den Rot-Anteil der OSD-Textfarbe fest. Gültige Werte liegen zwischen 0 und 255.");
break;
case MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_COLOR_GREEN:
snprintf(s, len,
"Legt den Grün-Anteil der OSD-Textfarbe fest. Gültige Werte liegen zwischen 0 und 255.");
break;
case MENU_ENUM_LABEL_VALUE_VIDEO_MESSAGE_COLOR_BLUE:
snprintf(s, len,
"Legt den Blau-Anteil der OSD-Textfarbe fest. Gültige Werte liegen zwischen 0 und 255.");
break;
default:
if (string_is_empty(s))
strlcpy(s, msg_hash_to_str(MENU_ENUM_LABEL_VALUE_NO_INFORMATION_AVAILABLE), len);
return -1;
}
return 0;
}

450
intl/msg_hash_de.h
View File

File diff suppressed because it is too large Load Diff

4
intl/msg_hash_eo.h
View File

@ -1570,6 +1570,8 @@ MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_PIXEL,
"Pixel")
MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_RETROACTIVE,
"RetroActive")
MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_RETROSYSTEM,
"Retrosystem")
MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_DOTART,
"Dot-Art")
MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME,
@ -2052,6 +2054,8 @@ MSG_HASH(MSG_SKIPPING_SRAM_LOAD,
"Skipping SRAM load.")
MSG_HASH(MSG_SLOW_MOTION,
"Slow motion.")
MSG_HASH(MSG_FAST_FORWARD,
"Fast forward.")
MSG_HASH(MSG_SLOW_MOTION_REWIND,
"Slow motion rewind.")
MSG_HASH(MSG_SRAM_WILL_NOT_BE_SAVED,

2
intl/msg_hash_es.c
View File

@ -1469,6 +1469,8 @@ const char *msg_hash_to_str_es(enum msg_hash_enums msg)
return "Omitiendo carga de SRAM.";
case MSG_SLOW_MOTION:
return "Cámara lenta.";
case MSG_FAST_FORWARD:
return "Avance rápido.";
case MSG_SLOW_MOTION_REWIND:
return "Rebobinar cámara lenta.";
case MSG_SRAM_WILL_NOT_BE_SAVED:

4
intl/msg_hash_fr.h
View File

@ -1695,6 +1695,8 @@ MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_PIXEL,
"Pixel")
MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_RETROACTIVE,
"RetroActive")
MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_RETROSYSTEM,
"Retrosystem")
MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_ICON_THEME_DOTART,
"Dot-Art")
MSG_HASH(MENU_ENUM_LABEL_VALUE_XMB_MENU_COLOR_THEME,
@ -2183,6 +2185,8 @@ MSG_HASH(MSG_SKIPPING_SRAM_LOAD,
"Ignore le chargement de la SRAM.")
MSG_HASH(MSG_SLOW_MOTION,
"Ralenti.")
MSG_HASH(MSG_FAST_FORWARD,
"Avance rapide.")
MSG_HASH(MSG_SLOW_MOTION_REWIND,
"Rembobinage ralenti.")
MSG_HASH(MSG_SRAM_WILL_NOT_BE_SAVED,

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