ShuriZma
/
pcsx2
mirror of https://github.com/PCSX2/pcsx2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

1.0 branch: Merge back cmake changes, the debian unstable directory changes and the whole of zzogl-pg. 

git-svn-id: http://pcsx2.googlecode.com/svn/branches/1.0.0@5250 96395faa-99c1-11dd-bbfe-3dabce05a288
This commit is contained in:
ramapcsx2 2012-05-31 18:40:35 +00:00
parent 309516bc2b
commit fd6511fc6e
55 changed files with 2862 additions and 999 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -1,8 +1,8 @@
# Project Name
project(Pcsx2)
# There is some incompatible change with version 2.6 and below !
cmake_minimum_required(VERSION 2.8)
# Debian-based distributions require at least 2.8.5 due to multiarch.
cmake_minimum_required(VERSION 2.8.5)
# Variable to check that people use the good file
set(TOP_CMAKE_WAS_SOURCED TRUE)

10
cmake/BuildParameters.cmake
View File

@ -20,6 +20,7 @@
### Packaging options
# Installation path : -DPACKAGE_MODE=TRUE(follow FHS)|FALSE(local bin/)
# Plugin installation path : -DPLUGIN_DIR="/usr/lib/pcsx2"
# GL Shader installation path : -DGLSL_SHADER_DIR="/usr/share/games/pcsx2"
# Game DB installation path : -DGAMEINDEX_DIR="/var/games/pcsx2"
# Follow XDG standard : -DXDG_STD=TRUE|FALSE
#-------------------------------------------------------------------------------
@ -123,7 +124,7 @@ set(CMAKE_SHARED_LIBRARY_CXX_FLAGS "")
#-------------------------------------------------------------------------------
# Set some default compiler flags
#-------------------------------------------------------------------------------
set(DEFAULT_WARNINGS "-Wno-write-strings -Wno-format -Wno-unused-parameter -Wno-unused-value -Wstrict-aliasing")
set(DEFAULT_WARNINGS "-Wno-write-strings -Wno-format -Wno-unused-parameter -Wno-unused-value -Wstrict-aliasing -Wno-unused-function")
set(DEFAULT_GCC_FLAG "-m32 -msse -msse2 -march=i686 -pthread ${DEFAULT_WARNINGS}")
set(DEFAULT_CPP_FLAG "${DEFAULT_GCC_FLAG} -Wno-invalid-offsetof")
@ -183,8 +184,13 @@ if(PACKAGE_MODE)
set(GAMEINDEX_DIR "/var/games/pcsx2")
endif(NOT DEFINED GAMEINDEX_DIR)
# Compile all source codes with these 2 defines
if(NOT DEFINED GLSL_SHADER_DIR)
set(GLSL_SHADER_DIR "/usr/share/games/pcsx2")
endif(NOT DEFINED GLSL_SHADER_DIR)
# Compile all source codes with these 3 defines
add_definitions(-DPLUGIN_DIR_COMPILATION=${PLUGIN_DIR} -DGAMEINDEX_DIR_COMPILATION=${GAMEINDEX_DIR})
add_definitions(-DGLSL_SHADER_DIR_COMPILATION=${GLSL_SHADER_DIR})
endif(PACKAGE_MODE)
#-------------------------------------------------------------------------------

594
cmake/FindGTK2_pcsx2.cmake
View File

@ -1,594 +0,0 @@
# - FindGTK2.cmake
# This module can find the GTK2 widget libraries and several of its other
# optional components like gtkmm, glade, and glademm.
#
# NOTE: If you intend to use version checking, CMake 2.6.2 or later is
# required.
#
# Specify one or more of the following components
# as you call this find module. See example below.
#
# gtk
# gtkmm
# glade
# glademm
#
# The following variables will be defined for your use
#
# GTK2_FOUND - Were all of your specified components found?
# GTK2_INCLUDE_DIRS - All include directories
# GTK2_LIBRARIES - All libraries
#
# GTK2_VERSION - The version of GTK2 found (x.y.z)
# GTK2_MAJOR_VERSION - The major version of GTK2
# GTK2_MINOR_VERSION - The minor version of GTK2
# GTK2_PATCH_VERSION - The patch version of GTK2
#
# Optional variables you can define prior to calling this module:
#
# GTK2_DEBUG - Enables verbose debugging of the module
# GTK2_SKIP_MARK_AS_ADVANCED - Disable marking cache variables as advanced
# GTK2_ADDITIONAL_SUFFIXES - Allows defining additional directories to
# search for include files
#
#=================
# Example Usage:
#
# Call find_package() once, here are some examples to pick from:
#
# Require GTK 2.6 or later
# find_package(GTK2 2.6 REQUIRED gtk)
#
# Require GTK 2.10 or later and Glade
# find_package(GTK2 2.10 REQUIRED gtk glade)
#
# Search for GTK/GTKMM 2.8 or later
# find_package(GTK2 2.8 COMPONENTS gtk gtkmm)
#
# if(GTK2_FOUND)
# include_directories(${GTK2_INCLUDE_DIRS})
# add_executable(mygui mygui.cc)
# target_link_libraries(mygui ${GTK2_LIBRARIES})
# endif()
#
#=============================================================================
# Copyright 2009 Kitware, Inc.
# Copyright 2008-2009 Philip Lowman <philip@yhbt.com>
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
# (To distribute this file outside of CMake, substitute the full
# License text for the above reference.)
# Version 1.3 (11/9/2010) (CMake 2.8.4)
# * 11429: Add support for detecting GTK2 built with Visual Studio 10.
# Thanks to Vincent Levesque for the patch.
# Version 1.2 (8/30/2010) (CMake 2.8.3)
# * Merge patch for detecting gdk-pixbuf library (split off
# from core GTK in 2.21). Thanks to Vincent Untz for the patch
# and Ricardo Cruz for the heads up.
# Version 1.1 (8/19/2010) (CMake 2.8.3)
# * Add support for detecting GTK2 under macports (thanks to Gary Kramlich)
# Version 1.0 (8/12/2010) (CMake 2.8.3)
# * Add support for detecting new pangommconfig.h header file
# (Thanks to Sune Vuorela & the Debian Project for the patch)
# * Add support for detecting fontconfig.h header
# * Call find_package(Freetype) since it's required
# * Add support for allowing users to add additional library directories
# via the GTK2_ADDITIONAL_SUFFIXES variable (kind of a future-kludge in
# case the GTK developers change versions on any of the directories in the
# future).
# Version 0.8 (1/4/2010)
# * Get module working under MacOSX fink by adding /sw/include, /sw/lib
# to PATHS and the gobject library
# Version 0.7 (3/22/09)
# * Checked into CMake CVS
# * Added versioning support
# * Module now defaults to searching for GTK if COMPONENTS not specified.
# * Added HKCU prior to HKLM registry key and GTKMM specific environment
# variable as per mailing list discussion.
# * Added lib64 to include search path and a few other search paths where GTK
# may be installed on Unix systems.
# * Switched to lowercase CMake commands
# * Prefaced internal variables with _GTK2 to prevent collision
# * Changed internal macros to functions
# * Enhanced documentation
# Version 0.6 (1/8/08)
# Added GTK2_SKIP_MARK_AS_ADVANCED option
# Version 0.5 (12/19/08)
# Second release to cmake mailing list
#=============================================================
# _GTK2_GET_VERSION
# Internal function to parse the version number in gtkversion.h
# _OUT_major = Major version number
# _OUT_minor = Minor version number
# _OUT_micro = Micro version number
# _gtkversion_hdr = Header file to parse
#=============================================================
function(_GTK2_GET_VERSION _OUT_major _OUT_minor _OUT_micro _gtkversion_hdr)
file(READ ${_gtkversion_hdr} _contents)
if(_contents)
string(REGEX REPLACE ".*#define GTK_MAJOR_VERSION[ \t]+\\(([0-9]+)\\).*" "\\1" ${_OUT_major} "${_contents}")
string(REGEX REPLACE ".*#define GTK_MINOR_VERSION[ \t]+\\(([0-9]+)\\).*" "\\1" ${_OUT_minor} "${_contents}")
string(REGEX REPLACE ".*#define GTK_MICRO_VERSION[ \t]+\\(([0-9]+)\\).*" "\\1" ${_OUT_micro} "${_contents}")
if(NOT ${_OUT_major} MATCHES "[0-9]+")
message(FATAL_ERROR "Version parsing failed for GTK2_MAJOR_VERSION!")
endif()
if(NOT ${_OUT_minor} MATCHES "[0-9]+")
message(FATAL_ERROR "Version parsing failed for GTK2_MINOR_VERSION!")
endif()
if(NOT ${_OUT_micro} MATCHES "[0-9]+")
message(FATAL_ERROR "Version parsing failed for GTK2_MICRO_VERSION!")
endif()
set(${_OUT_major} ${${_OUT_major}} PARENT_SCOPE)
set(${_OUT_minor} ${${_OUT_minor}} PARENT_SCOPE)
set(${_OUT_micro} ${${_OUT_micro}} PARENT_SCOPE)
else()
message(FATAL_ERROR "Include file ${_gtkversion_hdr} does not exist")
endif()
endfunction()
#=============================================================
# _GTK2_FIND_INCLUDE_DIR
# Internal function to find the GTK include directories
# _var = variable to set
# _hdr = header file to look for
#=============================================================
function(_GTK2_FIND_INCLUDE_DIR _var _hdr)
if(GTK2_DEBUG)
message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] "
"_GTK2_FIND_INCLUDE_DIR( ${_var} ${_hdr} )")
endif()
set(_relatives
# If these ever change, things will break.
${GTK2_ADDITIONAL_SUFFIXES}
glibmm-2.4
glib-2.0
atk-1.0
atkmm-1.6
cairo
cairomm-1.0
gdk-pixbuf-2.0
gdkmm-2.4
giomm-2.4
gtk-2.0
gtkmm-2.4
libglade-2.0
libglademm-2.4
pango-1.0
pangomm-1.4
sigc++-2.0
)
set(_suffixes)
foreach(_d ${_relatives})
list(APPEND _suffixes ${_d})
list(APPEND _suffixes ${_d}/include) # for /usr/lib/gtk-2.0/include
endforeach()
if(GTK2_DEBUG)
message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] "
"include suffixes = ${_suffixes}")
endif()
find_path(${_var} ${_hdr}
PATHS
# FIXME workaround of ubuntu 11.04 multiarch bug
# Hopefully PCSX2 only needs the i386 versions.
/usr/lib/i386-linux-gnu
# END
/usr/local/lib64
/usr/local/lib
/usr/lib64
/usr/lib
/opt/gnome/include
/opt/gnome/lib
/opt/openwin/include
/usr/openwin/lib
/sw/include
/sw/lib
/opt/local/include
/opt/local/lib
$ENV{GTKMM_BASEPATH}/include
$ENV{GTKMM_BASEPATH}/lib
[HKEY_CURRENT_USER\\SOFTWARE\\gtkmm\\2.4;Path]/include
[HKEY_CURRENT_USER\\SOFTWARE\\gtkmm\\2.4;Path]/lib
[HKEY_LOCAL_MACHINE\\SOFTWARE\\gtkmm\\2.4;Path]/include
[HKEY_LOCAL_MACHINE\\SOFTWARE\\gtkmm\\2.4;Path]/lib
PATH_SUFFIXES
${_suffixes}
)
if(${_var})
set(GTK2_INCLUDE_DIRS ${GTK2_INCLUDE_DIRS} ${${_var}} PARENT_SCOPE)
if(NOT GTK2_SKIP_MARK_AS_ADVANCED)
mark_as_advanced(${_var})
endif()
endif()
endfunction(_GTK2_FIND_INCLUDE_DIR)
#=============================================================
# _GTK2_FIND_LIBRARY
# Internal function to find libraries packaged with GTK2
# _var = library variable to create
#=============================================================
function(_GTK2_FIND_LIBRARY _var _lib _expand_vc _append_version)
if(GTK2_DEBUG)
message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] "
"_GTK2_FIND_LIBRARY( ${_var} ${_lib} ${_expand_vc} ${_append_version} )")
endif()
# Not GTK versions per se but the versions encoded into Windows
# import libraries (GtkMM 2.14.1 has a gtkmm-vc80-2_4.lib for example)
# Also the MSVC libraries use _ for . (this is handled below)
set(_versions 2.20 2.18 2.16 2.14 2.12
2.10 2.8 2.6 2.4 2.2 2.0
1.20 1.18 1.16 1.14 1.12
1.10 1.8 1.6 1.4 1.2 1.0)
set(_library)
set(_library_d)
set(_library ${_lib})
if(_expand_vc AND MSVC)
# Add vc80/vc90/vc100 midfixes
if(MSVC80)
set(_library ${_library}-vc80)
elseif(MSVC90)
set(_library ${_library}-vc90)
elseif(MSVC10)
set(_library ${_library}-vc100)
endif()
set(_library_d ${_library}-d)
endif()
if(GTK2_DEBUG)
message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] "
"After midfix addition = ${_library} and ${_library_d}")
endif()
set(_lib_list)
set(_libd_list)
if(_append_version)
foreach(_ver ${_versions})
list(APPEND _lib_list "${_library}-${_ver}")
list(APPEND _libd_list "${_library_d}-${_ver}")
endforeach()
else()
set(_lib_list ${_library})
set(_libd_list ${_library_d})
endif()
if(GTK2_DEBUG)
message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] "
"library list = ${_lib_list} and library debug list = ${_libd_list}")
endif()
# For some silly reason the MSVC libraries use _ instead of .
# in the version fields
if(_expand_vc AND MSVC)
set(_no_dots_lib_list)
set(_no_dots_libd_list)
foreach(_l ${_lib_list})
string(REPLACE "." "_" _no_dots_library ${_l})
list(APPEND _no_dots_lib_list ${_no_dots_library})
endforeach()
# And for debug
set(_no_dots_libsd_list)
foreach(_l ${_libd_list})
string(REPLACE "." "_" _no_dots_libraryd ${_l})
list(APPEND _no_dots_libd_list ${_no_dots_libraryd})
endforeach()
# Copy list back to original names
set(_lib_list ${_no_dots_lib_list})
set(_libd_list ${_no_dots_libd_list})
endif()
if(GTK2_DEBUG)
message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] "
"While searching for ${_var}, our proposed library list is ${_lib_list}")
endif()
find_library(${_var}
NAMES ${_lib_list}
PATHS
/opt/gnome/lib
/opt/gnome/lib64
/usr/openwin/lib
/usr/openwin/lib64
/sw/lib
$ENV{GTKMM_BASEPATH}/lib
[HKEY_CURRENT_USER\\SOFTWARE\\gtkmm\\2.4;Path]/lib
[HKEY_LOCAL_MACHINE\\SOFTWARE\\gtkmm\\2.4;Path]/lib
)
if(_expand_vc AND MSVC)
if(GTK2_DEBUG)
message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] "
"While searching for ${_var}_DEBUG our proposed library list is ${_libd_list}")
endif()
find_library(${_var}_DEBUG
NAMES ${_libd_list}
PATHS
$ENV{GTKMM_BASEPATH}/lib
[HKEY_CURRENT_USER\\SOFTWARE\\gtkmm\\2.4;Path]/lib
[HKEY_LOCAL_MACHINE\\SOFTWARE\\gtkmm\\2.4;Path]/lib
)
if(${_var} AND ${_var}_DEBUG)
if(NOT GTK2_SKIP_MARK_AS_ADVANCED)
mark_as_advanced(${_var}_DEBUG)
endif()
set(GTK2_LIBRARIES ${GTK2_LIBRARIES} optimized ${${_var}} debug ${${_var}_DEBUG})
set(GTK2_LIBRARIES ${GTK2_LIBRARIES} PARENT_SCOPE)
endif()
else()
if(NOT GTK2_SKIP_MARK_AS_ADVANCED)
mark_as_advanced(${_var})
endif()
set(GTK2_LIBRARIES ${GTK2_LIBRARIES} ${${_var}})
set(GTK2_LIBRARIES ${GTK2_LIBRARIES} PARENT_SCOPE)
# Set debug to release
set(${_var}_DEBUG ${${_var}})
set(${_var}_DEBUG ${${_var}} PARENT_SCOPE)
endif()
endfunction(_GTK2_FIND_LIBRARY)
#=============================================================
#
# main()
#
set(GTK2_FOUND)
set(GTK2_INCLUDE_DIRS)
set(GTK2_LIBRARIES)
if(NOT GTK2_FIND_COMPONENTS)
# Assume they only want GTK
set(GTK2_FIND_COMPONENTS gtk)
endif()
#
# If specified, enforce version number
#
if(GTK2_FIND_VERSION)
cmake_minimum_required(VERSION 2.6.2)
set(GTK2_FAILED_VERSION_CHECK true)
if(GTK2_DEBUG)
message(STATUS "[FindGTK2.cmake:${CMAKE_CURRENT_LIST_LINE}] "
"Searching for version ${GTK2_FIND_VERSION}")
endif()
_GTK2_FIND_INCLUDE_DIR(GTK2_GTK_INCLUDE_DIR gtk/gtk.h)
if(GTK2_GTK_INCLUDE_DIR)
_GTK2_GET_VERSION(GTK2_MAJOR_VERSION
GTK2_MINOR_VERSION
GTK2_PATCH_VERSION
${GTK2_GTK_INCLUDE_DIR}/gtk/gtkversion.h)
set(GTK2_VERSION
${GTK2_MAJOR_VERSION}.${GTK2_MINOR_VERSION}.${GTK2_PATCH_VERSION})
if(GTK2_FIND_VERSION_EXACT)
if(GTK2_VERSION VERSION_EQUAL GTK2_FIND_VERSION)
set(GTK2_FAILED_VERSION_CHECK false)
endif()
else()
if(GTK2_VERSION VERSION_EQUAL GTK2_FIND_VERSION OR
GTK2_VERSION VERSION_GREATER GTK2_FIND_VERSION)
set(GTK2_FAILED_VERSION_CHECK false)
endif()
endif()
else()
# If we can't find the GTK include dir, we can't do version checking
if(GTK2_FIND_REQUIRED AND NOT GTK2_FIND_QUIETLY)
message(FATAL_ERROR "Could not find GTK2 include directory")
endif()
return()
endif()
if(GTK2_FAILED_VERSION_CHECK)
if(GTK2_FIND_REQUIRED AND NOT GTK2_FIND_QUIETLY)
if(GTK2_FIND_VERSION_EXACT)
message(FATAL_ERROR "GTK2 version check failed. Version ${GTK2_VERSION} was found, version ${GTK2_FIND_VERSION} is needed exactly.")
else()
message(FATAL_ERROR "GTK2 version check failed. Version ${GTK2_VERSION} was found, at least version ${GTK2_FIND_VERSION} is required")
endif()
endif()
# If the version check fails, exit out of the module here
return()
endif()
endif()
#
# Find all components
#
find_package(Freetype)
list(APPEND GTK2_INCLUDE_DIRS ${FREETYPE_INCLUDE_DIRS})
list(APPEND GTK2_LIBRARIES ${FREETYPE_LIBRARIES})
foreach(_GTK2_component ${GTK2_FIND_COMPONENTS})
if(_GTK2_component STREQUAL "gtk")
_GTK2_FIND_INCLUDE_DIR(GTK2_GLIB_INCLUDE_DIR glib.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_GLIBCONFIG_INCLUDE_DIR glibconfig.h)
_GTK2_FIND_LIBRARY (GTK2_GLIB_LIBRARY glib false true)
_GTK2_FIND_INCLUDE_DIR(GTK2_GOBJECT_INCLUDE_DIR gobject/gobject.h)
_GTK2_FIND_LIBRARY (GTK2_GOBJECT_LIBRARY gobject false true)
_GTK2_FIND_INCLUDE_DIR(GTK2_GDK_PIXBUF_INCLUDE_DIR gdk-pixbuf/gdk-pixbuf.h)
_GTK2_FIND_LIBRARY (GTK2_GDK_PIXBUF_LIBRARY gdk_pixbuf false true)
_GTK2_FIND_INCLUDE_DIR(GTK2_GDK_INCLUDE_DIR gdk/gdk.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_GDKCONFIG_INCLUDE_DIR gdkconfig.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_GTK_INCLUDE_DIR gtk/gtk.h)
if(UNIX)
_GTK2_FIND_LIBRARY (GTK2_GDK_LIBRARY gdk-x11 false true)
_GTK2_FIND_LIBRARY (GTK2_GTK_LIBRARY gtk-x11 false true)
else()
_GTK2_FIND_LIBRARY (GTK2_GDK_LIBRARY gdk-win32 false true)
_GTK2_FIND_LIBRARY (GTK2_GTK_LIBRARY gtk-win32 false true)
endif()
_GTK2_FIND_INCLUDE_DIR(GTK2_CAIRO_INCLUDE_DIR cairo.h)
_GTK2_FIND_LIBRARY (GTK2_CAIRO_LIBRARY cairo false false)
_GTK2_FIND_INCLUDE_DIR(GTK2_FONTCONFIG_INCLUDE_DIR fontconfig/fontconfig.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_PANGO_INCLUDE_DIR pango/pango.h)
_GTK2_FIND_LIBRARY (GTK2_PANGO_LIBRARY pango false true)
_GTK2_FIND_INCLUDE_DIR(GTK2_ATK_INCLUDE_DIR atk/atk.h)
_GTK2_FIND_LIBRARY (GTK2_ATK_LIBRARY atk false true)
elseif(_GTK2_component STREQUAL "gtkmm")
_GTK2_FIND_INCLUDE_DIR(GTK2_GLIBMM_INCLUDE_DIR glibmm.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_GLIBMMCONFIG_INCLUDE_DIR glibmmconfig.h)
_GTK2_FIND_LIBRARY (GTK2_GLIBMM_LIBRARY glibmm true true)
_GTK2_FIND_INCLUDE_DIR(GTK2_GDKMM_INCLUDE_DIR gdkmm.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_GDKMMCONFIG_INCLUDE_DIR gdkmmconfig.h)
_GTK2_FIND_LIBRARY (GTK2_GDKMM_LIBRARY gdkmm true true)
_GTK2_FIND_INCLUDE_DIR(GTK2_GTKMM_INCLUDE_DIR gtkmm.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_GTKMMCONFIG_INCLUDE_DIR gtkmmconfig.h)
_GTK2_FIND_LIBRARY (GTK2_GTKMM_LIBRARY gtkmm true true)
_GTK2_FIND_INCLUDE_DIR(GTK2_CAIROMM_INCLUDE_DIR cairomm/cairomm.h)
_GTK2_FIND_LIBRARY (GTK2_CAIROMM_LIBRARY cairomm true true)
_GTK2_FIND_INCLUDE_DIR(GTK2_PANGOMM_INCLUDE_DIR pangomm.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_PANGOMMCONFIG_INCLUDE_DIR pangommconfig.h)
_GTK2_FIND_LIBRARY (GTK2_PANGOMM_LIBRARY pangomm true true)
_GTK2_FIND_INCLUDE_DIR(GTK2_SIGC++_INCLUDE_DIR sigc++/sigc++.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_SIGC++CONFIG_INCLUDE_DIR sigc++config.h)
_GTK2_FIND_LIBRARY (GTK2_SIGC++_LIBRARY sigc true true)
_GTK2_FIND_INCLUDE_DIR(GTK2_GIOMM_INCLUDE_DIR giomm.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_GIOMMCONFIG_INCLUDE_DIR giommconfig.h)
_GTK2_FIND_LIBRARY (GTK2_GIOMM_LIBRARY giomm true true)
_GTK2_FIND_INCLUDE_DIR(GTK2_ATKMM_INCLUDE_DIR atkmm.h)
_GTK2_FIND_LIBRARY (GTK2_ATKMM_LIBRARY atkmm true true)
elseif(_GTK2_component STREQUAL "glade")
_GTK2_FIND_INCLUDE_DIR(GTK2_GLADE_INCLUDE_DIR glade/glade.h)
_GTK2_FIND_LIBRARY (GTK2_GLADE_LIBRARY glade false true)
elseif(_GTK2_component STREQUAL "glademm")
_GTK2_FIND_INCLUDE_DIR(GTK2_GLADEMM_INCLUDE_DIR libglademm.h)
_GTK2_FIND_INCLUDE_DIR(GTK2_GLADEMMCONFIG_INCLUDE_DIR libglademmconfig.h)
_GTK2_FIND_LIBRARY (GTK2_GLADEMM_LIBRARY glademm true true)
else()
message(FATAL_ERROR "Unknown GTK2 component ${_component}")
endif()
endforeach()
#
# Solve for the GTK2 version if we haven't already
#
if(NOT GTK2_FIND_VERSION AND GTK2_GTK_INCLUDE_DIR)
_GTK2_GET_VERSION(GTK2_MAJOR_VERSION
GTK2_MINOR_VERSION
GTK2_PATCH_VERSION
${GTK2_GTK_INCLUDE_DIR}/gtk/gtkversion.h)
set(GTK2_VERSION ${GTK2_MAJOR_VERSION}.${GTK2_MINOR_VERSION}.${GTK2_PATCH_VERSION})
endif()
#
# Try to enforce components
#
set(_GTK2_did_we_find_everything true) # This gets set to GTK2_FOUND
include(FindPackageHandleStandardArgs)
foreach(_GTK2_component ${GTK2_FIND_COMPONENTS})
string(TOUPPER ${_GTK2_component} _COMPONENT_UPPER)
if(_GTK2_component STREQUAL "gtk")
FIND_PACKAGE_HANDLE_STANDARD_ARGS(GTK2_${_COMPONENT_UPPER} "Some or all of the gtk libraries were not found."
GTK2_GTK_LIBRARY
GTK2_GTK_INCLUDE_DIR
GTK2_GLIB_INCLUDE_DIR
GTK2_GLIBCONFIG_INCLUDE_DIR
GTK2_GLIB_LIBRARY
GTK2_GDK_INCLUDE_DIR
GTK2_GDKCONFIG_INCLUDE_DIR
GTK2_GDK_LIBRARY
)
elseif(_GTK2_component STREQUAL "gtkmm")
FIND_PACKAGE_HANDLE_STANDARD_ARGS(GTK2_${_COMPONENT_UPPER} "Some or all of the gtkmm libraries were not found."
GTK2_GTKMM_LIBRARY
GTK2_GTKMM_INCLUDE_DIR
GTK2_GTKMMCONFIG_INCLUDE_DIR
GTK2_GLIBMM_INCLUDE_DIR
GTK2_GLIBMMCONFIG_INCLUDE_DIR
GTK2_GLIBMM_LIBRARY
GTK2_GDKMM_INCLUDE_DIR
GTK2_GDKMMCONFIG_INCLUDE_DIR
GTK2_GDKMM_LIBRARY
)
elseif(_GTK2_component STREQUAL "glade")
FIND_PACKAGE_HANDLE_STANDARD_ARGS(GTK2_${_COMPONENT_UPPER} "The glade library was not found."
GTK2_GLADE_LIBRARY
GTK2_GLADE_INCLUDE_DIR
)
elseif(_GTK2_component STREQUAL "glademm")
FIND_PACKAGE_HANDLE_STANDARD_ARGS(GTK2_${_COMPONENT_UPPER} "The glademm library was not found."
GTK2_GLADEMM_LIBRARY
GTK2_GLADEMM_INCLUDE_DIR
GTK2_GLADEMMCONFIG_INCLUDE_DIR
)
endif()
if(NOT GTK2_${_COMPONENT_UPPER}_FOUND)
set(_GTK2_did_we_find_everything false)
endif()
endforeach()
if(_GTK2_did_we_find_everything AND NOT GTK2_VERSION_CHECK_FAILED)
set(GTK2_FOUND true)
else()
# Unset our variables.
set(GTK2_FOUND false)
set(GTK2_VERSION)
set(GTK2_VERSION_MAJOR)
set(GTK2_VERSION_MINOR)
set(GTK2_VERSION_PATCH)
set(GTK2_INCLUDE_DIRS)
set(GTK2_LIBRARIES)
endif()
if(GTK2_INCLUDE_DIRS)
list(REMOVE_DUPLICATES GTK2_INCLUDE_DIRS)
endif()

7
cmake/SearchForStuff.cmake
View File

@ -7,12 +7,7 @@ SET(FIND_LIBRARY_USE_LIB64_PATHS FALSE)
## Linux only libraries
if(Linux)
# Most plugins (if not all) and PCSX2 core need gtk2, so set the required flags
#
# Warning: because of multiarch Ubuntu move /usr/lib/glib-2.0/include/glibconfig.h to /usr/lib/i386-linux-gnu/glib-2.0/include/glibconfig.h
# So as temporary work around, I copy the FindGTK2 module inside pcsx2 and add the /usr/lib/i386-linux-gnu path... -- Gregory
#
# find_package(GTK2 REQUIRED gtk)
find_package(GTK2_pcsx2 REQUIRED gtk)
find_package(GTK2 REQUIRED gtk)
if(GTK2_FOUND)
# From version 2.21.3 gtk moved gdk-pixbuf into a separate module
# Cmake need to be fixed. For the moment uses a manual detection.

30
cmake/SelectPcsx2Plugins.cmake
View File

@ -30,6 +30,8 @@ endif(GLSL_API)
#---------------------------------------
if(wxWidgets_FOUND AND SPARSEHASH_FOUND)
set(common_libs TRUE)
elseif(NOT EXISTS "${PROJECT_SOURCE_DIR}/common/src")
set(common_libs FALSE)
else(wxWidgets_FOUND AND SPARSEHASH_FOUND)
set(common_libs FALSE)
message(STATUS "Skip build of common libraries: miss some dependencies")
@ -46,17 +48,19 @@ endif(wxWidgets_FOUND AND SPARSEHASH_FOUND)
# Common dependancy
if(wxWidgets_FOUND AND ZLIB_FOUND AND common_libs)
set(pcsx2_core TRUE)
elseif(NOT EXISTS "${PROJECT_SOURCE_DIR}/pcsx2")
set(pcsx2_core FALSE)
else(wxWidgets_FOUND AND ZLIB_FOUND AND common_libs)
set(pcsx2_core FALSE)
message(STATUS "Skip build of pcsx2 core: miss some dependencies")
message(STATUS "${msg_dep_pcsx2}")
endif(wxWidgets_FOUND AND ZLIB_FOUND AND common_libs)
# Linux need also gtk2
if(Linux AND NOT GTK2_FOUND)
if(Linux AND pcsx2_core AND NOT GTK2_FOUND)
set(pcsx2_core FALSE)
message(STATUS "Skip build of pcsx2 core: miss some dependencies")
message(STATUS "${msg_dep_pcsx2}")
endif(Linux AND NOT GTK2_FOUND)
endif(Linux AND pcsx2_core AND NOT GTK2_FOUND)
#-------------------------------------------------------------------------------
@ -83,6 +87,8 @@ endif(GTK2_FOUND)
#---------------------------------------
if(BZIP2_FOUND AND GTK2_FOUND)
set(CDVDiso TRUE)
elseif(NOT EXISTS "${PROJECT_SOURCE_DIR}/plugins/CDVDiso")
set(CDVDiso FALSE)
else(BZIP2_FOUND AND GTK2_FOUND)
set(CDVDiso FALSE)
message(STATUS "Skip build of CDVDiso: miss some dependencies")
@ -127,6 +133,8 @@ endif(GTK2_FOUND)
#---------------------------------------
if(OPENGL_FOUND AND X11_FOUND)
set(GSdx TRUE)
elseif(NOT EXISTS "${PROJECT_SOURCE_DIR}/plugins/GSdx")
set(GSdx FALSE)
else(OPENGL_FOUND AND X11_FOUND)
set(GSdx FALSE)
message(STATUS "Skip build of GSdx: miss some dependencies")
@ -144,6 +152,8 @@ endif(OPENGL_FOUND AND X11_FOUND)
#---------------------------------------
if(GLEW_FOUND AND OPENGL_FOUND AND X11_FOUND AND CG_FOUND)
set(zerogs TRUE)
elseif(NOT EXISTS "${PROJECT_SOURCE_DIR}/plugins/zerogs")
set(zerogs FALSE)
else(GLEW_FOUND AND OPENGL_FOUND AND X11_FOUND AND CG_FOUND)
set(zerogs FALSE)
message(STATUS "Skip build of zerogs: miss some dependencies")
@ -168,6 +178,10 @@ if((GLEW_FOUND AND OPENGL_FOUND AND X11_FOUND AND JPEG_FOUND AND common_libs) AN
else(CG_FOUND AND NOT GLSL_API)
set(zzoglcg FALSE)
endif(CG_FOUND AND NOT GLSL_API)
elseif(NOT EXISTS "${PROJECT_SOURCE_DIR}/plugins/zzogl-pg")
set(zzogl FALSE)
set(zzoglcg FALSE)
set(REBUILD_SHADER FALSE)
else((GLEW_FOUND AND OPENGL_FOUND AND X11_FOUND AND JPEG_FOUND AND common_libs) AND (CG_FOUND OR GLSL_API))
set(zzogl FALSE)
set(zzoglcg FALSE)
@ -192,6 +206,8 @@ endif(GTK2_FOUND)
#---------------------------------------
if(SDL_FOUND)
set(onepad TRUE)
elseif(NOT EXISTS "${PROJECT_SOURCE_DIR}/plugins/onepad")
set(onepad FALSE)
else(SDL_FOUND)
set(onepad FALSE)
message(STATUS "Skip build of onepad: miss some dependencies")
@ -217,6 +233,8 @@ endif(GTK2_FOUND)
#---------------------------------------
if(ALSA_FOUND AND PORTAUDIO_FOUND AND SOUNDTOUCH_FOUND AND common_libs)
set(spu2-x TRUE)
elseif(NOT EXISTS "${PROJECT_SOURCE_DIR}/plugins/spu2-x")
set(spu2-x FALSE)
else(ALSA_FOUND AND PORTAUDIO_FOUND AND SOUNDTOUCH_FOUND AND common_libs)
set(spu2-x FALSE)
message(STATUS "Skip build of spu2-x: miss some dependencies")
@ -231,16 +249,18 @@ endif(ALSA_FOUND AND PORTAUDIO_FOUND AND SOUNDTOUCH_FOUND AND common_libs)
# -ALSA
# -PortAudio
#---------------------------------------
if(SOUNDTOUCH_FOUND AND ALSA_FOUND)
if(EXISTS "${PROJECT_SOURCE_DIR}/plugins/zerospu2" AND SOUNDTOUCH_FOUND AND ALSA_FOUND)
set(zerospu2 TRUE)
# Comment the next line, if you want to compile zerospu2
set(zerospu2 FALSE)
message(STATUS "Don't build zerospu2. It is super-seeded by spu2x")
else(SOUNDTOUCH_FOUND AND ALSA_FOUND)
elseif(NOT EXISTS "${PROJECT_SOURCE_DIR}/plugins/zerospu2")
set(zerospu2 FALSE)
else(EXISTS "${PROJECT_SOURCE_DIR}/plugins/zerospu2" AND SOUNDTOUCH_FOUND AND ALSA_FOUND)
set(zerospu2 FALSE)
message(STATUS "Skip build of zerospu2: miss some dependencies")
message(STATUS "${msg_dep_zerospu2}")
endif(SOUNDTOUCH_FOUND AND ALSA_FOUND)
endif(EXISTS "${PROJECT_SOURCE_DIR}/plugins/zerospu2" AND SOUNDTOUCH_FOUND AND ALSA_FOUND)
#---------------------------------------
#---------------------------------------

79
debian-unstable-upstream/README.Debian
View File

@ -1,15 +1,72 @@
pcsx2 for debian
=========================
------------------------------
Package information for PCSX2
------------------------------
* This version has some major modifications against the default upstream code.
-> documents are stored in $XDG_CONFIG_HOME instead of $HOME/pcsx2
* The reasons given by upstream as to why they remove -fPIC are the following:
- Code only supports the i386 architecture.
- Code uses the ebx register and this is not compliant with -fPIC.
- The use of -fPIC negatively impacts the performance of the program.
- The .so file are not shared libraries but plug-ins. No program should try
to link with them.
* Documentation needs some love. Feel free to help.
------------------------------------------
Information about the plug-ins for video
------------------------------------------
* -fPIC option was removed for multiple reasons.
- Code only supports the x86 architecture.
- Upstream code uses the ebx register so it's not compliant with PIC.
- Impacts the performance too much.
- Only plugins. No package will link to them.
* The zzogl plug-in comes in two flavors:
- The Nvidia Cg version which requires the non-free nvidia-cg-toolkit
package. Since this package contains GPL-2+ code this plug-in can't be
distributed without an GPL exception allowing linking with non-free
libraries. If the user desires to try this flavor of the plug-in he/she
must:
+ Install the nvidia-cg-dev or nvidia-cg-toolkit package from non-free.
+ Pass "-DGLSL_API=FALSE" to dh_auto_configure in the rules file.
+ Add "usr/lib/*/games/pcsx2/*.dat /usr/share/games/pcsx2/" to the install
file.
+ Compile the program using dpkg-buildpackage.
This plug-in currently provides the greatest compatibility with video cards
and drivers. It currently works with open source drivers like radeon R600.
- The OpenGL Shading Language (GLSL) version which currently only works with
AMD video cards but support for other cards is being worked on.
* The GSdx plug-in currently only supports the OpenGL software renderer.
* The GSdx and zzogl GLSL plug-ins currently require a video card that supports
at least OpenGL 3.0. A noninclusive list of cards that support OpenGL 3.0 is:
- Radeon HD series (except HD2300)
- GeForce 8, 9, 100-series, 200-series, 300-series, 400-series and 500-series
- Intel Sandy Bridge HD Graphics 2000 and 3000
* Currently only the proprietary drivers for AMD and Nvidia have support for
OpenGL 3.0 and above. The GSdx and/or zzogl GLSL plug-ins use the following
extensions/commands that may or may not be completely implemented in the open
source video stack:
- OpenGL 3.0
+ glClearBuffer
+ glGetStringi
+ glVertexAttribI
+ GLX_ARB_create_context
+ GL_APPLE_vertex_array_object
+ GL_ARB_framebuffer_object
- OpenGL 3.1
+ GL_ARB_texture_rectangle (zzogl)
+ GL_ARB_uniform_buffer_object
- OpenGL 3.2
+ GL_ARB_geometry_shader4 (GSdx)
+ GL_ARB_draw_elements_base_vertex
+ GLX_ARB_create_context_profile
- OpenGL 3.3
+ GL_ARB_blend_func_extended (GSdx)
+ GL_ARB_explicit_attrib_location
+ GL_ARB_sampler_objects (GSdx)
- OpenGL 4.1
+ GL_ARB_separate_shader_objects
- OpenGL 4.2
+ GL_ARB_map_buffer_alignment
+ GL_ARB_shading_language_420pack
+ GL_ARB_texture_storage
- Extensions that may get included in future versions:
+ GL_NV_copy_image
The current status for the open source drivers can be found at:
- http://cgit.freedesktop.org/mesa/mesa/tree/docs/GL3.txt
-- Gregory Hainaut <gregory.hainaut@gmail.com> Sat, 24 Apr 2010 23:11:10 +0200

9
debian-unstable-upstream/TODO.debian
View File

@ -1,9 +0,0 @@
* policy bin2cpp tool ??
May be we could pregenerate the file in the upstream tar ball!!
* copyright and doc stuff
Lots of work to do here....
* need to add copyrigh info in Cmake file
## 64 bit
=> see multiarch

2
debian-unstable-upstream/compat
View File

@ -1 +1 @@
7
8

78
debian-unstable-upstream/control
View File

@ -2,16 +2,14 @@ Source: pcsx2.snapshot
Section: contrib/games
Priority: optional
Maintainer: Gregory Hainaut <gregory.hainaut@gmail.com>
# WARNING Natty need at least cmake 2.8.5 (multiarch issue)
Build-Depends: cmake (>= 2.8),
debhelper (>= 7.0.50),
Build-Depends: cmake (>= 2.8.5),
debhelper (>= 8.9),
dpkg-dev (>= 1.15.7),
libasound2-dev,
libbz2-dev,
libgl1-mesa-dev,
# Future GSdx version will need glew1.6. Only Oneiric have it...
# libglew1.6-dev,
libglew-dev (>= 1.6)| libglew1.5-dev,
# GSdx need glew1.6 and would love glew1.7
libglew-dev (>= 1.6)| libglew1.6-dev,
libglu1-mesa-dev,
libgtk2.0-dev (>= 2.16),
libjpeg-dev,
@ -26,49 +24,38 @@ Build-Depends: cmake (>= 2.8),
libcg, nvidia-cg-toolkit (>= 3),
portaudio19-dev,
zlib1g-dev (>= 1:1.2.3.3)
Standards-Version: 3.9.2
Standards-Version: 3.9.3
Homepage: http://pcsx2.net/
Package: pcsx2-unstable
Architecture: i386
# manually add nvidia-cg-toolkit for zzogl (cg pacakge does not provide symbol or shlibs files)
# recommand libasound for alsa plugin for pulseaudio
Depends: ${shlibs:Depends}, ${misc:Depends},
pcsx2-plugins-unstable (>= ${binary:Version})
libcg | nvidia-cg-toolkit (>= 2.1)
Recommends: libasound2-plugins
Conflicts: pcsx2,
pcsx2-data-unstable
Replaces: pcsx2-data-unstable
pcsx2-data-unstable,
pcsx2-l10n-unstable,
pcsx2-plugins-unstable
Replaces: pcsx2-data-unstable,
pcsx2-l10n-unstable,
pcsx2-plugins-unstable
Description: Playstation 2 emulator
PCSX2 is a PlayStation 2 emulator for Windows and Linux.
.
WARNING: It requires a CPU with SSE2 instructions. If your CPU does not support
this instruction set, it does not have enough horse power to run this emulator
anyway.
.
This package includes the main binary file.
Package: pcsx2-plugins-unstable
Architecture: i386
# manually add nvidia-cg-toolkit for zzogl (cg pacakge does not provide symbol or shlibs files)
Depends: ${shlibs:Depends}, ${misc:Depends},
libcg | nvidia-cg-toolkit (>= 2.1)
Recommends: pcsx2-unstable (>= ${binary:Version}),
Conflicts: pcsx2-plugins,
pcsx2-data-unstable
Replaces: pcsx2-data-unstable
Description: Various plugins for PCSX2
PCSX2 is a PlayStation 2 emulator for Windows and Linux.
.
WARNING: It requires a CPU with SSE2 instructions. If your CPU does not support
this instruction set, it does not have enough horse power to run this emulator
anyway.
.
This package includes the plugins for PCSX2.
Package: pcsx2-unstable-dbg
Section: contrib/debug
Priority: extra
Architecture: i386
Depends: ${misc:Depends}, pcsx2-unstable (= ${binary:Version})
Conflicts: pcsx2-dbg
Conflicts: pcsx2-dbg,
pcsx2-plugins-unstable-dbg
Replaces: pcsx2-plugins-unstable-dbg
Description: Debug symbols for pcsx2
PCSX2 is a PlayStation 2 emulator for Windows and Linux.
.
@ -78,32 +65,3 @@ Description: Debug symbols for pcsx2
.
This package contains the debug symbols for PCSX2.
Package: pcsx2-plugins-unstable-dbg
Section: contrib/debug
Priority: extra
Architecture: i386
Depends: ${misc:Depends}, pcsx2-plugins-unstable (= ${binary:Version})
Conflicts: pcsx2-plugins-dbg
Description: Debug symbols of the pcsx2-plugins
PCSX2 is a PlayStation 2 emulator for Windows and Linux.
.
WARNING: It requires a CPU with SSE2 instructions. If your CPU does not support
this instruction set, it does not have enough horse power to run this emulator
anyway.
.
This package contains the debug symbols for the PCSX2 plugins.
Package: pcsx2-l10n-unstable
Section: contrib/localization
Architecture: all
Depends: ${misc:Depends}
Recommends: pcsx2-unstable (>= ${source:Version})
Conflicts: pcsx2-l10n
Description: Language files for PCSX2
PCSX2 is a PlayStation 2 emulator for Windows and Linux.
.
WARNING: It requires a CPU with SSE2 instructions. If your CPU does not support
this instruction set, it does not have enough horse power to run this emulator
anyway.
.
This package contains the localization of the emulator in various languages.

283
debian-unstable-upstream/copyright
View File

@ -1,168 +1,155 @@
This work was packaged for Debian by:
Gregory Hainaut <gregory.hainaut@gmail.com> on Sat, 24 Apr 2010 23:11:10 +0200
It was downloaded from:
http://pcsx2.googlecode.com/svn/
Upstream Author(s):
PCSX2 Dev Team
Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
Upstream-Name: PCSX2
Source: http://code.google.com/p/pcsx2/source
Files: debian/*
Copyright:
2010-2012 Gregory Hainaut <gregory.hainaut@gmail.com>
2010-2012 Miguel Colon <debian.micove@gmail.com>
License: LGPL-3
Copyright (C) 2002-2010 PCSX2 Dev Team
Files: pcsx2/*, common/*, plugins/spu2-x/*, plugins/PadNull/Pad*, plugins/USBnull/*, plugins/FWnull/*, plugins/CDVDnull/CDVD*, plugins/GSnull/*, plugins/dev9null/DEV9.cpp
Files: pcsx2/* common/* plugins/spu2-x/* plugins/PadNull/Pad* plugins/USBnull/* plugins/FWnull/* plugins/CDVDnull/CDVD* plugins/GSnull/* plugins/dev9null/DEV9.cpp
Copyright: 2002-2012 PCSX2 Dev Team
License: LGPL-3+
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This package is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
On Debian systems, the complete text of the GNU Lesser General
Public License version 3 can be found in "/usr/share/common-licenses/LGPL-3".
Files: pcsx2/Mdec.cpp, pcsx2/Mdec.h, pcsx2/RDebug/deci2_drfp.cpp, pcsx2/IPU/mpeg2lib/*, pcsx2/cheatscpp.h, common/include/api/*, plugins/onepad/*, plugins/PadNull/Linux/*, plugins/SPU2null/*, plugins/FWnull/FW.cpp, plugins/zerospu2/*, plugins/zzogl-pg/*, plugins/GSnull/Registers.h, plugins/GSnull/Linux/Linux*, plugins/GSnull/Linux/Config*, plugins/dev9null/DEV9.h, plugins/dev9null/Config.*
Files: pcsx2/Mdec.cpp pcsx2/Mdec.h pcsx2/RDebug/deci2_drfp.cpp pcsx2/IPU/mpeg2lib/* pcsx2/cheatscpp.h common/include/api/* plugins/onepad/* plugins/PadNull/Linux/* plugins/SPU2null/* plugins/FWnull/FW.cpp plugins/zerospu2/* plugins/zzogl-pg/* plugins/GSnull/Registers.h plugins/GSnull/Linux/Linux* plugins/GSnull/Linux/Config* plugins/dev9null/DEV9.h plugins/dev9null/Config.*
Copyright: 2002-2012 PCSX2 Dev Team
License: GPL-2+
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This package is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
On Debian systems, the complete text of the GNU General
Public License version 2 can be found in "/usr/share/common-licenses/GPL-2".
Files: plugins/spu2-x/src/Spu2replay.*, plugins/spu2-x/src/Decode*, plugins/spu2-x/src/Linux/ConfigSoundTouch.cpp, plugins/spu2-x/src/spdif.h, plugins/spu2-x/src/Debug.h
Files: plugins/spu2-x/src/Spu2replay.* plugins/spu2-x/src/Decode* plugins/spu2-x/src/Linux/ConfigSoundTouch.cpp plugins/spu2-x/src/spdif.h plugins/spu2-x/src/Debug.h
Copyright: 2002-2012 PCSX2 Dev Team
License: LGPL-2.1+
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
This package is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
On Debian systems, the complete text of the GNU Lesser General
Public License version 2.1 can be found in "/usr/share/common-licenses/LGPL-2.1".
Files: plugins/zzogl-pg/opengl/glprocs.*
Copyright: 1991-2000, Silicon Graphics, Inc
License: MIT/X11 (BSD like)
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice including the dates of first publication and
either this permission notice or a reference to
http://oss.sgi.com/projects/FreeB/
shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Except as contained in this notice, the name of Silicon Graphics, Inc.
shall not be used in advertising or otherwise to promote the sale, use or
other dealings in this Software without prior written authorization from
Silicon Graphics, Inc.
Copyright: 1991-2000 Silicon Graphics, Inc
License: SGI FREE SOFTWARE LICENSE B 2.0
Files: common/include/intrin_x86.h
Copyright: 2006, KJK::Hyperion <hackbunny@reactos.com>
License: MIT/X11 (BSD like)
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
Copyright: 2006 KJK::Hyperion <hackbunny@reactos.com>
License: Expat
Files: common/src/Utilities/vssprintf.cpp
Copyright: 2002, Michael Ringgaard
License: BSD (3 clause)
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. 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.
3. Neither the name of the project 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 COPYRIGHT OWNER 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.
Copyright: 2002 Michael Ringgaard
License: BSD-3-Clause
Files: plugins/zzogl-pg/opengl/zpipe.cpp
Copyright: public domain
Copyright: not applicable
License: public-domain
Author's Note:
zpipe.c: example of proper use of zlib's inflate() and deflate()
Not copyrighted -- provided to the public domain
Version 1.4 11 December 2005 Mark Adler
Files: plugins/zzogl-pg/opengl/ZeroGSShaders/zerogsshaders*
Copyright: Unknown
License: LGPL-3 or LGPL-3+
This program is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option) any
later version.
.
This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
.
You should have received a copy of the GNU Lesser General Public License along
with this program. If not, see <http://www.gnu.org/licenses/>.
Comment: On Debian systems, the complete text of the GNU Lesser General Public
License version 3 can be found in "/usr/share/common-licenses/LGPL-3".
The Debian packaging is:
License: GPL-2+
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
.
This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU General Public License for more details.
.
You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 51 Franklin
Street, Fifth Floor, Boston, MA 02110-1301, USA.
Comment: On Debian systems, the complete text of the GNU General Public License
version 2 can be found in "/usr/share/common-licenses/GPL-2".
Copyright (C) 2010 Gregory Hainaut <gregory.hainaut@gmail.com>
License: LGPL-2.1+
This program is free software: you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation; either version 2.1 of the License, or (at your option) any
later version.
.
This program is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
.
You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc., 51
Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Comment: On Debian systems, the complete text of the GNU Lesser General Public
License version 2.1 can be found in "/usr/share/common-licenses/LGPL-2.1".
and is licensed under the Lesser GPL version 3, see above.
License: SGI FREE SOFTWARE LICENSE B 2.0
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
.
The above copyright notice including the dates of first publication and either
this permission notice or a reference to http://oss.sgi.com/projects/FreeB/
shall be included in all copies or substantial portions of the Software.
.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL SILICON
GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
.
Except as contained in this notice, the name of Silicon Graphics, Inc. shall
not be used in advertising or otherwise to promote the sale, use or other
dealings in this Software without prior written authorization from Silicon
Graphics, Inc.
License: Expat
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
.
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
License: BSD-3-Clause
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
.
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. 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.
3. Neither the name of the project 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 COPYRIGHT OWNER 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.

26
debian-unstable-upstream/create_pcsx2_tarball_from_svn_repository.sh
View File

@ -105,7 +105,7 @@ echo "Downloading pcsx2 source revision ${SVN_CO_VERSION}"
mkdir -p $ROOT_DIR;
(cd $ROOT_DIR;
get_svn_file CMakeLists.txt;
get_svn_dir common cmake locales pcsx2 tools;
get_svn_dir common cmake locales pcsx2;
get_svn_dir debian-unstable-upstream linux_various;
echo "Done")
@ -125,18 +125,18 @@ mkdir -p $ROOT_DIR/plugins
# get_svn_dir plugins/CDVDnull plugins/CDVDiso;
get_svn_dir plugins/PadNull plugins/onepad;
get_svn_dir plugins/SPU2null plugins/spu2-x;
get_svn_dir plugins/GSnull plugins/zzogl-pg plugins/GSdx;
get_svn_dir plugins/GSnull plugins/zzogl-pg plugins/zzogl-pg-cg plugins/GSdx;
get_svn_dir plugins/dev9null plugins/FWnull plugins/USBnull;
echo "Note: some plugins are more or less deprecated CDVDisoEFP, CDVDlinuz, Zerogs, Zeropad ...";
echo "Done")
## Download the internal sdl 1.3 for gsdx
echo "Downloading 3rdpary SDL 1.3 (need by gsdx) revision ${SVN_CO_VERSION}"
mkdir -p $ROOT_DIR/3rdparty
(cd $ROOT_DIR/3rdparty/;
get_svn_file 3rdparty/CMakeLists.txt;
get_svn_dir 3rdparty/SDL-1.3.0-5387;)
echo "Done"
# echo "Downloading 3rdpary SDL 1.3 (need by gsdx) revision ${SVN_CO_VERSION}"
# mkdir -p $ROOT_DIR/3rdparty
# (cd $ROOT_DIR/3rdparty/;
# get_svn_file 3rdparty/CMakeLists.txt;
# get_svn_dir 3rdparty/SDL-1.3.0-5387;)
# echo "Done"
## Installation
@ -147,22 +147,12 @@ cp -r $ROOT_DIR $NEW_DIR
echo "Remove .svn directories"
find $NEW_DIR -name ".svn" -type d -exec rm -fr {} \; 2> /dev/null
echo "Remove old build system (scripts and autotools)"
find $NEW_DIR -name "build.sh" -exec rm -f {} \;
find $NEW_DIR -name "install-sh" -exec rm -f {} \;
find $NEW_DIR -name "depcomp" -exec rm -f {} \;
find $NEW_DIR -name "missing" -exec rm -f {} \;
find $NEW_DIR -name "aclocal.m4" -exec rm -f {} \;
find $NEW_DIR -name "configure.ac" -exec rm -f {} \;
find $NEW_DIR -name "Makefile.am" -exec rm -f {} \;
echo "Remove windows files (useless & copyright issues)"
find $NEW_DIR -iname "windows" -type d -exec rm -fr {} \; 2> /dev/null
find $NEW_DIR -name "Win32" -type d -exec rm -fr {} \; 2> /dev/null
rm -fr "${NEW_DIR}/plugins/zzogl-pg/opengl/Win32"
rm -fr "${NEW_DIR}/tools/GSDumpGUI"
rm -fr "${NEW_DIR}/common/vsprops"
echo "Remove useless files (copyright issues)"
rm -fr "${NEW_DIR}/pcsx2/3rdparty" # useless link which annoy me
rm -fr "${NEW_DIR}/plugins/zzogl-pg/opengl/ZeroGSShaders"
rm -fr "${NEW_DIR}/common/src/Utilities/x86/MemcpyFast.cpp"
rm -fr "${NEW_DIR}/plugins/GSdx/baseclasses"

2
debian-unstable-upstream/docs
View File

@ -0,0 +1,2 @@
debian/tmp/usr/share/doc/pcsx2
bin/docs/*.pdf

7
debian-unstable-upstream/install Normal file
View File

@ -0,0 +1,7 @@
usr/bin/pcsx2 /usr/games/
usr/lib/games/pcsx2
usr/share/applications/pcsx2.desktop
usr/share/pixmaps/pcsx2.xpm
usr/share/locale usr/share/
var/games/pcsx2
usr/share/games/pcsx2

2
debian-unstable-upstream/pcsx2-plugins-unstable.lintian-overrides → debian-unstable-upstream/lintian-overrides
View File

@ -3,4 +3,4 @@
# - Upstream code uses the ebx register so it's not compliant with PIC.
# - Impacts the performance too much.
# - Only plugins. No package will link to them.
pcsx2-plugins-unstable: shlib-with-non-pic-code
: shlib-with-non-pic-code

1
debian-unstable-upstream/manpages Normal file
View File

@ -0,0 +1 @@
bin/docs/pcsx2.1

2
debian-unstable-upstream/pcsx2-unstable.menu → debian-unstable-upstream/menu
View File

@ -2,5 +2,5 @@
needs="X11" \
section="Applications/Emulators" \
title="pcsx2" \
longtitle="A playstation 2 emulators" \
longtitle="A playstation 2 emulator" \
command="/usr/games/pcsx2"

1
debian-unstable-upstream/pcsx2-l10n-unstable.install
View File

@ -1 +0,0 @@
usr/share/locale usr/share/

1
debian-unstable-upstream/pcsx2-plugins-unstable.install
View File

@ -1 +0,0 @@
usr/lib/games/pcsx2

1
debian-unstable-upstream/pcsx2-unstable.docs
View File

@ -1 +0,0 @@
debian/tmp/usr/share/doc/pcsx2

4
debian-unstable-upstream/pcsx2-unstable.install
View File

@ -1,4 +0,0 @@
usr/bin/pcsx2
usr/share/applications/pcsx2.desktop
usr/share/pixmaps/pcsx2.xpm
var/games/pcsx2

1
debian-unstable-upstream/pcsx2-unstable.manpages
View File

@ -1 +0,0 @@
bin/docs/pcsx2.man

18
debian-unstable-upstream/rules
View File

@ -1,5 +1,4 @@
#!/usr/bin/make -f
# -*- makefile -*-
# Uncomment this to turn on verbose mode.
# export DH_VERBOSE=1
@ -15,20 +14,15 @@ override_dh_auto_configure:
-DCMAKE_BUILD_TYPE=$(CMAKE_BUILD_TYPE) \
-DCMAKE_BUILD_STRIP=FALSE \
-DXDG_STD=TRUE \
-DFORCE_INTERNAL_SDL=TRUE \
-DPACKAGE_MODE=TRUE
clean:
dh_testdir
dh_testroot
dh_auto_clean
dh_clean
override_dh_strip:
dh_strip --package=pcsx2-unstable --dbg-package=pcsx2-unstable-dbg
dh_strip --package=pcsx2-plugins-unstable --dbg-package=pcsx2-plugins-unstable-dbg
override_dh_makeshlibs:
clean:
dh_auto_clean
dh_clean
%:
dh $@ --parallel
.PHONY: clean
dh $@

6
debian-unstable-upstream/watch
View File

@ -1,9 +1,3 @@
# Example watch control file for uscan
# Rename this file to "watch" and then you can run the "uscan" command
# to check for upstream updates and more.
# See uscan(1) for format
# Compulsory line, this is a version 3 file
version=3
# Note: Upstream does not release prepackaged source files.

3
plugins/zzogl-pg-cg/opengl/GSDump.cpp
View File

@ -58,13 +58,14 @@ void GSDump::Close()
}
}
void GSDump::Transfer(int index, const u8* mem, size_t size)
void GSDump::Transfer(int index, const u32* mem, size_t size, u32 real_size)
{
if(m_gs && size > 0)
{
fputc(0, m_gs);
fputc(index, m_gs);
fwrite(&size, 4, 1, m_gs);
fwrite(&real_size, 4, 1, m_gs);
fwrite(mem, size, 1, m_gs);
}
}

2
plugins/zzogl-pg-cg/opengl/GSDump.h
View File

@ -56,7 +56,7 @@ public:
void Open(const string& fn, u32 crc, const freezeData& fd, u8* regs);
void Close();
void ReadFIFO(u32 size);
void Transfer(int index, const u8* mem, size_t size);
void Transfer(int index, const u32* mem, size_t size, u32 real_size);
void VSync(int field, bool last, u8* regs);
operator bool() {return m_gs != NULL;}
};

29
plugins/zzogl-pg-cg/opengl/GSmain.cpp
View File

@ -399,7 +399,7 @@ static bool get_snapshot_filename(char *filename, char* path, const char* extens
{
snapshotnr++;
sprintf(filename, "%s/snap%03ld.%s", path, snapshotnr, extension);
sprintf(filename, "%s/snap%03d.%s", path, snapshotnr, extension);
bmpfile = fopen(filename, "rb");
@ -627,6 +627,7 @@ struct Packet
{
u8 type, param;
u32 size, addr;
u32 real_size;
vector<u32> buff;
};
@ -680,18 +681,20 @@ EXPORT_C_(void) GSReplay(char* lpszCmdLine)
p->param = (u8)fgetc(fp);
fread(&p->size, 4, 1, fp);
fread(&p->real_size, 4, 1, fp);
switch(p->param)
{
case 0:
p->buff.resize(0x4000);
p->addr = 0x4000 - p->size;
fread(&p->buff[p->addr], p->size, 1, fp);
p->buff.resize(0x4000/4);
//p->addr = 0x4000 - p->size;
//fread(&p->buff[p->addr], p->size, 1, fp);
fread(&p->buff[0], p->size, 1, fp);
break;
case 1:
case 2:
case 3:
p->buff.resize(p->size);
p->buff.resize(p->size/4);
fread(&p->buff[0], p->size, 1, fp);
break;
}
@ -712,7 +715,7 @@ EXPORT_C_(void) GSReplay(char* lpszCmdLine)
case 3:
p->buff.resize(0x2000);
p->buff.resize(0x2000/4);
fread(&p->buff[0], 0x2000, 1, fp);
@ -741,12 +744,14 @@ EXPORT_C_(void) GSReplay(char* lpszCmdLine)
{
case 0:
//fprintf(stderr, "TRANSFER %d size %d\n", p->param, p->real_size);
switch(p->param)
{
case 0: GSgifTransfer1(&p->buff[0], p->addr); break;
case 1: GSgifTransfer2(&p->buff[0], p->size / 16); break;
case 2: GSgifTransfer3(&p->buff[0], p->size / 16); break;
case 3: GSgifTransfer(&p->buff[0], p->size / 16); break;
//case 0: GSgifTransfer1((u32*)&p->buff[0], p->addr); break;
case 0: _GSgifTransfer<0>(&p->buff[0], p->real_size); break;
case 1: GSgifTransfer2((u32*)&p->buff[0], p->real_size); break;
case 2: GSgifTransfer3((u32*)&p->buff[0], p->real_size); break;
case 3: GSgifTransfer((u32*)&p->buff[0], p->real_size); break;
}
break;
@ -775,8 +780,8 @@ EXPORT_C_(void) GSReplay(char* lpszCmdLine)
}
}
unsigned long end = timeGetTime();
fprintf(stderr, "The %d frames of the scene was render on %dms\n", frame_number, end - start);
fprintf(stderr, "A means of %fms by frame\n", (float)(end - start)/(float)frame_number);
fprintf(stderr, "The %ld frames of the scene was render on %ldms\n", frame_number, end - start);
fprintf(stderr, "A means of %fms by frame (limit 16ms/f)\n", (float)(end - start)/(float)frame_number);
sleep(1);
finished--;

8
plugins/zzogl-pg-cg/opengl/GifTransfer.cpp
View File

@ -76,8 +76,8 @@ template<int index> void _GSgifTransfer(const u32 *pMem, u32 size)
#ifdef _DEBUG
gifTransferLog(index, pMem, size);
g_dump.Transfer(index, (const u8*)pMem, size);
const u32* start = pMem;
u32 size_arg = size;
#endif
while (size > 0)
@ -218,6 +218,10 @@ template<int index> void _GSgifTransfer(const u32 *pMem, u32 size)
}
}
#ifdef _DEBUG
g_dump.Transfer(index, start, pMem - start, size_arg);
#endif
// This is the case when not all data was readed from one try: VU1 has too much data.
// So we should redo reading from the start.
if (index == 0)

11
plugins/zzogl-pg/opengl/CMakeLists.txt
View File

@ -20,7 +20,6 @@ set(CommonFlags
-fno-strict-aliasing
-Wstrict-aliasing # Allow to track strict aliasing issue.
-Wunused-variable
#-DOGL4_LOG # Easier for development
)
set(OptimizationFlags
@ -31,7 +30,7 @@ set(OptimizationFlags
# Debug - Build
if(CMAKE_BUILD_TYPE STREQUAL Debug)
# add defines
add_definitions(${CommonFlags} -g -Wall -D_DEBUG)
add_definitions(${CommonFlags} -g -Wall -D_DEBUG)
endif(CMAKE_BUILD_TYPE STREQUAL Debug)
# Devel - Build
@ -48,7 +47,8 @@ endif(CMAKE_BUILD_TYPE STREQUAL Release)
# Select the shader API
if(GLSL_API)
add_definitions(-DGLSL_API)
add_definitions(-DGLSL_API -DGLSL4_API -DOGL4_LOG)
#add_definitions(-DGLSL_API)
else(GLSL_API)
add_definitions(-DNVIDIA_CG_API)
endif(GLSL_API)
@ -87,6 +87,7 @@ set(zzoglSources
ZZoglSave.cpp
ZZoglShaders.cpp
ZZoglShadersGLSL.cpp
ZZoglShadersGLSL4.cpp
ZZoglShoots.cpp
ZZoglVB.cpp
)
@ -190,7 +191,8 @@ endif(NOT USER_CMAKE_LD_FLAGS STREQUAL "")
if(PACKAGE_MODE)
install(TARGETS ${Output} DESTINATION ${PLUGIN_DIR})
if(GLSL_API)
install(FILES ${PROJECT_SOURCE_DIR}/plugins/zzogl-pg/opengl/ps2hw.glsl DESTINATION ${PLUGIN_DIR})
install(FILES ${PROJECT_SOURCE_DIR}/plugins/zzogl-pg/opengl/ps2hw.glsl DESTINATION ${GLSL_SHADER_DIR})
install(FILES ${PROJECT_SOURCE_DIR}/plugins/zzogl-pg/opengl/ps2hw_gl4.glsl DESTINATION ${GLSL_SHADER_DIR})
else(GLSL_API)
if(NOT REBUILD_SHADER)
install(FILES ${PROJECT_SOURCE_DIR}/plugins/zzogl-pg/opengl/ps2hw.dat DESTINATION ${PLUGIN_DIR})
@ -200,6 +202,7 @@ else(PACKAGE_MODE)
install(TARGETS ${Output} DESTINATION ${CMAKE_SOURCE_DIR}/bin/plugins)
if(GLSL_API)
install(FILES ${PROJECT_SOURCE_DIR}/plugins/zzogl-pg/opengl/ps2hw.glsl DESTINATION ${CMAKE_SOURCE_DIR}/bin/plugins)
install(FILES ${PROJECT_SOURCE_DIR}/plugins/zzogl-pg/opengl/ps2hw_gl4.glsl DESTINATION ${CMAKE_SOURCE_DIR}/bin/plugins)
else(GLSL_API)
if(NOT REBUILD_SHADER)
install(FILES ${PROJECT_SOURCE_DIR}/plugins/zzogl-pg/opengl/ps2hw.dat DESTINATION ${CMAKE_SOURCE_DIR}/bin/plugins)

6
plugins/zzogl-pg/opengl/GLWinX11.cpp
View File

@ -228,9 +228,9 @@ bool GLWindow::CreateContextGL(int major, int minor)
void GLWindow::CreateContextGL()
{
#ifdef OGL4_LOG
// We need to define a debug context. So we need at a 3.0 context (if not 3.2)
CreateContextGL(4, 1);
#if defined(OGL4_LOG) || defined(GLSL4_API)
// We need to define a debug context. So we need at a 3.0 context (if not 3.2 actually)
CreateContextGL(3, 3);
#else
// FIXME there was some issue with previous context creation on Geforce7. Code was rewritten
// for GSdx unfortunately it was not tested on Geforce7 so keep the 2.0 context for now.

5
plugins/zzogl-pg/opengl/GS.h
View File

@ -26,6 +26,7 @@
#include "Util.h"
#include "GifTransfer.h"
#include "HostMemory.h"
#include "ZZoglShoots.h"
using namespace std;
@ -39,7 +40,7 @@ extern float fFPS;
extern int g_LastCRC;
#define VB_NUMBUFFERS 512 // number of vbo buffer allocated
#define VB_NUMBUFFERS 128 // number of vbo buffer allocated
struct Vector_16F
{
@ -422,7 +423,7 @@ union tex_0_info
#define TEX_HIGHLIGHT 2
#define TEX_HIGHLIGHT2 3
bool SaveTexture(const char* filename, u32 textarget, u32 tex, int width, int height);
//bool SaveTexture(const char* filename, u32 textarget, u32 tex, int width, int height, int ext_format = 0);
extern void SaveTex(tex0Info* ptex, int usevid);
extern char* NamedSaveTex(tex0Info* ptex, int usevid);

3
plugins/zzogl-pg/opengl/GSDump.cpp
View File

@ -58,13 +58,14 @@ void GSDump::Close()
}
}
void GSDump::Transfer(int index, const u8* mem, size_t size)
void GSDump::Transfer(int index, const u32* mem, size_t size, u32 real_size)
{
if(m_gs && size > 0)
{
fputc(0, m_gs);
fputc(index, m_gs);
fwrite(&size, 4, 1, m_gs);
fwrite(&real_size, 4, 1, m_gs);
fwrite(mem, size, 1, m_gs);
}
}

2
plugins/zzogl-pg/opengl/GSDump.h
View File

@ -56,7 +56,7 @@ public:
void Open(const string& fn, u32 crc, const freezeData& fd, u8* regs);
void Close();
void ReadFIFO(u32 size);
void Transfer(int index, const u8* mem, size_t size);
void Transfer(int index, const u32* mem, size_t size, u32 real_size);
void VSync(int field, bool last, u8* regs);
operator bool() {return m_gs != NULL;}
};

71
plugins/zzogl-pg/opengl/GSUniformBufferOGL.h Normal file
View File

@ -0,0 +1,71 @@
/*
* Copyright (C) 2011-2011 Gregory hainaut
* Copyright (C) 2007-2009 Gabest
*
* This Program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This Program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Make; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
* http://www.gnu.org/copyleft/gpl.html
*
*/
// Note: it is same code that was developed for GSdx plugin
#pragma once
#ifdef GLSL4_API
class GSUniformBufferOGL {
GLuint buffer; // data object
GLuint index; // GLSL slot
uint size; // size of the data
const GLenum target;
public:
GSUniformBufferOGL(GLuint index, uint size) : index(index)
, size(size)
,target(GL_UNIFORM_BUFFER)
{
glGenBuffers(1, &buffer);
bind();
allocate();
attach();
}
void bind()
{
glBindBuffer(target, buffer);
}
void allocate()
{
glBufferData(target, size, NULL, GL_STREAM_DRAW);
}
void attach()
{
glBindBufferBase(target, index, buffer);
}
void upload(const void* src)
{
uint32 flags = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT;
uint8* dst = (uint8*) glMapBufferRange(target, 0, size, flags);
memcpy(dst, src, size);
glUnmapBuffer(target);
}
~GSUniformBufferOGL() {
glDeleteBuffers(1, &buffer);
}
};
#endif

283
plugins/zzogl-pg/opengl/GSVertexArrayOGL.h Normal file
View File

@ -0,0 +1,283 @@
/*
* Copyright (C) 2011-2011 Gregory hainaut
* Copyright (C) 2007-2009 Gabest
*
* This Program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This Program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Make; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
* http://www.gnu.org/copyleft/gpl.html
*
*/
// Note: it is same code that was developed for GSdx plugin
#pragma once
#ifdef GLSL4_API
struct GSInputLayoutOGL {
GLuint index;
GLint size;
GLenum type;
GLboolean normalize;
GLsizei stride;
const GLvoid* offset;
};
class GSBufferOGL {
size_t m_stride;
size_t m_start;
size_t m_count;
size_t m_limit;
GLenum m_target;
GLuint m_buffer;
size_t m_default_size;
public:
GSBufferOGL(GLenum target, size_t stride) :
m_stride(stride)
, m_start(0)
, m_count(0)
, m_limit(0)
, m_target(target)
{
glGenBuffers(1, &m_buffer);
// Opengl works best with 1-4MB buffer.
m_default_size = 2 * 1024 * 1024 / m_stride;
}
~GSBufferOGL() { glDeleteBuffers(1, &m_buffer); }
void allocate() { allocate(m_default_size); }
void allocate(size_t new_limit)
{
m_start = 0;
m_limit = new_limit;
glBufferData(m_target, m_limit * m_stride, NULL, GL_STREAM_DRAW);
}
void bind()
{
glBindBuffer(m_target, m_buffer);
}
void upload(const void* src, uint32 count)
{
// Upload the data to the buffer
void* dst;
if (Map(&dst, count)) {
// FIXME which one to use
// GSVector4i::storent(dst, src, m_count * m_stride);
memcpy(dst, src, m_stride*m_count);
Unmap();
}
}
bool Map(void** pointer, uint32 count ) {
#ifdef OGL_DEBUG
GLint b_size = -1;
glGetBufferParameteriv(m_target, GL_BUFFER_SIZE, &b_size);
if (b_size <= 0) return false;
#endif
m_count = count;
// Note: For an explanation of the map flag
// see http://www.opengl.org/wiki/Buffer_Object_Streaming
uint32 map_flags = GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT;
// Current GPU buffer is really too small need to allocate a new one
if (m_count > m_limit) {
allocate(std::max<int>(m_count * 3 / 2, m_default_size));
} else if (m_count > (m_limit - m_start) ) {
// Not enough left free room. Just go back at the beginning
m_start = 0;
// Tell the driver that it can orphan previous buffer and restart from a scratch buffer.
// Technically the buffer will not be accessible by the application anymore but the
// GL will effectively remove it when draws call are finised.
map_flags |= GL_MAP_INVALIDATE_BUFFER_BIT;
} else {
// Tell the driver that it doesn't need to contain any valid buffer data, and that you promise to write the entire range you map
map_flags |= GL_MAP_INVALIDATE_RANGE_BIT;
}
// Upload the data to the buffer
*pointer = (uint8*) glMapBufferRange(m_target, m_stride*m_start, m_stride*m_count, map_flags);
//fprintf(stderr, "Map %x from %d to %d\n", *pointer, m_start, m_start+m_count);
#ifdef OGL_DEBUG
if (*pointer == NULL) {
fprintf(stderr, "CRITICAL ERROR map failed for vb!!!\n");
return false;
}
#endif
return true;
}
void Unmap() { glUnmapBuffer(m_target); }
void EndScene()
{
m_start += m_count;
m_count = 0;
}
void Draw(GLenum mode)
{
glDrawArrays(mode, m_start, m_count);
}
void Draw(GLenum mode, GLint basevertex)
{
glDrawElementsBaseVertex(mode, m_count, GL_UNSIGNED_INT, (void*)(m_start * m_stride), basevertex);
}
void Draw(GLenum mode, GLint basevertex, int offset, int count)
{
glDrawElementsBaseVertex(mode, count, GL_UNSIGNED_INT, (void*)((m_start + offset) * m_stride), basevertex);
}
size_t GetStart() { return m_start; }
void debug()
{
fprintf(stderr, "data buffer: start %d, count %d\n", m_start, m_count);
}
};
class GSVertexBufferStateOGL {
GSBufferOGL *m_vb;
GSBufferOGL *m_ib;
GLuint m_va;
GLenum m_topology;
// DEBUG
vector<GSInputLayoutOGL> layout_store;
public:
GSVertexBufferStateOGL(size_t stride, GSInputLayoutOGL* layout, uint32 layout_nbr)
{
glGenVertexArrays(1, &m_va);
layout_store.clear();
m_vb = new GSBufferOGL(GL_ARRAY_BUFFER, stride);
m_ib = new GSBufferOGL(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32));
bind();
// Note: index array are part of the VA state so it need to be bind only once.
m_ib->bind();
m_vb->allocate();
m_ib->allocate();
set_internal_format(layout, layout_nbr);
}
void bind()
{
glBindVertexArray(m_va);
m_vb->bind();
}
void set_internal_format()
{
for (vector<GSInputLayoutOGL>::iterator it = layout_store.begin(); it != layout_store.end(); it++)
set_internal_format(*it);
}
void set_internal_format(GSInputLayoutOGL& layout) {
// Note this function need both a vertex array object and a GL_ARRAY_BUFFER buffer
glEnableVertexAttribArray(layout.index);
switch (layout.type) {
case GL_UNSIGNED_SHORT:
case GL_UNSIGNED_INT:
case GL_SHORT:
case GL_INT:
// Rule: when shader use integral (not normalized) you must use glVertexAttribIPointer (note the extra I)
if (layout.normalize == false)
glVertexAttribIPointer(layout.index, layout.size, layout.type, layout.stride, layout.offset);
else
glVertexAttribPointer(layout.index, layout.size, layout.type, layout.normalize, layout.stride, layout.offset);
break;
default:
glVertexAttribPointer(layout.index, layout.size, layout.type, layout.normalize, layout.stride, layout.offset);
break;
}
}
void set_internal_format(GSInputLayoutOGL* layout, uint32 layout_nbr)
{
for (uint i = 0; i < layout_nbr; i++) {
// DEBUG
layout_store.push_back(layout[i]);
set_internal_format(layout[i]);
}
}
void EndScene()
{
m_vb->EndScene();
m_ib->EndScene();
}
void DrawPrimitive() { m_vb->Draw(m_topology); }
void DrawIndexedPrimitive() { m_ib->Draw(m_topology, m_vb->GetStart() ); }
void DrawIndexedPrimitive(int offset, int count) { m_ib->Draw(m_topology, m_vb->GetStart(), offset, count ); }
void SetTopology(GLenum topology) { m_topology = topology; }
void UploadVB(const void* vertices, size_t count) { m_vb->upload(vertices, count); }
void UploadIB(const void* index, size_t count) { m_ib->upload(index, count); }
bool MapVB(void **pointer, size_t count) { return m_vb->Map(pointer, count); }
void UnmapVB() { m_vb->Unmap(); }
~GSVertexBufferStateOGL()
{
glDeleteVertexArrays(1, &m_va);
delete m_vb;
delete m_ib;
}
void debug()
{
string topo;
switch (m_topology) {
case GL_POINTS:
topo = "point";
break;
case GL_LINES:
topo = "line";
break;
case GL_TRIANGLES:
topo = "triangle";
break;
case GL_TRIANGLE_STRIP:
topo = "triangle strip";
break;
}
m_vb->debug();
m_ib->debug();
fprintf(stderr, "primitives of %s\n", topo.c_str());
}
};
#endif

29
plugins/zzogl-pg/opengl/GSmain.cpp
View File

@ -403,7 +403,7 @@ static bool get_snapshot_filename(char *filename, char* path, const char* extens
{
snapshotnr++;
sprintf(filename, "%s/snap%03ld.%s", path, snapshotnr, extension);
sprintf(filename, "%s/snap%03d.%s", path, snapshotnr, extension);
bmpfile = fopen(filename, "rb");
@ -641,6 +641,7 @@ struct Packet
{
u8 type, param;
u32 size, addr;
u32 real_size;
vector<u32> buff;
};
@ -694,18 +695,20 @@ EXPORT_C_(void) GSReplay(char* lpszCmdLine)
p->param = (u8)fgetc(fp);
fread(&p->size, 4, 1, fp);
fread(&p->real_size, 4, 1, fp);
switch(p->param)
{
case 0:
p->buff.resize(0x4000);
p->addr = 0x4000 - p->size;
fread(&p->buff[p->addr], p->size, 1, fp);
p->buff.resize(0x4000/4);
//p->addr = 0x4000 - p->size;
//fread(&p->buff[p->addr], p->size, 1, fp);
fread(&p->buff[0], p->size, 1, fp);
break;
case 1:
case 2:
case 3:
p->buff.resize(p->size);
p->buff.resize(p->size/4);
fread(&p->buff[0], p->size, 1, fp);
break;
}
@ -726,7 +729,7 @@ EXPORT_C_(void) GSReplay(char* lpszCmdLine)
case 3:
p->buff.resize(0x2000);
p->buff.resize(0x2000/4);
fread(&p->buff[0], 0x2000, 1, fp);
@ -755,12 +758,14 @@ EXPORT_C_(void) GSReplay(char* lpszCmdLine)
{
case 0:
//fprintf(stderr, "TRANSFER %d size %d\n", p->param, p->real_size);
switch(p->param)
{
case 0: GSgifTransfer1(&p->buff[0], p->addr); break;
case 1: GSgifTransfer2(&p->buff[0], p->size / 16); break;
case 2: GSgifTransfer3(&p->buff[0], p->size / 16); break;
case 3: GSgifTransfer(&p->buff[0], p->size / 16); break;
//case 0: GSgifTransfer1((u32*)&p->buff[0], p->addr); break;
case 0: _GSgifTransfer<0>(&p->buff[0], p->real_size); break;
case 1: GSgifTransfer2((u32*)&p->buff[0], p->real_size); break;
case 2: GSgifTransfer3((u32*)&p->buff[0], p->real_size); break;
case 3: GSgifTransfer((u32*)&p->buff[0], p->real_size); break;
}
break;
@ -789,8 +794,8 @@ EXPORT_C_(void) GSReplay(char* lpszCmdLine)
}
}
unsigned long end = timeGetTime();
fprintf(stderr, "The %d frames of the scene was render on %dms\n", frame_number, end - start);
fprintf(stderr, "A means of %fms by frame\n", (float)(end - start)/(float)frame_number);
fprintf(stderr, "The %ld frames of the scene was render on %ldms\n", frame_number, end - start);
fprintf(stderr, "A means of %fms by frame (limit 16ms/f)\n", (float)(end - start)/(float)frame_number);
sleep(1);
finished--;

8
plugins/zzogl-pg/opengl/GifTransfer.cpp
View File

@ -76,8 +76,8 @@ template<int index> void _GSgifTransfer(const u32 *pMem, u32 size)
#ifdef _DEBUG
gifTransferLog(index, pMem, size);
g_dump.Transfer(index, (const u8*)pMem, size);
const u32* start = pMem;
u32 size_arg = size;
#endif
while (size > 0)
@ -222,6 +222,10 @@ template<int index> void _GSgifTransfer(const u32 *pMem, u32 size)
}
}
#ifdef _DEBUG
g_dump.Transfer(index, start, pMem - start, size_arg);
#endif
// This is the case when not all data was readed from one try: VU1 has too much data.
// So we should redo reading from the start.
if (index == 0)

41
plugins/zzogl-pg/opengl/Util.h
View File

@ -72,6 +72,16 @@ extern "C" u32 CALLBACK PS2EgetLibVersion2(u32 type);
extern "C" char* CALLBACK PS2EgetLibName(void);
#endif
// Allow easy copy/past between GSdx and zzogl
typedef unsigned char uint8;
typedef signed char int8;
typedef unsigned short uint16;
typedef signed short int16;
typedef unsigned int uint32;
typedef signed int int32;
typedef unsigned long long uint64;
typedef signed long long int64;
#include "ZZoglMath.h"
#include "Profile.h"
#include "GSDump.h"
@ -81,6 +91,37 @@ extern "C" char* CALLBACK PS2EgetLibName(void);
extern wxString s_strIniPath; // Air's new (r2361) new constant for ini file path
static std::string format(const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
int result = -1, length = 256;
char* buffer = NULL;
while(result == -1)
{
if(buffer) delete [] buffer;
buffer = new char[length + 1];
memset(buffer, 0, length + 1);
result = vsnprintf(buffer, length, fmt, args);
length *= 2;
}
va_end(args);
std::string s(buffer);
delete [] buffer;
return s;
}
typedef struct
{
int x, y, w, h;

1
plugins/zzogl-pg/opengl/Win32/zerogsogl.vcxproj
View File

@ -142,6 +142,7 @@
<ClCompile Include="..\ZZoglFlushHack.cpp" />
<ClCompile Include="..\ZZoglMem.cpp" />
<ClCompile Include="..\ZZoglShadersGLSL.cpp" />
<ClCompile Include="..\ZZoglShadersGLSL4.cpp" />
<ClCompile Include="..\ZZRenderTargets.cpp" />
<ClCompile Include="Conf.cpp" />
<ClCompile Include="..\GifTransfer.cpp" />

3
plugins/zzogl-pg/opengl/Win32/zerogsogl.vcxproj.filters
View File

@ -129,6 +129,9 @@
<ClCompile Include="..\ZZoglShadersGLSL.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\ZZoglShadersGLSL4.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<None Include="GSsoftdx.def">

10
plugins/zzogl-pg/opengl/Win32/zerogsogl_2008.vcproj
View File

@ -1,7 +1,7 @@
<?xml version="1.0" encoding="windows-1253"?>
<VisualStudioProject
ProjectType="Visual C++"
Version="9.00"
Version="9,00"
Name="ZZOgl"
ProjectGUID="{2D4E85B2-F47F-4D65-B091-701E5C031DAC}"
RootNamespace="ZZogl"
@ -412,6 +412,10 @@
RelativePath="..\ZZoglShadersGLSL.cpp"
>
</File>
<File
RelativePath="..\ZZoglShadersGLSL4.cpp"
>
</File>
<File
RelativePath="..\ZZoglShoots.cpp"
>
@ -608,11 +612,11 @@
</File>
</Filter>
<File
RelativePath="..\ps2hw.dat"
RelativePath=".\ps2hw.dat"
>
</File>
<File
RelativePath=".\ps2hw.dat"
RelativePath="..\ps2hw.dat"
>
</File>
</Files>

13
plugins/zzogl-pg/opengl/ZZGl.h
View File

@ -84,13 +84,20 @@ static __forceinline void GL_STENCILFUNC_SET()
glStencilFunc(s_stencilfunc, s_stencilref, s_stencilmask);
}
#ifdef GLSL4_API
#include "ZZoglShaders.h"
#endif
// sets the data stream
static __forceinline void SET_STREAM()
{
#ifndef GLSL4_API
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(VertexGPU), (void*)8);
glSecondaryColorPointerEXT(4, GL_UNSIGNED_BYTE, sizeof(VertexGPU), (void*)12);
glTexCoordPointer(3, GL_FLOAT, sizeof(VertexGPU), (void*)16);
glVertexPointer(4, GL_SHORT, sizeof(VertexGPU), (void*)0);
#else
vertex_array->set_internal_format();
#endif
}
// global alpha blending settings
@ -149,8 +156,14 @@ extern PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC glGetFramebufferAttachmen
extern PFNGLGENERATEMIPMAPEXTPROC glGenerateMipmapEXT;
extern PFNGLDRAWBUFFERSPROC glDrawBuffers;
#ifdef GLSL4_API
#include "ZZoglShaders.h"
#endif
static __forceinline void DrawTriangleArray()
{
#ifdef GLSL4_API
ZZshSetupShader();
#endif
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
GL_REPORT_ERRORD();
}

8
plugins/zzogl-pg/opengl/ZZoglCRTC.cpp
View File

@ -881,10 +881,10 @@ void RenderCRTC()
tex0Info& texframe = dispinfo[i];
// I don't think this is neccessary, now that we make sure the ciruit we are working with is enabled.
/*if (texframe.th <= 1)
{
continue;
}*/
//
// Actually it seems there are still empty frame in some games (persona 4 and tales of abyss). I'm not sure it
// is normal, for the moment keep the check to avoid some undefined behavior. -- Gregory
if (texframe.th <= 1) continue;
if (SMODE2->INT && SMODE2->FFMD)
{

26
plugins/zzogl-pg/opengl/ZZoglCreate.cpp
View File

@ -40,9 +40,7 @@ typedef void (APIENTRYP _PFNSWAPINTERVAL)(int);
map<string, GLbyte> mapGLExtensions;
extern bool LoadEffects();
extern bool ZZshLoadExtraEffects();
extern FRAGMENTSHADER* ZZshLoadShadeEffect(int type, int texfilter, int fog, int testaem, int exactcolor, const clampInfo& clamp, int context, bool* pbFailed);
GLuint vboRect = 0;
GLuint g_vboBuffers[VB_NUMBUFFERS]; // VBOs for all drawing commands
@ -574,6 +572,18 @@ bool ZZCreate(int _width, int _height)
GL_REPORT_ERROR();
#ifdef GLSL4_API
GSInputLayoutOGL vert_format[] =
{
{0 , 2 , GL_SHORT , GL_FALSE , sizeof(VertexGPU) , (const GLvoid*)(0) } , // vertex
{1 , 4 , GL_UNSIGNED_BYTE , GL_TRUE , sizeof(VertexGPU) , (const GLvoid*)(8) } , // color
{2 , 4 , GL_UNSIGNED_BYTE , GL_TRUE , sizeof(VertexGPU) , (const GLvoid*)(12) } , // z value. FIXME WTF 4 unsigned byte, why not a full integer
{3 , 3 , GL_FLOAT , GL_FALSE , sizeof(VertexGPU) , (const GLvoid*)(16) } , // tex coord
};
vertex_array = new GSVertexBufferStateOGL(sizeof(VertexGPU), vert_format, 4);
#endif
g_nCurVBOIndex = 0;
if (!vb_buffer_allocated) {
@ -582,6 +592,9 @@ bool ZZCreate(int _width, int _height)
{
glBindBuffer(GL_ARRAY_BUFFER, g_vboBuffers[i]);
glBufferData(GL_ARRAY_BUFFER, 0x100*sizeof(VertexGPU), NULL, GL_STREAM_DRAW);
#ifdef GLSL4_API
vertex_array->set_internal_format();
#endif
}
vb_buffer_allocated = true; // mark the buffer allocated
}
@ -663,6 +676,9 @@ bool ZZCreate(int _width, int _height)
// fill a simple rect
glGenBuffers(1, &vboRect);
glBindBuffer(GL_ARRAY_BUFFER, vboRect);
#ifdef GLSL4_API
vertex_array->set_internal_format();
#endif
vector<VertexGPU> verts(4);
@ -682,6 +698,7 @@ bool ZZCreate(int _width, int _height)
glBufferDataARB(GL_ARRAY_BUFFER, 4*sizeof(VertexGPU), &verts[0], GL_STATIC_DRAW);
#ifndef GLSL4_API
// setup the default vertex declaration
glEnableClientState(GL_VERTEX_ARRAY);
glClientActiveTexture(GL_TEXTURE0);
@ -689,6 +706,7 @@ bool ZZCreate(int _width, int _height)
glEnableClientState(GL_SECONDARY_COLOR_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
GL_REPORT_ERROR();
#endif
// some cards don't support this
// glClientActiveTexture(GL_TEXTURE0);
@ -815,6 +833,10 @@ void ZZDestroy()
vb_buffer_allocated = false; // mark the buffer unallocated
}
#ifdef GLSL4_API
delete vertex_array;
#endif
g_nCurVBOIndex = 0;
if (pvs != NULL)

6
plugins/zzogl-pg/opengl/ZZoglDrawing.cpp
View File

@ -145,7 +145,7 @@ void Kick::DrawPrim(u32 prim_type)
break;
case PRIM_LINE_STRIP:
if (likely(ValidPrevPrim)) {
if (likely(ValidPrevPrim) && curvb.nCount != 0) {
assert(curvb.nCount >= 1);
p[0] = p[-1];
} else {
@ -165,7 +165,7 @@ void Kick::DrawPrim(u32 prim_type)
break;
case PRIM_TRIANGLE_STRIP:
if (likely(ValidPrevPrim)) {
if (likely(ValidPrevPrim) && curvb.nCount != 0) {
assert(curvb.nCount >= 2);
p[0] = p[-2];
p[1] = p[-1];
@ -180,7 +180,7 @@ void Kick::DrawPrim(u32 prim_type)
break;
case PRIM_TRIANGLE_FAN:
if (likely(ValidPrevPrim)) {
if (likely(ValidPrevPrim) && curvb.nCount != 0) {
assert(curvb.nCount >= 2);
VertexGPU* TriFanVert = curvb.pBufferData + gs.nTriFanVert;
p[0] = TriFanVert[0];

2
plugins/zzogl-pg/opengl/ZZoglDrawing.h
View File

@ -51,7 +51,7 @@ class Kick
void Output_Vertex(VertexGPU vert, u32 id);
bool ValidPrevPrim;
public:
Kick() { }
Kick() : ValidPrevPrim(false) { }
~Kick() { }
void KickVertex(bool adc);

82
plugins/zzogl-pg/opengl/ZZoglFlush.cpp
View File

@ -89,6 +89,9 @@ int icurctx = -1;
void Draw(const VB& curvb)
{
#ifdef GLSL4_API
ZZshSetupShader();
#endif
glDrawArrays(primtype[curvb.curprim.prim], 0, curvb.nCount);
}
@ -688,7 +691,7 @@ inline float4 FlushSetPageOffset(FRAGMENTSHADER* pfragment, int shadertype, CRen
// zoe2
if (PSMT_ISZTEX(ptextarg->psm)) vpageoffset.w = -1.0f;
ZZshSetParameter4fv(pfragment->fPageOffset, vpageoffset, "g_fPageOffset");
ZZshSetParameter4fv(pfragment->prog, pfragment->fPageOffset, vpageoffset, "g_fPageOffset");
return vpageoffset;
}
@ -706,7 +709,7 @@ inline float4 FlushSetTexOffset(FRAGMENTSHADER* pfragment, int shadertype, VB& c
v.y = 16.0f / (float)curvb.tex0.th;
v.z = 0.5f * v.x;
v.w = 0.5f * v.y;
ZZshSetParameter4fv(pfragment->fTexOffset, v, "g_fTexOffset");
ZZshSetParameter4fv(pfragment->prog, pfragment->fTexOffset, v, "g_fTexOffset");
}
else if (shadertype == 4)
{
@ -715,7 +718,7 @@ inline float4 FlushSetTexOffset(FRAGMENTSHADER* pfragment, int shadertype, VB& c
v.y = 16.0f / (float)ptextarg->fbh;
v.z = -1;
v.w = 8.0f / (float)ptextarg->fbh;
ZZshSetParameter4fv(pfragment->fTexOffset, v, "g_fTexOffset");
ZZshSetParameter4fv(pfragment->prog, pfragment->fTexOffset, v, "g_fTexOffset");
}
return v;
@ -749,7 +752,7 @@ inline float4 FlushTextureDims(FRAGMENTSHADER* pfragment, int shadertype, VB& cu
if (shadertype == 4)
vTexDims.z += 8.0f;
ZZshSetParameter4fv(pfragment->fTexDims, vTexDims, "g_fTexDims");
ZZshSetParameter4fv(pfragment->prog, pfragment->fTexDims, vTexDims, "g_fTexDims");
return vTexDims;
}
@ -799,7 +802,7 @@ inline FRAGMENTSHADER* FlushUseExistRenderTarget(VB& curvb, CRenderTarget* ptext
float4 vTexDims = FlushTextureDims(pfragment, shadertype, curvb, ptextarg);
if (pfragment->sCLUT != NULL && ptexclut != 0)
ZZshGLSetTextureParameter(pfragment->sCLUT, ptexclut, "CLUT");
ZZshGLSetTextureParameter(pfragment->prog, pfragment->sCLUT, ptexclut, "CLUT");
FlushApplyResizeFilter(curvb, dwFilterOpts, ptextarg, context);
@ -846,13 +849,19 @@ inline void FlushSetTexture(VB& curvb, FRAGMENTSHADER* pfragment, CRenderTarget*
// have to enable the texture parameters(curtest.atst)
if( curvb.ptexClamp[0] != 0 )
ZZshGLSetTextureParameter(pfragment->sBitwiseANDX, curvb.ptexClamp[0], "Clamp 0");
ZZshGLSetTextureParameter(pfragment->prog, pfragment->sBitwiseANDX, curvb.ptexClamp[0], "Clamp 0");
if( curvb.ptexClamp[1] != 0 )
ZZshGLSetTextureParameter(pfragment->sBitwiseANDY, curvb.ptexClamp[1], "Clamp 1");
ZZshGLSetTextureParameter(pfragment->prog, pfragment->sBitwiseANDY, curvb.ptexClamp[1], "Clamp 1");
// FIXME condition is a bit strange for GLSL
#ifdef GLSL4_API
if( s_ptexCurSet[context] != 0)
ZZshGLSetTextureParameter(pfragment->prog, pfragment->sMemory, s_ptexCurSet[context], "Clamp memory");
#else
if( pfragment->sMemory != NULL && s_ptexCurSet[context] != 0)
ZZshGLSetTextureParameter(pfragment->sMemory, s_ptexCurSet[context], "Clamp memory");
ZZshGLSetTextureParameter(pfragment->prog, pfragment->sMemory, s_ptexCurSet[context], "Clamp memory");
#endif
}
// Reset program and texture variables;
@ -975,7 +984,7 @@ inline void AlphaRenderFBA(VB& curvb, FRAGMENTSHADER* pfragment)
// needs to be before RenderAlphaTest
if ((gs.pabe) || (curvb.fba.fba && !ZZOglGet_fbmHighByte(curvb.frame.fbm)) || (s_bDestAlphaTest && bCanRenderStencil))
{
RenderFBA(curvb, pfragment->sOneColor);
RenderFBA(curvb, pfragment);
}
}
@ -990,7 +999,7 @@ inline u32 AlphaRenderAlpha(VB& curvb, const pixTest curtest, FRAGMENTSHADER* pf
if ((bNeedBlendFactorInAlpha || ((curtest.ate && curtest.atst > ATST_ALWAYS) && (curtest.aref > 0x80))))
{
// need special stencil processing for the alpha
RenderAlphaTest(curvb, pfragment->sOneColor);
RenderAlphaTest(curvb, pfragment);
dwUsingSpecialTesting = 1;
}
@ -1003,13 +1012,13 @@ inline u32 AlphaRenderAlpha(VB& curvb, const pixTest curtest, FRAGMENTSHADER* pf
v.w *= 255;
}
ZZshSetParameter4fv(pfragment->sOneColor, v, "g_fOneColor");
ZZshSetParameter4fv(pfragment->prog, pfragment->sOneColor, v, "g_fOneColor");
}
else
{
// not using blending so set to defaults
float4 v = exactcolor ? float4(1, 510 * 255.0f / 256.0f, 0, 0) : float4(1, 2 * 255.0f / 256.0f, 0, 0);
ZZshSetParameter4fv(pfragment->sOneColor, v, "g_fOneColor");
ZZshSetParameter4fv(pfragment->prog, pfragment->sOneColor, v, "g_fOneColor");
}
@ -1100,7 +1109,7 @@ inline void AlphaPabe(VB& curvb, FRAGMENTSHADER* pfragment, int exactcolor)
if (exactcolor) v.y *= 255;
ZZshSetParameter4fv(pfragment->sOneColor, v, "g_fOneColor");
ZZshSetParameter4fv(pfragment->prog, pfragment->sOneColor, v, "g_fOneColor");
Draw(curvb);
@ -1169,7 +1178,7 @@ inline void AlphaFailureTestJob(VB& curvb, const pixTest curtest, FRAGMENTSHADE
if (exactcolor) { v.y *= 255; v.w *= 255; }
ZZshSetParameter4fv(pfragment->sOneColor, v, "g_fOneColor");
ZZshSetParameter4fv(pfragment->prog, pfragment->sOneColor, v, "g_fOneColor");
glEnable(GL_BLEND);
GL_STENCILFUNC(GL_EQUAL, s_stencilref | STENCIL_FBA, s_stencilmask | STENCIL_FBA);
@ -1193,7 +1202,7 @@ inline void AlphaFailureTestJob(VB& curvb, const pixTest curtest, FRAGMENTSHADE
if (exactcolor) v.y *= 255;
ZZshSetParameter4fv(pfragment->sOneColor, v, "g_fOneColor");
ZZshSetParameter4fv(pfragment->prog, pfragment->sOneColor, v, "g_fOneColor");
Draw(curvb);
@ -1245,7 +1254,7 @@ inline void AlphaSpecialTesting(VB& curvb, FRAGMENTSHADER* pfragment, u32 dwUsin
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
float4 v = float4(0, exactcolor ? 510.0f : 2.0f, 0, 0);
ZZshSetParameter4fv(pfragment->sOneColor, v, "g_fOneColor");
ZZshSetParameter4fv(pfragment->prog, pfragment->sOneColor, v, "g_fOneColor");
Draw(curvb);
// don't need to restore
@ -1260,7 +1269,7 @@ inline void AlphaDestinationTest(VB& curvb, FRAGMENTSHADER* pfragment)
{
if (curvb.fba.fba)
{
ProcessFBA(curvb, pfragment->sOneColor);
ProcessFBA(curvb, pfragment);
}
else if (s_bDestAlphaTest && bCanRenderStencil)
{
@ -1383,7 +1392,7 @@ void FlushIfNecesary(void* ptr)
if (vb[1].prndr == ptr || vb[1].pdepth == ptr) Flush(1);
}
inline void RenderFBA(const VB& curvb, ZZshParameter sOneColor)
inline void RenderFBA(const VB& curvb, FRAGMENTSHADER* pfragment)
{
// add fba to all pixels
GL_STENCILFUNC(GL_ALWAYS, STENCIL_FBA, 0xff);
@ -1404,7 +1413,7 @@ inline void RenderFBA(const VB& curvb, ZZshParameter sOneColor)
float4 v(1,2,0,0);
ZZshSetParameter4fv(sOneColor, v, "g_fOneColor");
ZZshSetParameter4fv(pfragment->prog, pfragment->sOneColor, v, "g_fOneColor");
Draw(curvb);
@ -1427,7 +1436,7 @@ inline void RenderFBA(const VB& curvb, ZZshParameter sOneColor)
GL_ZTEST(curvb.test.zte);
}
__forceinline void RenderAlphaTest(const VB& curvb, ZZshParameter sOneColor)
__forceinline void RenderAlphaTest(const VB& curvb, FRAGMENTSHADER* pfragment )
{
if (!g_bUpdateStencil) return;
@ -1443,7 +1452,7 @@ __forceinline void RenderAlphaTest(const VB& curvb, ZZshParameter sOneColor)
float4 v(1,2,0,0);
ZZshSetParameter4fv(sOneColor, v, "g_fOneColor");
ZZshSetParameter4fv(pfragment->prog, pfragment->sOneColor, v, "g_fOneColor");
// or a 1 to the stencil buffer wherever alpha passes
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
@ -1467,7 +1476,7 @@ __forceinline void RenderAlphaTest(const VB& curvb, ZZshParameter sOneColor)
if (curvb.test.ate && curvb.test.atst > ATST_ALWAYS && curvb.test.aref > 0x80)
{
v = float4(1,1,0,0);
ZZshSetParameter4fv(sOneColor, v, "g_fOneColor");
ZZshSetParameter4fv(pfragment->prog, pfragment->sOneColor, v, "g_fOneColor");
glAlphaFunc(g_dwAlphaCmp[curvb.test.atst], AlphaReferedValue(curvb.test.aref));
}
@ -1565,7 +1574,7 @@ inline void ProcessStencil(const VB& curvb)
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
}
__forceinline void ProcessFBA(const VB& curvb, ZZshParameter sOneColor)
__forceinline void ProcessFBA(const VB& curvb, FRAGMENTSHADER* pfragment )
{
if ((curvb.frame.fbm&0x80000000)) return;
@ -1590,8 +1599,12 @@ __forceinline void ProcessFBA(const VB& curvb, ZZshParameter sOneColor)
GL_BLEND_ALPHA(GL_ONE, GL_ONE);
GL_BLENDEQ_ALPHA(GL_FUNC_ADD);
float f = 1;
ZZshSetParameter4fv(sOneColor, &f, "g_fOneColor");
// FIXME: Seem dangerous
// float f = 1;
// ZZshSetParameter4fv(pfragment->prog, pfragment->sOneColor, &f, "g_fOneColor");
float4 v = float4(1,1,0,0);
ZZshSetParameter4fv(pfragment->prog, pfragment->sOneColor, v, "g_fOneColor");
ZZshSetPixelShader(ppsOne.prog);
Draw(curvb);
glDisable(GL_ALPHA_TEST);
@ -1840,11 +1853,10 @@ void SetTexClamping(int context, FRAGMENTSHADER* pfragment)
}
if (pfragment->fTexWrapMode != 0)
ZZshSetParameter4fv(pfragment->fTexWrapMode, v, "g_fTexWrapMode");
ZZshSetParameter4fv(pfragment->prog, pfragment->fTexWrapMode, v, "g_fTexWrapMode");
if (pfragment->fClampExts != 0)
ZZshSetParameter4fv(pfragment->fClampExts, v2, "g_fClampExts");
ZZshSetParameter4fv(pfragment->prog, pfragment->fClampExts, v2, "g_fClampExts");
}
@ -1917,15 +1929,15 @@ void SetTexVariables(int context, FRAGMENTSHADER* pfragment)
valpha.z = (tex0.tfx == TFX_HIGHLIGHT2);
valpha.w = (tex0.tcc == 0) || (tex0.tcc == 1 && tex0.tfx == TFX_HIGHLIGHT);
ZZshSetParameter4fv(pfragment->fTexAlpha, valpha, "g_fTexAlpha");
ZZshSetParameter4fv(pfragment->fTexAlpha2, valpha2, "g_fTexAlpha2");
ZZshSetParameter4fv(pfragment->prog, pfragment->fTexAlpha, valpha, "g_fTexAlpha");
ZZshSetParameter4fv(pfragment->prog, pfragment->fTexAlpha2, valpha2, "g_fTexAlpha2");
if (IsAlphaTestExpansion(tex0))
{
float4 vblack;
vblack.x = vblack.y = vblack.z = vblack.w = 10;
if (tex0.tcc && gs.texa.aem && psm == PSMCT24) vblack.w = 0;
ZZshSetParameter4fv(pfragment->fTestBlack, vblack, "g_fTestBlack");
ZZshSetParameter4fv(pfragment->prog, pfragment->fTestBlack, vblack, "g_fTestBlack");
}
SetTexClamping(context, pfragment);
@ -2025,11 +2037,11 @@ void SetTexVariablesInt(int context, int bilinear, const tex0Info& tex0, bool Ch
v.z *= b.bpp * (1 / 32.0f);
}
ZZshSetParameter4fv(pfragment->fTexDims, vTexDims, "g_fTexDims");
ZZshSetParameter4fv(pfragment->prog, pfragment->fTexDims, vTexDims, "g_fTexDims");
// ZZshSetParameter4fv(pfragment->fTexBlock, b.vTexBlock, "g_fTexBlock"); // I change it, and it's working. Seems casting from float4 to float[4] is ok.
ZZshSetParameter4fv(pfragment->fTexBlock, &b.vTexBlock.x, "g_fTexBlock");
ZZshSetParameter4fv(pfragment->fTexOffset, v, "g_fTexOffset");
ZZshSetParameter4fv(pfragment->prog, pfragment->fTexBlock, &b.vTexBlock.x, "g_fTexBlock");
ZZshSetParameter4fv(pfragment->prog, pfragment->fTexOffset, v, "g_fTexOffset");
// get hardware texture dims
//int texheight = pmemtarg->texH;
@ -2049,7 +2061,7 @@ void SetTexVariablesInt(int context, int bilinear, const tex0Info& tex0, bool Ch
v.w = 0.5f;*/
v.w = 0.5f;
ZZshSetParameter4fv(pfragment->fPageOffset, v, "g_fPageOffset");
ZZshSetParameter4fv(pfragment->prog, pfragment->fPageOffset, v, "g_fPageOffset");
if (force)
s_ptexCurSet[context] = pmemtarg->ptex->tex;

6
plugins/zzogl-pg/opengl/ZZoglFlush.h
View File

@ -108,11 +108,11 @@ void SetAlphaVariables(const alphaInfo& ainfo); // zzz
inline void SetAlphaTestInt(pixTest curtest);
inline void RenderAlphaTest(const VB& curvb, ZZshParameter sOneColor);
inline void RenderAlphaTest(const VB& curvb, FRAGMENTSHADER* pfragment);
inline void RenderStencil(const VB& curvb, u32 dwUsingSpecialTesting);
inline void ProcessStencil(const VB& curvb);
inline void RenderFBA(const VB& curvb, ZZshParameter sOneColor);
inline void ProcessFBA(const VB& curvb, ZZshParameter sOneColor); // zz
inline void RenderFBA(const VB& curvb, FRAGMENTSHADER* pfragment);
inline void ProcessFBA(const VB& curvb, FRAGMENTSHADER* pfragment); // zz
void SetContextTarget(int context);

6
plugins/zzogl-pg/opengl/ZZoglShaders.cpp
View File

@ -276,13 +276,13 @@ void ZZshSetParameter4fv(ZZshParameter param, const float* v, const char* name)
cgGLSetParameter4fv(param, v);
}
void ZZshSetParameter4fv(ZZshProgram prog, ZZshParameter param, const float* v, const char* name) {
void ZZshSetParameter4fv(ZZshProgram& prog, ZZshParameter param, const float* v, const char* name) {
ShaderHandleName = name;
cgGLSetParameter4fv(param, v);
}
// The same stuff, but also with retry of param, name should be USED name of param for prog.
void ZZshSetParameter4fvWithRetry(ZZshParameter* param, ZZshProgram prog, const float* v, const char* name) {
void ZZshSetParameter4fvWithRetry(ZZshParameter* param, ZZshProgram& prog, const float* v, const char* name) {
if (param != NULL)
ZZshSetParameter4fv(prog, param[0], v, name);
else
@ -303,7 +303,7 @@ void ZZshGLSetTextureParameter(ZZshProgram prog, ZZshParameter param, GLuint tex
}
// Used sometimes for color 1.
void ZZshDefaultOneColor( FRAGMENTSHADER ptr ) {
void ZZshDefaultOneColor( FRAGMENTSHADER& ptr ) {
ShaderHandleName = "Set Default One color";
float4 v = float4 ( 1, 1, 1, 1 );
ZZshSetParameter4fv( ptr.prog, ptr.sOneColor, v, "DefaultOne");

413
plugins/zzogl-pg/opengl/ZZoglShaders.h
View File

@ -30,6 +30,7 @@
#define SHADER_REDUCED 1 // equivalent to ps2.0
#define SHADER_ACCURATE 2 // for older cards with less accurate math (ps2.x+)
#include <math.h>
#include "ZZoglMath.h"
#include "GS.h"
@ -58,6 +59,11 @@ inline bool ZZshActiveParameter(ZZshParameter param) {return (param !=NULL); }
#endif // end NVIDIA cg-toolkit API
#ifdef GLSL4_API
#include "GSUniformBufferOGL.h"
#include "GSVertexArrayOGL.h"
#endif
#ifdef GLSL_API
enum ZZshPARAMTYPE {
@ -106,6 +112,108 @@ inline bool ZZshActiveParameter(ZZshParameter param) {return (param > -1); }
#endif
extern float4 g_vdepth;
extern float4 vlogz;
#ifdef GLSL4_API
enum {
ZZSH_CTX_0 = 0,
ZZSH_CTX_1 = 1,
ZZSH_CTX_ALL = 2
};
// Note A nice template could be better
// Warning order is important for buffer (see GLSL)
// Note must be keep POD (so you can map it to GLSL)
struct GlobalUniform {
union {
struct {
// VS
float g_fPosXY[4]; // dual context
// PS
float g_fFogColor[4];
};
float linear[2*4];
};
void SettleFloat(uint indice, const float* v) {
assert(indice + 3 < 2*4);
linear[indice+0] = v[0];
linear[indice+1] = v[1];
linear[indice+2] = v[2];
linear[indice+3] = v[3];
}
};
struct ConstantUniform {
union {
struct {
// Both VS/PS
float g_fBilinear[4];
float g_fZbias[4];
float g_fc0[4];
float g_fMult[4];
// VS
float g_fZ[4];
float g_fZMin[4];
float g_fZNorm[4];
// PS
float g_fExactColor[4];
};
float linear[8*4];
};
void SettleFloat(uint indice, const float* v) {
assert(indice + 3 < 8*4);
linear[indice+0] = v[0];
linear[indice+1] = v[1];
linear[indice+2] = v[2];
linear[indice+3] = v[3];
}
};
struct FragmentUniform {
union {
struct {
float g_fTexAlpha2[4]; // dual context
float g_fTexOffset[4]; // dual context
float g_fTexDims[4]; // dual context
float g_fTexBlock[4]; // dual context
float g_fClampExts[4]; // dual context
float g_fTexWrapMode[4]; // dual context
float g_fRealTexDims[4]; // dual context
float g_fTestBlack[4]; // dual context
float g_fPageOffset[4]; // dual context
float g_fTexAlpha[4]; // dual context
float g_fInvTexDims[4];
float g_fBitBltZ[4];
float g_fOneColor[4];
};
float linear[13*4];
};
void SettleFloat(uint indice, const float* v) {
assert(indice + 3 < 13*4);
linear[indice+0] = v[0];
linear[indice+1] = v[1];
linear[indice+2] = v[2];
linear[indice+3] = v[3];
}
};
struct VertexUniform {
union {
struct {
float g_fBitBltPos[4];
float g_fBitBltTex[4];
float g_fBitBltTrans[4];
};
float linear[3*4];
};
void SettleFloat(uint indice, const float* v) {
assert(indice + 3 < 3*4);
linear[indice+0] = v[0];
linear[indice+1] = v[1];
linear[indice+2] = v[2];
linear[indice+3] = v[3];
}
};
#endif
@ -124,6 +232,7 @@ extern ZZshParameter g_vparamPosXY[2], g_fparamFogColor;
#define MAX_ACTIVE_UNIFORMS 600
#define MAX_ACTIVE_SHADERS 400
#ifndef GLSL4_API
struct FRAGMENTSHADER
{
FRAGMENTSHADER() : prog(sZero), Shader(0), sMemory(pZero), sFinal(pZero), sBitwiseANDX(pZero), sBitwiseANDY(pZero), sInterlace(pZero), sCLUT(pZero), sOneColor(pZero), sBitBltZ(pZero),
@ -217,7 +326,239 @@ struct FRAGMENTSHADER
}
#endif
};
#else
const GLenum g_texture_target[11] = {GL_TEXTURE_RECTANGLE, GL_TEXTURE_RECTANGLE, GL_TEXTURE_2D, GL_TEXTURE_2D, GL_TEXTURE_2D, GL_TEXTURE_3D, GL_TEXTURE_RECTANGLE, GL_TEXTURE_RECTANGLE, GL_TEXTURE_RECTANGLE, GL_TEXTURE_2D, GL_TEXTURE_RECTANGLE};
extern int g_current_texture_bind[11];
struct SamplerParam {
int unit;
GLuint texid;
GLenum target;
SamplerParam() : unit(-1), texid(0), target(0) {}
void set_unit(int new_unit) {
assert(new_unit < 11);
unit = new_unit;
target = g_texture_target[new_unit];
}
void enable_texture() {
assert(unit >= 0);
assert(unit < 11);
if (texid) {
if (g_current_texture_bind[unit] != texid) {
glActiveTexture(GL_TEXTURE0 + unit);
glBindTexture(target, texid);
g_current_texture_bind[unit] = texid;
}
}
}
void set_texture(GLuint new_texid) {
texid = new_texid;
}
void release_texture() {
texid = 0;
}
};
struct FRAGMENTSHADER
{
FRAGMENTSHADER() : prog(sZero)
, program(0)
, context(0)
, sMemory(0) // dual context need 2 slots
, sFinal(2)
, sBitwiseANDX(3)
, sBitwiseANDY(4)
, sInterlace(5)
, sCLUT(6)
{
// Uniform
sOneColor = (ZZshParameter)offsetof(struct FragmentUniform, g_fOneColor) /4;
sBitBltZ = (ZZshParameter)offsetof(struct FragmentUniform, g_fBitBltZ) /4;
sInvTexDims = (ZZshParameter)offsetof(struct FragmentUniform, g_fInvTexDims) /4;
fTexAlpha = (ZZshParameter)offsetof(struct FragmentUniform, g_fTexAlpha) /4;
fTexAlpha2 = (ZZshParameter)offsetof(struct FragmentUniform, g_fTexAlpha2) /4;
fTexOffset = (ZZshParameter)offsetof(struct FragmentUniform, g_fTexOffset) /4;
fTexDims = (ZZshParameter)offsetof(struct FragmentUniform, g_fTexDims) /4;
fTexBlock = (ZZshParameter)offsetof(struct FragmentUniform, g_fTexBlock) /4;
fClampExts = (ZZshParameter)offsetof(struct FragmentUniform, g_fClampExts) /4; // FIXME: There is a bug, that lead FFX-1 to incorrect CLAMP if this uniform have context.
fTexWrapMode = (ZZshParameter)offsetof(struct FragmentUniform, g_fTexWrapMode) /4;
fRealTexDims = (ZZshParameter)offsetof(struct FragmentUniform, g_fRealTexDims) /4;
fTestBlack = (ZZshParameter)offsetof(struct FragmentUniform, g_fTestBlack) /4;
fPageOffset = (ZZshParameter)offsetof(struct FragmentUniform, g_fPageOffset) /4;
//sFinal = 2;
//sBitwiseANDX = 3;
//sBitwiseANDY = 4;
//sInterlace = 5;
//sCLUT = 6;
samplers[sMemory].set_unit(10);
samplers[sMemory+1].set_unit(10); // Dual context. Use same unit
samplers[sFinal].set_unit(1);
samplers[sBitwiseANDX].set_unit(6);
samplers[sBitwiseANDY].set_unit(7);
samplers[sInterlace].set_unit(8);
samplers[sCLUT].set_unit(9);
prog.isFragment = true;
prog.link = (void*)this;
}
ZZshShaderLink prog; // it link to FRAGMENTSHADER structure, for compability between GLSL and CG
ZZshProgram program;
uint context;
FragmentUniform uniform_buffer[ZZSH_CTX_ALL];
// sampler
const ZZshParameter sMemory;
const ZZshParameter sFinal, sBitwiseANDX, sBitwiseANDY, sInterlace, sCLUT;
SamplerParam samplers[7];
// uniform
ZZshParameter sOneColor, sBitBltZ, sInvTexDims;
ZZshParameter fTexAlpha2, fTexOffset, fTexDims, fTexBlock, fClampExts, fTexWrapMode, fRealTexDims, fTestBlack, fPageOffset, fTexAlpha;
#ifdef _DEBUG
string filename;
#endif
void ZZshSetParameter4fv(ZZshParameter param, const float* v) {
if (IsDualContext(param))
uniform_buffer[context].SettleFloat((int) param, v);
else
for ( int i = 0; i < ZZSH_CTX_ALL ; i++)
uniform_buffer[i].SettleFloat((int) param, v);
}
bool IsDualContext(ZZshParameter param) {
if (param == sInvTexDims || param == sBitBltZ || param == sOneColor)
return false;
else
return true;
}
void enable_texture() {
samplers[sMemory+context].enable_texture(); // sMemory is dual context
for (int i = 2; i < 7; i++)
samplers[i].enable_texture();
}
void set_texture(ZZshParameter param, GLuint texid) {
if (param == sMemory) // sMemory is dual context
samplers[sMemory+context].set_texture(texid);
else
samplers[param].set_texture(texid);
}
void release_prog() {
if(program) {
glDeleteProgram(program);
program = 0;
}
for (uint i = 0; i < 7 ; i++)
samplers[i].release_texture();
}
};
#endif
#ifdef GLSL4_API
struct COMMONSHADER
{
COMMONSHADER() : context(0)
, sBlocks(0)
, sBilinearBlocks(1)
, sConv16to32(2)
, sConv32to16(3)
{
// sBlocks = 0;
// sBilinearBlocks = 1;
// sConv16to32 = 2;
// sConv32to16 = 3;
samplers[sBlocks].set_unit(2);
samplers[sBilinearBlocks].set_unit(3);
samplers[sConv16to32].set_unit(4);
samplers[sConv32to16].set_unit(5);
g_fparamFogColor = (ZZshParameter)offsetof(struct GlobalUniform, g_fFogColor) /4;
g_vparamPosXY = (ZZshParameter)offsetof(struct GlobalUniform, g_fPosXY) /4;
g_fBilinear = (ZZshParameter)offsetof(struct ConstantUniform, g_fBilinear) /4;
g_fZBias = (ZZshParameter)offsetof(struct ConstantUniform, g_fZbias) /4;
g_fc0 = (ZZshParameter)offsetof(struct ConstantUniform, g_fc0) /4;
g_fMult = (ZZshParameter)offsetof(struct ConstantUniform, g_fMult) /4;
g_fZ = (ZZshParameter)offsetof(struct ConstantUniform, g_fZ) /4;
g_fZMin = (ZZshParameter)offsetof(struct ConstantUniform, g_fZMin) /4;
g_fZNorm = (ZZshParameter)offsetof(struct ConstantUniform, g_fZNorm) /4;
g_fExactColor = (ZZshParameter)offsetof(struct ConstantUniform, g_fExactColor) /4;
// Setup the constant buffer
// Set Z-test, log or no log;
if (conf.settings().no_logz) {
g_vdepth = float4( 255.0 /256.0f, 255.0/65536.0f, 255.0f/(65535.0f*256.0f), 1.0f/(65536.0f*65536.0f));
vlogz = float4( 1.0f, 0.0f, 0.0f, 0.0f);
}
else {
g_vdepth = float4( 256.0f*65536.0f, 65536.0f, 256.0f, 65536.0f*65536.0f);
vlogz = float4( 0.0f, 1.0f, 0.0f, 0.0f);
}
uniform_buffer_constant.SettleFloat(g_fZ, g_vdepth );
uniform_buffer_constant.SettleFloat(g_fZMin, vlogz );
const float g_filog32 = 0.999f / (32.0f * logf(2.0f));
float4 vnorm = float4(g_filog32, 0, 0,0);
uniform_buffer_constant.SettleFloat(g_fZNorm, vnorm);
uniform_buffer_constant.SettleFloat(g_fBilinear, float4(-0.2f, -0.65f, 0.9f, 1.0f / 32767.0f ) );
uniform_buffer_constant.SettleFloat(g_fZBias, float4(1.0f/256.0f, 1.0004f, 1, 0.5f) );
uniform_buffer_constant.SettleFloat(g_fc0, float4(0,1, 0.001f, 0.5f) );
uniform_buffer_constant.SettleFloat(g_fExactColor, float4(0.5f, (conf.settings().exact_color)?0.9f/256.0f:0.5f/256.0f, 0,1/255.0f) );
uniform_buffer_constant.SettleFloat(g_fMult, float4(1/1024.0f, 0.2f/1024.0f, 1/128.0f, 1/512.0f));
}
ZZshParameter g_fparamFogColor, g_vparamPosXY;
ZZshParameter g_fBilinear, g_fZBias, g_fc0, g_fMult, g_fZ, g_fZMin, g_fZNorm, g_fExactColor;
uint context;
GlobalUniform uniform_buffer[ZZSH_CTX_ALL];
ConstantUniform uniform_buffer_constant;
// Sampler
const ZZshParameter sBlocks, sBilinearBlocks, sConv16to32, sConv32to16;
SamplerParam samplers[4];
void ZZshSetParameter4fv(ZZshParameter param, const float* v) {
if (IsDualContext(param))
uniform_buffer[context].SettleFloat((int) param, v);
else
for ( int i = 0; i < ZZSH_CTX_ALL ; i++)
uniform_buffer[i].SettleFloat((int) param, v);
}
bool IsDualContext(ZZshParameter param) {
if (param == g_vparamPosXY) return true;
else return false;
}
void set_texture(ZZshParameter param, GLuint texid) {
samplers[param].set_texture(texid);
}
void enable_texture() {
for (int i = 0; i < 4; i++)
samplers[i].enable_texture();
}
};
#endif
#ifndef GLSL4_API
struct VERTEXSHADER
{
VERTEXSHADER() : prog(sZero), Shader(0), sBitBltPos(pZero), sBitBltTex(pZero) {}
@ -230,15 +571,54 @@ struct VERTEXSHADER
int ParametersStart, ParametersFinish;
};
#else
struct VERTEXSHADER
{
VERTEXSHADER() : prog(sZero), program(0), context(0)
{
sBitBltPos = (ZZshParameter)offsetof(struct VertexUniform, g_fBitBltPos) /4;
sBitBltTex = (ZZshParameter)offsetof(struct VertexUniform, g_fBitBltTex) /4;
fBitBltTrans = (ZZshParameter)offsetof(struct VertexUniform, g_fBitBltTrans) /4;
// Default value not sure it is needed
uniform_buffer[0].SettleFloat(fBitBltTrans, float4(0.5f, -0.5f, 0.5, 0.5 + 0.4/416.0f ) );
uniform_buffer[1].SettleFloat(fBitBltTrans, float4(0.5f, -0.5f, 0.5, 0.5 + 0.4/416.0f ) );
prog.isFragment = false;
prog.link = (void*)this;
}
VertexUniform uniform_buffer[ZZSH_CTX_ALL];
ZZshShaderLink prog;
ZZshProgram program;
uint context;
ZZshParameter sBitBltPos, sBitBltTex, fBitBltTrans; // vertex shader constants
void ZZshSetParameter4fv(ZZshParameter param, const float* v) {
if (IsDualContext(param))
uniform_buffer[context].SettleFloat((int) param, v);
else
for ( int i = 0; i < ZZSH_CTX_ALL ; i++)
uniform_buffer[i].SettleFloat((int) param, v);
}
bool IsDualContext(ZZshParameter param) { return false;}
};
#endif
extern float4 g_vdepth;
extern float4 vlogz;
extern VERTEXSHADER pvsBitBlt;
extern FRAGMENTSHADER ppsBitBlt[2], ppsBitBltDepth, ppsOne; // ppsOne used to stop using shaders for draw
extern FRAGMENTSHADER ppsBaseTexture, ppsConvert16to32, ppsConvert32to16;
extern FRAGMENTSHADER ppsRegular[4], ppsTexture[NUM_SHADERS];
extern FRAGMENTSHADER ppsCRTC[2], /*ppsCRTC24[2],*/ ppsCRTCTarg[2];
#ifdef GLSL4_API
extern COMMONSHADER g_cs;
#endif
extern int interlace_mode;
@ -271,11 +651,16 @@ inline bool ZZshExistProgram(FRAGMENTSHADER* pf) {return (pf->prog != NULL); };
inline bool ZZshExistProgram(VERTEXSHADER* pf) {return (pf->prog != NULL); };
inline bool ZZshExistProgram(ZZshShaderLink prog) {return (prog != NULL); };
#endif
#ifdef GLSL_API
#if defined(GLSL_API) && !defined(GLSL4_API)
inline bool ZZshExistProgram(FRAGMENTSHADER* pf) {return (pf->Shader != 0); };
inline bool ZZshExistProgram(VERTEXSHADER* pf) {return (pf->Shader != 0); };
inline bool ZZshExistProgram(ZZshShaderLink prog) {return (prog.link != NULL); } // This is used for pvs mainly. No NULL means that we do LOAD_VS
#endif
#if defined(GLSL4_API)
inline bool ZZshExistProgram(FRAGMENTSHADER* pf) {return (pf->program != 0); };
inline bool ZZshExistProgram(VERTEXSHADER* pf) {return (pf->program != 0); };
inline bool ZZshExistProgram(ZZshShaderLink prog) {return (prog.link != NULL); } // This is used for pvs mainly. No NULL means that we do LOAD_VS
#endif
extern const char* ShaderCallerName;
extern const char* ShaderHandleName;
@ -318,16 +703,16 @@ extern void ZZshGLEnableProfile();
// Set the Uniform parameter in host (NOT GL)
// Param seem to be an absolute index inside a table of uniform
extern void ZZshSetParameter4fv(ZZshShaderLink prog, ZZshParameter param, const float* v, const char* name);
extern void ZZshSetParameter4fv(ZZshShaderLink& prog, ZZshParameter param, const float* v, const char* name);
extern void ZZshSetParameter4fv(ZZshParameter param, const float* v, const char* name);
extern void ZZshSetParameter4fvWithRetry(ZZshParameter* param, ZZshShaderLink prog, const float* v, const char* name);
extern void ZZshSetParameter4fvWithRetry(ZZshParameter* param, ZZshShaderLink& prog, const float* v, const char* name);
// Set the Texture parameter in host (NOT GL)
extern void ZZshGLSetTextureParameter(ZZshShaderLink prog, ZZshParameter param, GLuint texobj, const char* name);
extern void ZZshGLSetTextureParameter(ZZshParameter param, GLuint texobj, const char* name);
// Set a default value for 1 uniform in host (NOT GL)
extern void ZZshDefaultOneColor( FRAGMENTSHADER ptr );
extern void ZZshDefaultOneColor( FRAGMENTSHADER& ptr );
// Link then run with the new Vertex/Fragment Shader
extern void ZZshSetVertexShader(ZZshShaderLink prog);
@ -350,5 +735,21 @@ extern u32 ptexConv16to32; // does not exists. This textures should be created o
extern u32 ptexBilinearBlocks;
extern u32 ptexConv32to16;
#ifdef GLSL4_API
extern GSUniformBufferOGL *constant_buffer;
extern GSUniformBufferOGL *common_buffer;
extern GSUniformBufferOGL *vertex_buffer;
extern GSUniformBufferOGL *fragment_buffer;
extern GSVertexBufferStateOGL *vertex_array;
extern GLenum g_current_vs;
extern GLenum g_current_ps;
extern void init_shader();
extern void PutParametersInProgram(VERTEXSHADER* vs, FRAGMENTSHADER* ps);
extern void init_shader();
extern void ZZshSetupShader();
#endif
#endif

23
plugins/zzogl-pg/opengl/ZZoglShadersGLSL.cpp
View File

@ -17,7 +17,7 @@
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifdef GLSL_API // This code is only for GLSL API
#if defined(GLSL_API) && !defined(GLSL4_API) // This code is only for GLSL API
// ZZogl Shader manipulation functions.
/*
@ -237,10 +237,10 @@ bool ZZshCreateOpenShadersFile() {
if ((ShaderFD == -1) || (fstat(ShaderFD, &sb) == -1)) {
// Each linux distributions have his rules for path so we give them the possibility to
// change it with compilation flags. -- Gregory
#ifdef PLUGIN_DIR_COMPILATION
#define xPLUGIN_DIR_str(s) PLUGIN_DIR_str(s)
#define PLUGIN_DIR_str(s) #s
ShaderFileName = string(xPLUGIN_DIR_str(PLUGIN_DIR_COMPILATION)) + "/ps2hw.glsl";
#ifdef GLSL_SHADER_DIR_COMPILATION
#define xGLSL_SHADER_DIR_str(s) GLSL_SHADER_DIR_str(s)
#define GLSL_SHADER_DIR_str(s) #s
ShaderFileName = string(xGLSL_SHADER_DIR_str(GLSL_SHADER_DIR_COMPILATION)) + "/ps2hw.glsl";
ShaderFD = open(ShaderFileName.c_str(), O_RDONLY);
#endif
if ((ShaderFD == -1) || (fstat(ShaderFD, &sb) == -1)) {
@ -290,7 +290,7 @@ void ZZshGLSetTextureParameter(ZZshShaderLink prog, ZZshParameter param, GLuint
// This is helper of cgGLSetParameter4fv, made for debug purpose.
// Name could be any string. We must use it on compilation time, because erroneus handler does not
// return name
void ZZshSetParameter4fv(ZZshShaderLink prog, ZZshParameter param, const float* v, const char* name) {
void ZZshSetParameter4fv(ZZshShaderLink& prog, ZZshParameter param, const float* v, const char* name) {
if (param > -1) {
// ZZLog::Error_Log("Set float parameter %s %f, %f, %f, %f... Ok", name, v[0], v[1], v[2], v[3]);
SettleFloat(UniformsIndex[param].fvalue, v);
@ -307,13 +307,13 @@ void ZZshSetParameter4fv(ZZshParameter param, const float* v, const char* name)
}
// The same stuff, but also with retry of param, name should be USED name of param for prog.
void ZZshSetParameter4fvWithRetry(ZZshParameter* param, ZZshShaderLink prog, const float* v, const char* name) {
void ZZshSetParameter4fvWithRetry(ZZshParameter* param, ZZshShaderLink& prog, const float* v, const char* name) {
if (param != NULL)
ZZshSetParameter4fv(prog, *param, v, name);
}
// Used sometimes for color 1.
void ZZshDefaultOneColor( FRAGMENTSHADER ptr ) {
void ZZshDefaultOneColor( FRAGMENTSHADER& ptr ) {
// return;
ShaderHandleName = "Set Default One colot";
float4 v = float4 ( 1, 1, 1, 1 );
@ -426,7 +426,7 @@ inline bool GetLinkLog(ZZshProgram prog) {
if (LinkStatus == GL_TRUE && glIsProgram(prog)) return true;
#ifdef DEVBUILD
#if defined(DEVBUILD) || defined(_DEBUG)
int* lenght, infologlength;
glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &infologlength);
char* InfoLog = new char[infologlength];
@ -474,6 +474,9 @@ static void PutParametersInProgam(int start, int finish) {
}
else
{
// assert(param.texid != 0);
// ZZLog::Error_Log("Set texture (%s) : %d with sampler %d\n", param.ShName, param.texid, param.sampler);
// assert(param.sampler >= 0);
glActiveTexture(GL_TEXTURE0 + param.sampler);
if (param.type == ZZ_TEXTURE_2D)
glBindTexture(GL_TEXTURE_2D, param.texid);
@ -974,4 +977,4 @@ FRAGMENTSHADER* ZZshLoadShadeEffect(int type, int texfilter, int fog, int testae
return NULL;
}
#endif // GLSL_API
#endif

610
plugins/zzogl-pg/opengl/ZZoglShadersGLSL4.cpp Normal file
View File

@ -0,0 +1,610 @@
/* ZZ Open GL graphics plugin
* Copyright (c)2009 zeydlitz@gmail.com
* Based on Zerofrog's ZeroGS KOSMOS (c)2005-2006
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifdef GLSL4_API // This code is only for GLSL API
// ZZogl Shader manipulation functions.
/*
* used cg calls:
* cgGLIsProfileSupported -- don't needed
* cgGetErrorString -- later
* cgGetLastListing -- later
* cgSetErrorHandler -- later
* cgCreateContext -- think that don't need
* cgGLEnableProfile -- don't need
* cgGLSetOptimalOptions -- don't need?
* cgGLSetManageTextureParameters -- what's this?
* cgCreateParameter -- don't need
* cgGLLoadProgram void LinkProgram(uint program)
* cgGetError -- later
* cgGLDisableProfile -- don't need
* cgGLSetParameter4fv
* cgGetNamedParameter
* cgGLEnableTextureParameter
* cgIsParameterUsed
* cgGLBindProgram void UseProgram(uint program)
* cgConnectParameter
* cgIsProgram bool IsProgram(uint program)
* cgCreateProgramFromFile
*/
//------------------- Includes
#include "Util.h"
#include "ZZoglShaders.h"
#include "zpipe.h"
#include <math.h>
#include <map>
#include <fcntl.h> // this for open(). Maybe linux-specific
#include <sys/mman.h> // and this for mmap
// ----------------- Defines
#define TEXWRAP_REPEAT 0
#define TEXWRAP_CLAMP 1
#define TEXWRAP_REGION_REPEAT 2
#define TEXWRAP_REPEAT_CLAMP 3
#ifdef DEVBUILD
# define UNIFORM_ERROR_LOG ZZLog::Error_Log
#else
# define UNIFORM_ERROR_LOG
#endif
// Set it to 0 to diable context usage, 1 -- to enable. FFX-1 have a strange issue with ClampExt.
#define NOCONTEXT 0
#define NUMBER_OF_SAMPLERS 11
#define MAX_SHADER_NAME_SIZE 25
#define DEFINE_STRING_SIZE 256
// #define ENABLE_MARKER // Fire some marker for opengl Debugger (apitrace, gdebugger)
//------------------ Constants
// Used in a logarithmic Z-test, as (1-o(1))/log(MAX_U32).
const float g_filog32 = 0.999f / (32.0f * logf(2.0f));
const static char* g_pTexTypes[] = { "32", "tex32", "clut32", "tex32to16", "tex16to8h" };
const static char* g_pShaders[4] = { "full", "reduced", "accurate", "accurate-reduced" };
const static char* g_pPsTexWrap[] = { "#define REPEAT 1\n", "#define CLAMP 1\n", "#define REGION_REPEAT 1\n", "\n" };
const int GLSL_VERSION = 330;
// ----------------- Global Variables
ZZshContext g_cgcontext;
ZZshProfile cgvProf, cgfProf;
int g_nPixelShaderVer = 0; // default
u8* s_lpShaderResources = NULL;
ZZshShaderLink pvs[16] = {sZero}, g_vsprog = sZero, g_psprog = sZero; // 2 -- ZZ
ZZshParameter g_vparamPosXY[2] = {pZero}, g_fparamFogColor = pZero;
char* ZZshSource; // Shader's source data.
off_t ZZshSourceSize;
bool g_bCRTCBilinear = true;
float4 g_vdepth, vlogz;
FRAGMENTSHADER ppsBitBlt[2], ppsBitBltDepth, ppsOne;
FRAGMENTSHADER ppsBaseTexture, ppsConvert16to32, ppsConvert32to16;
FRAGMENTSHADER ppsRegular[4], ppsTexture[NUM_SHADERS];
FRAGMENTSHADER ppsCRTC[2], /*ppsCRTC24[2],*/ ppsCRTCTarg[2];
VERTEXSHADER pvsStore[16];
VERTEXSHADER pvsBitBlt;
inline bool LoadEffects();
extern bool s_bWriteDepth;
// Debug variable, store name of the function that call the shader.
const char* ShaderCallerName = "";
const char* ShaderHandleName = "";
ZZshProgram CompiledPrograms[MAX_ACTIVE_SHADERS][MAX_ACTIVE_SHADERS] = {{0}};
// new for GLSL4
GSUniformBufferOGL *constant_buffer;
GSUniformBufferOGL *common_buffer;
GSUniformBufferOGL *vertex_buffer;
GSUniformBufferOGL *fragment_buffer;
static bool dirty_common_buffer = true;
static bool dirty_vertex_buffer = true;
static bool dirty_fragment_buffer = true;
GSVertexBufferStateOGL *vertex_array;
COMMONSHADER g_cs;
static GLuint s_pipeline = 0;
int g_current_texture_bind[11] = {0};
GLenum g_current_vs = NULL;
GLenum g_current_ps = NULL;
//FRAGMENTSHADER ppsDebug;
//FRAGMENTSHADER ppsDebug2;
//------------------ Code
inline int GET_SHADER_INDEX(int type, int texfilter, int texwrap, int fog, int writedepth, int testaem, int exactcolor, int context, int ps) {
return type + texfilter*NUM_TYPES + NUM_FILTERS*NUM_TYPES*texwrap + NUM_TEXWRAPS*NUM_FILTERS*NUM_TYPES*(fog+2*writedepth+4*testaem+8*exactcolor+16*context+32*ps) ;
}
// Nothing need to be done.
bool ZZshCheckProfilesSupport() {
return true;
}
// Error handler. Setup in ZZogl_Create once.
void HandleCgError(ZZshContext ctx, ZZshError err, void* appdata)
{/*
ZZLog::Error_Log("%s->%s: %s", ShaderCallerName, ShaderHandleName, cgGetErrorString(err));
const char* listing = cgGetLastListing(g_cgcontext);
if (listing != NULL)
ZZLog::Debug_Log(" last listing: %s", listing);
*/
}
bool ZZshStartUsingShaders() {
ZZLog::Error_Log("Creating effects.");
B_G(LoadEffects(), return false);
if (!glCreateShader)
{
ZZLog::Error_Log("GLSL shaders is not supported, stop.");
return false;
}
init_shader();
// create a sample shader
clampInfo temp;
memset(&temp, 0, sizeof(temp));
temp.wms = 3; temp.wmt = 3;
g_nPixelShaderVer = 0;//SHADER_ACCURATE;
// test
bool bFailed;
FRAGMENTSHADER* pfrag = ZZshLoadShadeEffect(0, 1, 1, 1, 1, temp, 0, &bFailed);
if( bFailed || pfrag == NULL ) {
return false;
ZZLog::Error_Log("Shader test failed.");
}
ZZLog::Error_Log("Creating extra effects.");
B_G(ZZshLoadExtraEffects(), return false);
ZZLog::Error_Log("Using %s shaders.", g_pShaders[g_nPixelShaderVer]);
return true;
}
// open shader file according to build target
bool ZZshCreateOpenShadersFile() {
std::string ShaderFileName("plugins/ps2hw_gl4.glsl");
int ShaderFD = open(ShaderFileName.c_str(), O_RDONLY);
struct stat sb;
if ((ShaderFD == -1) || (fstat(ShaderFD, &sb) == -1)) {
// Each linux distributions have his rules for path so we give them the possibility to
// change it with compilation flags. -- Gregory
#ifdef GLSL_SHADER_DIR_COMPILATION
#define xGLSL_SHADER_DIR_str(s) GLSL_SHADER_DIR_str(s)
#define GLSL_SHADER_DIR_str(s) #s
ShaderFileName = string(xGLSL_SHADER_DIR_str(GLSL_SHADER_DIR_COMPILATION)) + "/ps2hw_gl4.glsl";
ShaderFD = open(ShaderFileName.c_str(), O_RDONLY);
#endif
if ((ShaderFD == -1) || (fstat(ShaderFD, &sb) == -1)) {
ZZLog::Error_Log("No source for %s: \n", ShaderFileName.c_str());
return false;
}
}
ZZshSourceSize = sb.st_size;
ZZshSource = (char*)mmap(NULL, sb.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, ShaderFD, 0); // This function directly maped file into memory.
ZZshSource[ ZZshSourceSize - 1] = 0; // Made source null-terminated.
close(ShaderFD);
return true;
}
void ZZshExitCleaning() {
munmap(ZZshSource, ZZshSourceSize);
delete constant_buffer;
delete common_buffer;
delete vertex_buffer;
delete fragment_buffer;
glDeleteProgramPipelines(1, &s_pipeline);
}
// Disable CG
void ZZshGLDisableProfile() { // This stop all other shader programs from running;
glBindProgramPipeline(0);
}
//Enable CG
void ZZshGLEnableProfile() {
glBindProgramPipeline(s_pipeline);
}
//-------------------------------------------------------------------------------------
// The same function for texture, also to cgGLEnable
void ZZshGLSetTextureParameter(ZZshParameter param, GLuint texobj, const char* name) {
#ifdef ENABLE_MARKER
char* debug = new char[100];
sprintf(debug, "CS: texture %d, param %d", texobj, param);
if (GLEW_GREMEDY_string_marker) glStringMarkerGREMEDY(0, debug);
#endif
g_cs.set_texture(param, texobj);
}
void ZZshGLSetTextureParameter(ZZshShaderLink prog, ZZshParameter param, GLuint texobj, const char* name) {
FRAGMENTSHADER* shader = (FRAGMENTSHADER*)prog.link;
#ifdef ENABLE_MARKER
char* debug = new char[100];
sprintf(debug, "FS(%d):texture %d, param %d", shader->program, texobj, param);
if (GLEW_GREMEDY_string_marker) glStringMarkerGREMEDY(0, debug);
#endif
shader->set_texture(param, texobj);
}
// This is helper of cgGLSetParameter4fv, made for debug purpose.
// Name could be any string. We must use it on compilation time, because erroneus handler does not
// return name
void ZZshSetParameter4fv(ZZshShaderLink& prog, ZZshParameter param, const float* v, const char* name) {
if (prog.isFragment) {
FRAGMENTSHADER* shader = (FRAGMENTSHADER*)prog.link;
shader->ZZshSetParameter4fv(param, v);
dirty_fragment_buffer = true;
} else {
VERTEXSHADER* shader = (VERTEXSHADER*)prog.link;
shader->ZZshSetParameter4fv(param, v);
dirty_vertex_buffer = true;
}
#ifdef ENABLE_MARKER
char* debug = new char[100];
sprintf(debug, "prog: uniform (%s) (%f)", name, *v);
if (GLEW_GREMEDY_string_marker) glStringMarkerGREMEDY(0, debug);
#endif
}
void ZZshSetParameter4fv(ZZshParameter param, const float* v, const char* name) {
g_cs.ZZshSetParameter4fv(param, v);
dirty_common_buffer = true;
#ifdef ENABLE_MARKER
char* debug = new char[100];
sprintf(debug, "CS: uniform (%s) (%f)", name, *v);
if (GLEW_GREMEDY_string_marker) glStringMarkerGREMEDY(0, debug);
#endif
}
// The same stuff, but also with retry of param, name should be USED name of param for prog.
void ZZshSetParameter4fvWithRetry(ZZshParameter* param, ZZshShaderLink& prog, const float* v, const char* name) {
ZZshSetParameter4fv(prog, *param, v, name);
}
// Used sometimes for color 1.
void ZZshDefaultOneColor( FRAGMENTSHADER& ptr ) {
ShaderHandleName = "Set Default One colot";
float4 v = float4 ( 1, 1, 1, 1 );
ptr.ZZshSetParameter4fv(ptr.sOneColor, v);
dirty_fragment_buffer = true;
}
//-------------------------------------------------------------------------------------
static bool ValidateProgram(ZZshProgram Prog) {
GLint isValid;
glValidateProgram(Prog);
glGetProgramiv(Prog, GL_VALIDATE_STATUS, &isValid);
if (!isValid) {
int lenght, infologlength;
glGetProgramiv(Prog, GL_INFO_LOG_LENGTH, &infologlength);
char* InfoLog = new char[infologlength];
glGetProgramInfoLog(Prog, infologlength, &lenght, InfoLog);
ZZLog::Error_Log("Validation %d... %d:\t %s", Prog, infologlength, InfoLog);
}
return (isValid != 0);
}
inline bool CompileShaderFromFile(ZZshProgram& program, const std::string& DefineString, std::string main_entry, GLenum ShaderType)
{
std::string header("");
header += format("#version %d\n", GLSL_VERSION);
header += format("#define %s main\n", main_entry.c_str());
if (ShaderType == GL_VERTEX_SHADER) header += "#define VERTEX_SHADER 1\n";
else if (ShaderType == GL_FRAGMENT_SHADER) header += "#define FRAGMENT_SHADER 1\n";
header += DefineString;
const GLchar* ShaderSource[2];
ShaderSource[0] = header.c_str();
ShaderSource[1] = (const GLchar*)ZZshSource;
program = glCreateShaderProgramv(ShaderType, 2, &ShaderSource[0]);
ZZLog::Debug_Log("Creating program %d for %s", program, main_entry.c_str());
#if defined(DEVBUILD) || defined(_DEBUG)
if (!ValidateProgram(program)) return false;
#endif
return true;
}
//-------------------------------------------------------------------------------------
void ZZshSetupShader() {
VERTEXSHADER* vs = (VERTEXSHADER*)g_vsprog.link;
FRAGMENTSHADER* ps = (FRAGMENTSHADER*)g_psprog.link;
if (vs == NULL || ps == NULL) return;
// From the glValidateProgram docs: "The implementation may use this as an opportunity to perform any internal
// shader modifications that may be required to ensure correct operation of the installed
// shaders given the current GL state"
// It might be a good idea to validate the pipeline also in release mode???
#if defined(DEVBUILD) || defined(_DEBUG)
glValidateProgramPipeline(s_pipeline);
GLint isValid;
glGetProgramPipelineiv(s_pipeline, GL_VALIDATE_STATUS, &isValid);
if (!isValid) ZZLog::Error_Log("Something weird happened on pipeline validation.");
#endif
PutParametersInProgram(vs, ps);
GL_REPORT_ERRORD();
}
void ZZshSetVertexShader(ZZshShaderLink prog) {
g_vsprog = prog;
VERTEXSHADER* vs = (VERTEXSHADER*)g_vsprog.link;
if (!vs) return;
if (vs->program != g_current_vs) {
glUseProgramStages(s_pipeline, GL_VERTEX_SHADER_BIT, vs->program);
g_current_ps = vs->program;
}
}
void ZZshSetPixelShader(ZZshShaderLink prog) {
g_psprog = prog;
FRAGMENTSHADER* ps = (FRAGMENTSHADER*)g_psprog.link;
if (!ps) return;
if (ps->program != g_current_ps) {
glUseProgramStages(s_pipeline, GL_FRAGMENT_SHADER_BIT, ps->program);
g_current_ps = ps->program;
}
}
//------------------------------------------------------------------------------------------------------------------
void init_shader() {
// TODO:
// Note it would be more clever to allocate buffer inside SHADER class
// Add a dirty flags to avoid to upload twice same data...
// You need to attach() properly the uniform buffer;
// Note: don't put GSUniformBuffer creation inside constructor of static object (context won't
// be set to call gl command)
// Warning put same order than GLSL
constant_buffer = new GSUniformBufferOGL(0, sizeof(ConstantUniform));
common_buffer = new GSUniformBufferOGL(1, sizeof(GlobalUniform));
vertex_buffer = new GSUniformBufferOGL(2, sizeof(VertexUniform));
fragment_buffer = new GSUniformBufferOGL(3, sizeof(FragmentUniform));
constant_buffer->bind();
constant_buffer->upload((void*)&g_cs.uniform_buffer_constant);
g_cs.set_texture(g_cs.sBlocks, ptexBlocks);
g_cs.set_texture(g_cs.sConv16to32, ptexConv16to32);
g_cs.set_texture(g_cs.sConv32to16, ptexConv32to16);
g_cs.set_texture(g_cs.sBilinearBlocks, ptexBilinearBlocks);
glGenProgramPipelines(1, &s_pipeline);
glBindProgramPipeline(s_pipeline);
}
void PutParametersInProgram(VERTEXSHADER* vs, FRAGMENTSHADER* ps) {
if (dirty_common_buffer) {
common_buffer->bind();
common_buffer->upload((void*)&g_cs.uniform_buffer[g_cs.context]);
dirty_common_buffer = false;
}
if (dirty_vertex_buffer) {
vertex_buffer->bind();
vertex_buffer->upload((void*)&vs->uniform_buffer[vs->context]);
dirty_vertex_buffer = false;
}
if (dirty_fragment_buffer) {
fragment_buffer->bind();
fragment_buffer->upload((void*)&ps->uniform_buffer[ps->context]);
dirty_fragment_buffer = false;
}
#ifdef ENABLE_MARKER
char* debug = new char[100];
sprintf(debug, "FS(%d): enable texture", ps->program);
if (GLEW_GREMEDY_string_marker) glStringMarkerGREMEDY(0, debug);
#endif
g_cs.enable_texture();
ps->enable_texture();
// By default enable the unit 0, so I have the guarantee that any
// texture command won't change current binding of others unit
glActiveTexture(GL_TEXTURE0);
}
std::string BuildGlslMacro(bool writedepth, int texwrap = 3, bool testaem = false, bool exactcolor = false)
{
std::string header("");
if (writedepth) header += "#define WRITE_DEPTH 1\n";
if (testaem) header += "#define TEST_AEM 1\n";
if (exactcolor) header += "#define EXACT_COLOR 1\n";
header += format("%s", g_pPsTexWrap[texwrap]);
//const char* AddAccurate = (ps & SHADER_ACCURATE)?"#define ACCURATE_DECOMPRESSION 1\n":"";
return header;
}
static __forceinline bool LOAD_VS(const std::string& DefineString, const char* name, VERTEXSHADER& vertex, ZZshProfile context)
{
bool flag = CompileShaderFromFile(vertex.program, DefineString, name, GL_VERTEX_SHADER);
vertex.context = context * NOCONTEXT;
return flag;
}
static __forceinline bool LOAD_PS(const std::string& DefineString, const char* name, FRAGMENTSHADER& fragment, ZZshProfile context)
{
bool flag = CompileShaderFromFile(fragment.program, DefineString, name, GL_FRAGMENT_SHADER);
fragment.context = context * NOCONTEXT;
return flag;
}
inline bool LoadEffects()
{
// clear the textures
for(u32 i = 0; i < ArraySize(ppsTexture); ++i)
ppsTexture[i].release_prog();
return true;
}
bool ZZshLoadExtraEffects() {
bool bLoadSuccess = true;
std::string depth_macro = BuildGlslMacro(true);
std::string empty_macro = BuildGlslMacro(false);
const char* pvsshaders[4] = { "RegularVS", "TextureVS", "RegularFogVS", "TextureFogVS" };
for (int i = 0; i < 4; ++i) {
if (!LOAD_VS(empty_macro, pvsshaders[i], pvsStore[2 * i], 0)) bLoadSuccess = false;
if (!LOAD_VS(empty_macro, pvsshaders[i], pvsStore[2 *i + 1 ], 1)) bLoadSuccess = false;
if (!LOAD_VS(depth_macro, pvsshaders[i], pvsStore[2 *i + 8 ], 0)) bLoadSuccess = false;
if (!LOAD_VS(depth_macro, pvsshaders[i], pvsStore[2 *i + 8 + 1], 1)) bLoadSuccess = false;
}
for (int i = 0; i < 16; ++i)
pvs[i] = pvsStore[i].prog;
if (!LOAD_VS(empty_macro, "BitBltVS", pvsBitBlt, 0)) bLoadSuccess = false;
GL_REPORT_ERRORD();
if (!LOAD_PS(empty_macro, "RegularPS", ppsRegular[0], 0)) bLoadSuccess = false;
if (!LOAD_PS(empty_macro, "RegularFogPS", ppsRegular[1], 0)) bLoadSuccess = false;
if( conf.mrtdepth ) {
if (!LOAD_PS(depth_macro, "RegularPS", ppsRegular[2], 0)) bLoadSuccess = false;
if (!bLoadSuccess) conf.mrtdepth = 0;
if (!LOAD_PS(depth_macro, "RegularFogPS", ppsRegular[3], 0)) bLoadSuccess = false;
if (!bLoadSuccess) conf.mrtdepth = 0;
}
if (!LOAD_PS(empty_macro, "BitBltPS", ppsBitBlt[0], 0)) bLoadSuccess = false;
if (!LOAD_PS(empty_macro, "BitBltAAPS", ppsBitBlt[1], 0)) bLoadSuccess = false;
if (!bLoadSuccess) {
ZZLog::Error_Log("Failed to load BitBltAAPS, using BitBltPS.");
if (!LOAD_PS(empty_macro, "BitBltPS", ppsBitBlt[1], 0)) bLoadSuccess = false;
}
if (!LOAD_PS(empty_macro, "BitBltDepthPS", ppsBitBltDepth, 0)) bLoadSuccess = false;
if (!LOAD_PS(empty_macro, "CRTCTargPS", ppsCRTCTarg[0], 0)) bLoadSuccess = false;
if (!LOAD_PS(empty_macro, "CRTCTargInterPS", ppsCRTCTarg[1], 0)) bLoadSuccess = false;
g_bCRTCBilinear = true;
if (!LOAD_PS(empty_macro, "CRTCPS", ppsCRTC[0], 0)) bLoadSuccess = false;
if( !bLoadSuccess ) {
// switch to simpler
g_bCRTCBilinear = false;
if (!LOAD_PS(empty_macro, "CRTCPS_Nearest", ppsCRTC[0], 0)) bLoadSuccess = false;
if (!LOAD_PS(empty_macro, "CRTCInterPS_Nearest", ppsCRTC[0], 0)) bLoadSuccess = false;
}
else {
if (!LOAD_PS(empty_macro, "CRTCInterPS", ppsCRTC[1], 0)) bLoadSuccess = false;
}
if( !bLoadSuccess )
ZZLog::Error_Log("Failed to create CRTC shaders.");
// if (!LOAD_PS(empty_macro, "CRTC24PS", ppsCRTC24[0], 0)) bLoadSuccess = false;
// if (!LOAD_PS(empty_macro, "CRTC24InterPS", ppsCRTC24[1], 0)) bLoadSuccess = false;
if (!LOAD_PS(empty_macro, "ZeroPS", ppsOne, 0)) bLoadSuccess = false;
if (!LOAD_PS(empty_macro, "BaseTexturePS", ppsBaseTexture, 0)) bLoadSuccess = false;
if (!LOAD_PS(empty_macro, "Convert16to32PS", ppsConvert16to32, 0)) bLoadSuccess = false;
if (!LOAD_PS(empty_macro, "Convert32to16PS", ppsConvert32to16, 0)) bLoadSuccess = false;
// DEBUG
// if (!LOAD_PS(empty_macro, "ZeroDebugPS", ppsDebug, 0)) bLoadSuccess = false;
// if (!LOAD_PS(empty_macro, "ZeroDebug2PS", ppsDebug2, 0)) bLoadSuccess = false;
GL_REPORT_ERRORD();
return true;
}
FRAGMENTSHADER* ZZshLoadShadeEffect(int type, int texfilter, int fog, int testaem, int exactcolor, const clampInfo& clamp, int context, bool* pbFailed)
{
int texwrap;
assert( texfilter < NUM_FILTERS );
if( clamp.wms == clamp.wmt ) {
switch( clamp.wms ) {
case 0: texwrap = TEXWRAP_REPEAT; break;
case 1: texwrap = TEXWRAP_CLAMP; break;
case 2: texwrap = TEXWRAP_CLAMP; break;
default:
texwrap = TEXWRAP_REGION_REPEAT; break;
}
}
else if( clamp.wms==3||clamp.wmt==3)
texwrap = TEXWRAP_REGION_REPEAT;
else
texwrap = TEXWRAP_REPEAT_CLAMP;
int index = GET_SHADER_INDEX(type, texfilter, texwrap, fog, s_bWriteDepth, testaem, exactcolor, context, 0);
if( pbFailed != NULL ) *pbFailed = false;
FRAGMENTSHADER* pf = ppsTexture+index;
if (ZZshExistProgram(pf))
{
return pf;
}
std::string macro = BuildGlslMacro(s_bWriteDepth, texwrap, testaem, exactcolor);
std::string main_entry = format("Texture%s%d_%sPS", fog?"Fog":"", texfilter, g_pTexTypes[type]);
pf->context = context * NOCONTEXT;
if (!CompileShaderFromFile(pf->program, macro, main_entry, GL_FRAGMENT_SHADER)) {
ZZLog::Error_Log("Failed to create shader %d,%d,%d,%d.", type, fog, texfilter, 4*clamp.wms+clamp.wmt);
if( pbFailed != NULL ) *pbFailed = false;
return NULL;
}
return pf;
}
#endif // GLSL4_API

17
plugins/zzogl-pg/opengl/ZZoglShoots.cpp
View File

@ -101,7 +101,7 @@ bool SaveRenderTarget(const char* filename, int width, int height, int jpeg)
}
// Save selected texture as TGA
bool SaveTexture(const char* filename, u32 textarget, u32 tex, int width, int height)
bool SaveTexture(const char* filename, u32 textarget, u32 tex, int width, int height, int ext_format)
{
vector<u32> data(width*height);
glBindTexture(textarget, tex);
@ -109,7 +109,20 @@ bool SaveTexture(const char* filename, u32 textarget, u32 tex, int width, int he
if (glGetError() != GL_NO_ERROR) return false;
return SaveTGA(filename, width, height, &data[0]);
if (ext_format == EXT_BMP)
return SaveBMP(filename, width, height, &data[0]);
else if (ext_format == EXT_TGA)
return SaveTGA(filename, width, height, &data[0]);
else
return false;
}
// Save image as BMP
bool SaveBMP(const char* filename, int width, int height, void* pdata)
{
// FIXME
assert(0);
return false;
}
// save image as JPEG

9
plugins/zzogl-pg/opengl/ZZoglShoots.h
View File

@ -22,9 +22,10 @@
void SaveSnapshot(const char* filename);
bool SaveRenderTarget(const char* filename, int width, int height, int jpeg);
bool SaveTexture(const char* filename, u32 textarget, u32 tex, int width, int height);
bool SaveTexture(const char* filename, u32 textarget, u32 tex, int width, int height, int ext_format = 0);
bool SaveJPEG(const char* filename, int width, int height, const void* pdata, int quality);
bool SaveTGA(const char* filename, int width, int height, void* pdata);
bool SaveBMP(const char* filename, int width, int height, void* pdata);
void Stop_Avi();
void Delete_Avi_Capture();
@ -32,4 +33,10 @@ void StartCapture();
void StopCapture();
void CaptureFrame();
enum {
EXT_TGA = 0,
EXT_BMP = 1,
EXT_JPG = 2
};
#endif // ZZOGLSHOOTS_H_INCLUDED

18
plugins/zzogl-pg/opengl/ps2hw.glsl
View File

@ -1,4 +1,20 @@
// Cg Shaders for PS2 GS emulation
// ZZ Open GL graphics plugin
// Copyright (c)2009-2010 zeydlitz@gmail.com, arcum42@gmail.com
// Based on Zerofrog's ZeroGS KOSMOS (c)2005-2008
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
// divides by z for every pixel, instead of in vertex shader
// fixes kh textures

939
plugins/zzogl-pg/opengl/ps2hw_gl4.glsl Normal file
View File

@ -0,0 +1,939 @@
//#version 420 Keep it for text editor detection
// ZZ Open GL graphics plugin
// Copyright (c)2009-2010 zeydlitz@gmail.com, arcum42@gmail.com, gregory.hainaut@gmail.com
// Based on Zerofrog's ZeroGS KOSMOS (c)2005-2008
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
// divides by z for every pixel, instead of in vertex shader
// fixes kh textures
#extension ARB_texture_rectangle: require
#extension GL_ARB_shading_language_420pack: require
#extension GL_ARB_separate_shader_objects : require
// Set with version macro
// #define GL_compatibility_profile 1
#define PERSPECTIVE_CORRECT_TEX
// When writting GLSL code we should change variables in code according to denominator
// Not than in and out variables are differ!
// in POSITION set by glVertexPointer goes to gl_Vertex;
// out POSITION goes to gl_position
// in COLOR0 gl_Color
// out COLOR0 gl_FrontColor
// in TEXCOORD0 gl_MultiTexCoord0
// out TEXCOORD0 gl_TexCoord[0]
//in Fragments:
// in TEXCOORD0 gl_TexCoord[0]
// out COLOR0 gl_FragData[0]
//#define TEST_AEM // tests AEM for black pixels
//#define REGION_REPEAT // set if texture wrapping mode is region repeat
//#define WRITE_DEPTH // set if depth is also written in a MRT
//#define ACCURATE_DECOMPRESSION // set for less capable hardware ATI Radeon 9000 series
//#define EXACT_COLOR // make sure the output color is clamped to 1/255 boundaries (for alpha testing)
#ifdef PERSPECTIVE_CORRECT_TEX
#define TEX_XY tex.xy/tex.z
#define TEX_DECL vec4
#else
#define TEX_XY tex.xy
#define TEX_DECL vec4
#endif
// NVidia CG-data types
#define half2 vec2
#define half3 vec3
#define half4 vec4
#define float2 vec2
#define float3 vec3
#define float4 vec4
////////////////////////////////////////////////////////////////////
// INPUT/OUTPUT
////////////////////////////////////////////////////////////////////
// NOTE: Future optimization tex.w is normally useless (in cg it is a float3) so it can contains the fog value
struct vertex
{
vec4 color;
TEX_DECL tex;
vec4 z;
float fog;
};
// VS input (from VBO)
//
// glColorPointer -> gl_Color (color)
// glSecondaryColorPointerEXT -> gl_SecondaryColor (it seems just a way to have another parameter in shader)
// glTexCoordPointer -> gl_MultiTexCoord0 (tex coord)
// glVertexPointer -> gl_Vertex (position)
//
// VS Output (to PS)
// gl_Position (must be kept)
// vertex
//
// FS input (from VS)
// vertex
//
// FS output
// gl_FragData[0]
// gl_FragData[1]
#ifdef VERTEX_SHADER
out gl_PerVertex {
invariant vec4 gl_Position;
float gl_PointSize;
float gl_ClipDistance[];
};
layout(location = 0) in ivec2 Vert;
layout(location = 1) in vec4 Color;
layout(location = 2) in vec4 SecondaryColor;
layout(location = 3) in vec3 TexCoord;
layout(location = 0) out vertex VSout;
/////// return ZZ_SH_CRTC;
// otex0 -> tex
// ointerpos -> z
#endif
#ifdef FRAGMENT_SHADER
layout(location = 0) in vertex PSin;
// FIXME: host only do glDrawBuffers of 1 buffers not 2. I think this is a major bug
layout(location = 0) out vec4 FragData0;
layout(location = 1) out vec4 FragData1;
#endif
////////////////////////////////////////////////////////////////////
// Texture SAMPLER
////////////////////////////////////////////////////////////////////
// // main ps2 memory, each pixel is stored in 32bit color
// uniform sampler2DRect g_sMemory[2];
//
// // used to get the tiled offset into a page given the linear offset
// uniform sampler2DRect g_sSrcFinal;
// uniform sampler2D g_sBlocks;
// uniform sampler2D g_sBilinearBlocks;
// uniform sampler2D g_sConv16to32;
// uniform sampler3D g_sConv32to16;
// uniform sampler2DRect g_sBitwiseANDX;
// uniform sampler2DRect g_sBitwiseANDY;
// uniform sampler2DRect g_sInterlace;
//
// // used only on rare cases where the render target is PSMT8H
// uniform sampler2D g_sCLUT;
// main ps2 memory, each pixel is stored in 32bit color
layout(binding = 10) uniform sampler2DRect g_sMemory; // dual context
// used to get the tiled offset into a page given the linear offset
layout(binding = 1) uniform sampler2DRect g_sSrcFinal;
layout(binding = 2) uniform sampler2D g_sBlocks;
layout(binding = 3) uniform sampler2D g_sBilinearBlocks;
layout(binding = 4) uniform sampler2D g_sConv16to32;
layout(binding = 5) uniform sampler3D g_sConv32to16;
layout(binding = 6) uniform sampler2DRect g_sBitwiseANDX;
layout(binding = 7) uniform sampler2DRect g_sBitwiseANDY;
layout(binding = 8) uniform sampler2DRect g_sInterlace;
// used only on rare cases where the render target is PSMT8H
layout(binding = 9) uniform sampler2D g_sCLUT;
////////////////////////////////////////////////////////////////////
// UNIFORM BUFFER
////////////////////////////////////////////////////////////////////
layout(std140, binding = 0) uniform constant_buffer
{
// Both shader
// .z is used for the addressing fn
// FIXME: not same value between c and shader...
// float4 g_fBilinear = float4(-0.7f, -0.65f, 0.9,1/32767.0f);
float4 g_fBilinear;
float4 g_fZBias;
float4 g_fc0;
float4 g_fMult;
// Vertex
float4 g_fZ; // transforms d3dcolor z into float z
float4 g_fZMin;
float4 g_fZNorm;
// Pixel
half4 g_fExactColor;
};
layout(std140, binding = 1) uniform common_buffer
{
float4 g_fPosXY;
float4 g_fFogColor;
};
layout(std140, binding = 2) uniform vertex_buffer
{
float4 g_fBitBltPos;
float4 g_fBitBltTex;
float4 g_fBitBltTrans;
};
layout(std140, binding = 3) uniform fragment_buffer
{
half4 fTexAlpha2;
float4 g_fTexOffset; // converts the page and block offsets into the mem addr/1024
float4 g_fTexDims; // mult by tex dims when accessing the block texture
float4 g_fTexBlock;
float4 g_fClampExts; // if clamping the texture, use (minu, minv, maxu, maxv)
float4 TexWrapMode; // 0 - repeat/clamp, 1 - region rep (use fRegRepMask)
float4 g_fRealTexDims; // tex dims used for linear filtering (w,h,1/w,1/h)
// (alpha0, alpha1, 1 if highlight2 and tcc is rgba, 1-y)
half4 g_fTestBlack; // used for aem bit
float4 g_fPageOffset;
half4 fTexAlpha;
float4 g_fInvTexDims; // similar to g_fClutOff
// used for rectblitting
float4 g_fBitBltZ;
half4 g_fOneColor; // col*.xxxy+.zzzw
};
// given a local tex coord, returns the coord in the memory
float2 ps2memcoord(float2 realtex)
{
float4 off;
// block off
realtex.xy = realtex.xy * g_fTexDims.xy + g_fTexDims.zw;
realtex.xy = (realtex.xy - fract(realtex.xy)) * g_fMult.zw;
float2 fblock = fract(realtex.xy);
off.xy = realtex.xy-fblock.xy;
#ifdef ACCURATE_DECOMPRESSION
off.zw = texture(g_sBlocks, g_fTexBlock.xy*fblock + g_fTexBlock.zw).ar;
off.x = dot(off.xy, g_fTexOffset.xy);
float r = g_fTexOffset.w;
float f = fract(off.x);
float fadd = g_fTexOffset.z * off.z;
off.w = off.x + fadd + r;
off.x = fract(f + fadd + r);
off.w -= off.x ;
#else
off.z = texture(g_sBlocks, g_fTexBlock.xy*fblock + g_fTexBlock.zw).a;
// combine the two
off.x = dot(off.xyz, g_fTexOffset.xyz)+g_fTexOffset.w;
off.x = modf(off.x, off.w);
#endif
off.xy = off.xw * g_fPageOffset.zy + g_fPageOffset.wx;
//off.y = off.w * g_fPageOffset.y + g_fPageOffset.x;
return off.xy;
}
// find all texcoords for bilinear filtering
// assume that orgtex are already on boundaries
void ps2memcoord4(float4 orgtex, out float4 off0, out float4 off1)
{
//float4 off0, off1, off2, off3;
float4 realtex;
// block off
realtex = (orgtex * g_fTexDims.xyxy + g_fTexDims.zwzw);// * g_fMult.zwzw;
float4 fblock = fract(realtex.xyzw);
float4 ftransblock = g_fTexBlock.xyxy*fblock + g_fTexBlock.zwzw;
realtex -= fblock;
float4 transvals = g_fTexOffset.x * realtex.xzxz + g_fTexOffset.y * realtex.yyww + g_fTexOffset.w;
float4 colors;// = texture(g_sBilinearBlocks, ftransblock.xy);
// this is faster on ffx ingame
colors.x = texture(g_sBlocks, ftransblock.xy).a;
colors.y = texture(g_sBlocks, ftransblock.zy).a;
colors.z = texture(g_sBlocks, ftransblock.xw).a;
colors.w = texture(g_sBlocks, ftransblock.zw).a;
float4 fr, rem;
#ifdef ACCURATE_DECOMPRESSION
fr = fract(transvals);
float4 fadd = colors * g_fTexOffset.z;
rem = transvals + fadd;
fr = fract(fr + fadd);
rem -= fr;
#else
transvals += colors * g_fTexOffset.z;
fr = modf(transvals, rem);
#endif
rem = rem * g_fPageOffset.y + g_fPageOffset.x;
fr = fr * g_fPageOffset.z + g_fPageOffset.w;
// combine
off0 = g_fc0.yxyx * fr.xxyy + g_fc0.xyxy * rem.xxyy;
off1 = g_fc0.yxyx * fr.zzww + g_fc0.xyxy * rem.zzww;
}
void ps2memcoord4_fast(float4 orgtex, out float4 off0, out float4 off1)
{
float4 realtex;
realtex = (orgtex * g_fTexDims.xyxy + g_fTexDims.zwzw);// * g_fMult.zwzw;
float4 fblock = fract(realtex.xyzw);
float2 ftransblock = g_fTexBlock.xy*fblock.xy + g_fTexBlock.zw;
realtex -= fblock;
float4 transvals = g_fTexOffset.x * realtex.xzxz + g_fTexOffset.y * realtex.yyww + g_fTexOffset.w;
float4 colors = texture(g_sBilinearBlocks, ftransblock.xy);
float4 fr, rem;
#ifdef ACCURATE_DECOMPRESSION
fr = fract(transvals);
float4 fadd = colors * g_fTexOffset.z;
rem = transvals + fadd;
fr = fract(fr + fadd);
rem -= fr;
#else
transvals += colors * g_fTexOffset.z;
fr = modf(transvals, rem);
#endif
rem = rem * g_fPageOffset.y + g_fPageOffset.x;
fr = fr * g_fPageOffset.z;
off0 = g_fc0.yxyx * fr.xxyy + g_fc0.xyxy * rem.xxyy;
off1 = g_fc0.yxyx * fr.zzww + g_fc0.xyxy * rem.zzww;
}
// Wrapping modes
#if defined(REPEAT)
float2 ps2addr(float2 coord)
{
return fract(coord.xy);
}
#elif defined(CLAMP)
float2 ps2addr(float2 coord)
{
return clamp(coord.xy, g_fClampExts.xy, g_fClampExts.zw);
}
#elif defined(REGION_REPEAT)
// computes the local tex coord along with addressing modes
float2 ps2addr(float2 coord)
{
float2 final = fract(clamp(coord.xy, g_fClampExts.xy, g_fClampExts.zw));
if( TexWrapMode.x > g_fBilinear.z ) // region repeat mode for x (umsk&x)|ufix
final.x = texture(g_sBitwiseANDX, abs(coord.x)*TexWrapMode.zx).x * g_fClampExts.x + g_fClampExts.z;
if( TexWrapMode.y > g_fBilinear.z ) // region repeat mode for x (vmsk&x)|vfix
final.y = texture(g_sBitwiseANDY, abs(coord.y)*TexWrapMode.wy).x * g_fClampExts.y + g_fClampExts.w;
return final;
}
#else
float2 ps2addr(float2 coord)
{
return fract(clamp(coord.xy, g_fClampExts.xy, g_fClampExts.zw));
}
#endif
half4 tex2DPS_32(float2 tex0)
{
return texture(g_sMemory, ps2memcoord(tex0).xy);
}
// use when texture is not tiled -- shader 1
half4 tex2DPS_tex32(float2 tex0)
{
return texture(g_sMemory, g_fTexDims.xy*tex0+g_fTexDims.zw)*g_fZBias.zzzw+g_fPageOffset.w;
}
// use when texture is not tiled -- shader 2
half4 tex2DPS_clut32(float2 tex0)
{
float index = texture(g_sMemory, g_fTexDims.xy*tex0+g_fTexDims.zw).a+g_fPageOffset.w;
return texture(g_sCLUT, index*g_fExactColor.xz+g_fExactColor.yz);
}
// Shader 3
// use when texture is not tiled and converting from 32bit to 16bit
// don't convert on the block level, only on the column level
// so every other 8 pixels, use the upper bits instead of lower
half4 tex2DPS_tex32to16(float2 tex0)
{
bool upper = false;
tex0.y += g_fPageOffset.z;
float2 ffrac = mod(tex0, g_fTexOffset.xy);
tex0.xy = g_fc0.ww * (tex0.xy + ffrac);
if( ffrac.x > g_fTexOffset.z ) {
tex0.x -= g_fTexOffset.z;
upper = true;
}
if( ffrac.y >= g_fTexOffset.w ) {
tex0.y -= g_fTexOffset.w;
tex0.x += g_fc0.w;
}
half4 color = texture(g_sMemory, g_fTexDims.xy*tex0+g_fTexDims.zw)*g_fZBias.zzzw+g_fPageOffset.w;
float2 uv = upper ? color.xw : color.zy;
return texture(g_sConv16to32, uv+g_fPageOffset.xy);
}
// Shader 4
// used when a 16 bit texture is used an 8h
half4 tex2DPS_tex16to8h(float2 tex0)
{
float4 final;
float2 ffrac = mod(tex0+g_fPageOffset.zw, g_fTexOffset.xy);
tex0.xy = g_fPageOffset.xy * tex0.xy - ffrac * g_fc0.yw;
if( ffrac.x > g_fTexOffset.x*g_fc0.w )
tex0.x += g_fTexOffset.x*g_fc0.w;
if( tex0.x >= g_fc0.y ) tex0 += g_fTexOffset.zw;
float4 upper = texture(g_sMemory, g_fTexDims.xy*tex0+g_fTexDims.zw);
// only need alpha
float index = texture(g_sConv32to16, upper.zyx-g_fc0.z).y + upper.w*g_fc0.w*g_fc0.w;
return texture(g_sCLUT, index+g_fExactColor.yz);
}
// Shader 5
// used when a 16 bit texture is used a 32bit one
half4 tex2DPS_tex16to32(float2 tex0)
{
float4 final;
float2 ffrac = mod(tex0+g_fPageOffset.zw, g_fTexOffset.xy);
//tex0.xy = g_fPageOffset.xy * tex0.xy - ffrac * g_fc0.yw;
tex0.y += g_fPageOffset.y * ffrac.y;
if( ffrac.x > g_fTexOffset.z ) {
tex0.x -= g_fTexOffset.z;
tex0.y += g_fTexOffset.w;
}
float fconst = g_fc0.w*g_fc0.w;
float4 lower = texture(g_sSrcFinal, g_fTexDims.xy*tex0);
float4 upper = texture(g_sMemory, g_fTexDims.xy*tex0+g_fTexDims.zw);
final.zy = texture(g_sConv32to16, lower.zyx).xy + lower.ww*fconst;
final.xw = texture(g_sConv32to16, upper.zyx).xy + upper.ww*fconst;
return final;
}
half4 tex2DPS_tex16to32h(float2 tex0)
{
float4 final = vec4(0.0, 0.0, 0.0, 0.0);
return final;
}
//half4 f;
//f.w = old.y > (127.2f/255.0f) ? 1 : 0;
//old.y -= 0.5f * f.w;
//f.xyz = fract(old.yyx*half3(2.002*255.0f/256.0f, 64.025f*255.0f/256.0f, 8.002*255.0f/256.0f));
//f.y += old.x * (0.25f*255.0f/256.0f);
////////////////////////////////
// calculates the texture color
////////////////////////////////
#define decl_ps2shade(num) \
decl_ps2shade_##num(_32) \
decl_ps2shade_##num(_tex32) \
decl_ps2shade_##num(_clut32) \
decl_ps2shade_##num(_tex32to16) \
decl_ps2shade_##num(_tex16to8h) \
decl_ps2shade_##num(_tex16to32h)
// nearest
#define decl_ps2shade_0(bit) \
float4 ps2shade0##bit( TEX_DECL tex) \
{ \
return tex2DPS##bit( ps2addr(TEX_XY)); \
}
// do fast memcoord4 calcs when textures behave well
#ifdef REPEAT
#define PS2MEMCOORD4 ps2memcoord4
#else
#define PS2MEMCOORD4 ps2memcoord4
#endif
#define decl_BilinearFilter(bit, addrfn) \
half4 BilinearFilter##bit(float2 tex0) \
{ \
float4 off0, off1; \
float4 ftex; \
float2 ffrac; \
ftex.xy = tex0 + g_fBilinear.xy * g_fRealTexDims.zw; \
ffrac = fract(ftex.xy*g_fRealTexDims.xy); \
ftex.xy -= ffrac.xy * g_fRealTexDims.zw; \
\
ftex.zw = ps2addr(ftex.xy + g_fRealTexDims.zw); \
ftex.xy = ps2addr(ftex.xy); \
\
PS2MEMCOORD4(ftex, off0, off1); \
half4 c0 = texture(g_sMemory, off0.xy); \
half4 c1 = texture(g_sMemory, off0.zw); \
half4 c2 = texture(g_sMemory, off1.xy); \
half4 c3 = texture(g_sMemory, off1.zw); \
return mix( mix(c0, c1, vec4(ffrac.x)), mix(c2, c3, ffrac.x), vec4(ffrac.y) ); \
}
decl_BilinearFilter(_32, ps2addr)
decl_BilinearFilter(_tex32, ps2addr)
decl_BilinearFilter(_clut32, ps2addr)
decl_BilinearFilter(_tex32to16, ps2addr)
decl_BilinearFilter(_tex16to8h, ps2addr)
decl_BilinearFilter(_tex16to32h, ps2addr)
//TODO! For mip maps, only apply when LOD >= 0
// lcm == 0, LOD = log(1/Q)*L + K, lcm == 1, LOD = K
// bilinear
#define decl_ps2shade_1(bit) \
half4 ps2shade1##bit(TEX_DECL tex) \
{ \
return BilinearFilter##bit(TEX_XY); \
}
// nearest, mip nearest
#define decl_ps2shade_2(bit) \
half4 ps2shade2##bit(TEX_DECL tex) \
{ \
return tex2DPS##bit( ps2addr(TEX_XY)); \
}
// nearest, mip linear
#define decl_ps2shade_3(bit) \
half4 ps2shade3##bit(TEX_DECL tex) \
{ \
return tex2DPS##bit(ps2addr(TEX_XY)); \
}
// linear, mip nearest
#define decl_ps2shade_4(bit) \
half4 ps2shade4##bit(TEX_DECL tex) \
{ \
return BilinearFilter##bit(TEX_XY); \
}
// linear, mip linear
#define decl_ps2shade_5(bit) \
half4 ps2shade5##bit(TEX_DECL tex) \
{ \
return BilinearFilter##bit(TEX_XY); \
}
decl_ps2shade(0)
decl_ps2shade(1)
decl_ps2shade(2)
decl_ps2shade(3)
decl_ps2shade(4)
decl_ps2shade(5)
half4 ps2CalcShade(half4 texcol, half4 color)
{
#ifdef TEST_AEM
if( dot(texcol.xyzw, g_fTestBlack.xyzw) <= g_fc0.z )
texcol.w = g_fc0.x;
else
#endif
texcol.w = texcol.w * fTexAlpha.y + fTexAlpha.x;
texcol = texcol * (fTexAlpha2.zzzw * color + fTexAlpha2.xxxy) + fTexAlpha.zzzw * color.wwww;
return texcol;
}
// final ops on the color
#ifdef EXACT_COLOR
half4 ps2FinalColor(half4 col)
{
// g_fOneColor has to scale by 255
half4 temp = col * g_fOneColor.xxxy + g_fOneColor.zzzw;
temp.w = floor(temp.w)*g_fExactColor.w;
return temp;
}
#else
half4 ps2FinalColor(half4 col)
{
return col * g_fOneColor.xxxy + g_fOneColor.zzzw;
}
#endif
#ifdef FRAGMENT_SHADER // This is code only for FRAGMENTS (pixel shader)
#ifdef WRITE_DEPTH
void write_depth_target(vec4 z)
{
FragData1 = z;
}
#else
void write_depth_target(vec4 z) { }
#endif
void RegularPS() {
// whenever outputting depth, make sure to mult by 255/256 and 1
FragData0 = ps2FinalColor(PSin.color);
write_depth_target(PSin.z);
}
#define DECL_TEXPS(num, bit) \
void Texture##num##bit##PS() \
{ \
FragData0 = ps2FinalColor(ps2CalcShade(ps2shade##num##bit(PSin.tex), PSin.color)); \
write_depth_target(PSin.z); \
}
#define DECL_TEXPS_(num) \
DECL_TEXPS(num, _32) \
DECL_TEXPS(num, _tex32) \
DECL_TEXPS(num, _clut32) \
DECL_TEXPS(num, _tex32to16) \
DECL_TEXPS(num, _tex16to8h)
DECL_TEXPS_(0)
DECL_TEXPS_(1)
DECL_TEXPS_(2)
DECL_TEXPS_(3)
DECL_TEXPS_(4)
DECL_TEXPS_(5)
void RegularFogPS() {
half4 c;
c.xyz = mix(g_fFogColor.xyz, PSin.color.xyz, vec3(PSin.fog));
c.w = PSin.color.w;
FragData0 = ps2FinalColor(c);
write_depth_target(PSin.z);
}
#define DECL_TEXFOGPS(num, bit) \
void TextureFog##num##bit##PS() \
{ \
half4 c = ps2CalcShade(ps2shade##num##bit(PSin.tex), PSin.color); \
c.xyz = mix(g_fFogColor.xyz, c.xyz, vec3(PSin.fog)); \
FragData0 = ps2FinalColor(c); \
write_depth_target(PSin.z); \
}
#define DECL_TEXFOGPS_(num) \
DECL_TEXFOGPS(num, _32) \
DECL_TEXFOGPS(num, _tex32) \
DECL_TEXFOGPS(num, _clut32) \
DECL_TEXFOGPS(num, _tex32to16) \
DECL_TEXFOGPS(num, _tex16to8h)
DECL_TEXFOGPS_(0)
DECL_TEXFOGPS_(1)
DECL_TEXFOGPS_(2)
DECL_TEXFOGPS_(3)
DECL_TEXFOGPS_(4)
DECL_TEXFOGPS_(5)
//-------------------------------------------------------
// Techniques not related to the main primitive commands
half4 BilinearBitBlt(float2 tex0)
{
float4 ftex;
float2 ffrac;
ffrac.xy = fract(tex0*g_fRealTexDims.xy);
ftex.xy = tex0 - ffrac.xy * g_fRealTexDims.zw;
ftex.zw = ftex.xy + g_fRealTexDims.zw;
float4 off0, off1;
ps2memcoord4_fast(ftex, off0, off1);
half4 c0 = texture(g_sMemory, off0.xy);
half4 c1 = texture(g_sMemory, off0.zw);
half4 c2 = texture(g_sMemory, off1.xy);
half4 c3 = texture(g_sMemory, off1.zw);
return mix( mix(c0, c1, vec4(ffrac.x)), mix(c2, c3, vec4(ffrac.x)), vec4(ffrac.y) );
}
void BitBltPS() {
FragData0 = texture(g_sMemory, ps2memcoord(PSin.tex.xy).xy)*g_fOneColor.xxxy;
}
// used when AA
void BitBltAAPS() {
FragData0 = BilinearBitBlt(PSin.tex.xy) * g_fOneColor.xxxy;
}
void BitBltDepthPS() {
vec4 data;
data = texture(g_sMemory, ps2memcoord(PSin.tex.xy));
FragData0 = data + g_fZBias.y;
gl_FragDepth = (log(g_fc0.y + dot(data, g_fBitBltZ)) * g_fOneColor.w) * g_fZMin.y + dot(data, g_fBitBltZ) * g_fZMin.x ;
}
void BitBltDepthMRTPS() {
vec4 data;
data = texture(g_sMemory, ps2memcoord(PSin.tex.xy));
FragData0 = data + g_fZBias.y;
FragData1.x = g_fc0.x;
gl_FragDepth = (log(g_fc0.y + dot(data, g_fBitBltZ)) * g_fOneColor.w) * g_fZMin.y + dot(data, g_fBitBltZ) * g_fZMin.x ;
}
// static const float BlurKernel[9] = {
// 0.027601,
// 0.066213,
// 0.123701,
// 0.179952,
// 0.205065,
// 0.179952,
// 0.123701,
// 0.066213,
// 0.027601
// };
half4 BilinearFloat16(float2 tex0)
{
return texture(g_sSrcFinal, tex0.xy);
}
void CRTCTargInterPS() {
float finter = texture(g_sInterlace, PSin.z.yy).x * g_fOneColor.z + g_fOneColor.w + g_fc0.w;
float4 c = BilinearFloat16(PSin.tex.xy);
c.w = ( g_fc0.w*c.w * g_fOneColor.x + g_fOneColor.y ) * finter;
FragData0 = c;
}
void CRTCTargPS() {
float4 c = BilinearFloat16(PSin.tex.xy);
// FIXME DEBUG: to validate tex coord on blit
//c = vec4(PSin.tex.x/512.0f, PSin.tex.y/512.0f, 0.0, 1.0);
c.w = g_fc0.w * c.w * g_fOneColor.x + g_fOneColor.y;
FragData0 = c;
}
void CRTCInterPS() {
float finter = texture(g_sInterlace, PSin.z.yy).x * g_fOneColor.z + g_fOneColor.w + g_fc0.w;
float2 filtcoord = trunc(PSin.tex.xy) * g_fInvTexDims.xy + g_fInvTexDims.zw;
half4 c = BilinearBitBlt(filtcoord);
c.w = (c.w * g_fOneColor.x + g_fOneColor.y)*finter;
FragData0 = c;
}
// simpler
void CRTCInterPS_Nearest() {
float finter = texture(g_sInterlace, PSin.z.yy).x * g_fOneColor.z + g_fOneColor.w + g_fc0.w;
half4 c = texture(g_sMemory, ps2memcoord(PSin.tex.xy).xy);
c.w = (c.w * g_fOneColor.x + g_fOneColor.y)*finter;
FragData0 = c;
}
void CRTCPS() {
float2 filtcoord = PSin.tex.xy * g_fInvTexDims.xy+g_fInvTexDims.zw;
half4 c = BilinearBitBlt(filtcoord);
c.w = c.w * g_fOneColor.x + g_fOneColor.y;
FragData0 = c;
}
// simpler
void CRTCPS_Nearest() {
half4 c = texture(g_sMemory, ps2memcoord(PSin.tex.xy).xy);
c.w = c.w * g_fOneColor.x + g_fOneColor.y;
FragData0 = c;
}
void CRTC24InterPS() {
float finter = texture(g_sInterlace, PSin.z.yy).x * g_fOneColor.z + g_fOneColor.w + g_fc0.w;
float2 filtcoord = trunc(PSin.tex.xy) * g_fInvTexDims.xy + g_fInvTexDims.zw;
half4 c = texture(g_sMemory, ps2memcoord(filtcoord).xy);
c.w = (c.w * g_fOneColor.x + g_fOneColor.y)*finter;
FragData0 = c;
}
void CRTC24PS() {
float2 filtcoord = trunc(PSin.tex.xy) * g_fInvTexDims.xy + g_fInvTexDims.zw;
half4 c = texture(g_sMemory, ps2memcoord(filtcoord).xy);
c.w = c.w * g_fOneColor.x + g_fOneColor.y;
FragData0 = c;
}
void ZeroPS() {
FragData0 = g_fOneColor;
}
void ZeroDebugPS() {
FragData0 = vec4(0.0, 1.0, 0.0, 0.5);
//FragData0 = vec4(PSin.position.x, PSin.position.y, 1.0, 0.5);
}
void ZeroDebug2PS() {
FragData0 = vec4(1.0, 0.0, 0.0, 0.5);
}
void BaseTexturePS() {
FragData0 = texture(g_sSrcFinal, PSin.tex.xy) * g_fOneColor;
}
void Convert16to32PS() {
float4 final;
float2 ffrac = mod ( PSin.tex.xy + g_fTexDims.zw, g_fTexOffset.xy);
float2 tex0 = g_fTexDims.xy * PSin.tex.xy - ffrac * g_fc0.yw;
if (ffrac.x > g_fTexOffset.x*g_fc0.w)
tex0.x += g_fTexOffset.x*g_fc0.w;
if (tex0.x >= g_fc0.y)
tex0 += g_fTexOffset.zw;
float4 lower = texture(g_sSrcFinal, tex0);
float4 upper = texture(g_sSrcFinal, tex0 + g_fPageOffset.xy);
final.zy = texture(g_sConv32to16, lower.zyx).xy + lower.ww*g_fPageOffset.zw;
final.xw = texture(g_sConv32to16, upper.zyx).xy + upper.ww*g_fPageOffset.zw;
FragData0= final;
}
// use when texture is not tiled and converting from 32bit to 16bit
// don't convert on the block level, only on the column level
// so every other 8 pixels, use the upper bits instead of lower
void Convert32to16PS() {
bool upper = false;
float2 ffrac = mod(PSin.tex.xy + g_fTexDims.zw, g_fTexOffset.xy);
float2 tex0 = g_fc0.ww * (PSin.tex.xy + ffrac);
if( ffrac.x > g_fTexOffset.z ) {
tex0.x -= g_fTexOffset.z;
upper = true;
}
if( ffrac.y >= g_fTexOffset.w ) {
tex0.y -= g_fTexOffset.w;
tex0.x += g_fc0.w;
}
half4 color = texture(g_sSrcFinal, tex0*g_fTexDims.xy)*g_fc0.yyyw;
float2 uv = upper ? color.xw : color.zy;
FragData0 = texture(g_sConv16to32, uv*g_fPageOffset.xy+g_fPageOffset.zw)*g_fTexDims.xxxy;
}
#endif //FRAGMENT_SHADER
#ifdef VERTEX_SHADER
void SetColor() {
VSout.color = Color;
}
void SetTex() {
#ifdef PERSPECTIVE_CORRECT_TEX
VSout.tex.xyz = TexCoord.xyz;
#else
VSout.tex.xy = TexCoord.xy/TexCoord.z;
#endif
}
void SetZ() {
#ifdef WRITE_DEPTH
VSout.z = SecondaryColor * g_fZBias.x + g_fZBias.y;
VSout.z.w = g_fc0.y;
#endif
}
float SetPosition() {
float4 position;
position.xy = vec2(Vert.xy) * g_fPosXY.xy + g_fPosXY.zw;
// FIXME: the factor in normal mode seem bogus. They don't have same order than in log mode. Or I failed to understand the logic
//// normal mode.
// -> dot(g_fZ, SecondaryColor.zyxw)) => reconstruct a float from normalized char. The float range from 0 to 1
// position.z = dot(g_fZ, SecondaryColor.zyxw);
//// logz mode
// -> dot(g_fZ, SecondaryColor.zyxw)) => reconstruct a float from normalized char. The float range from 0 to 2**32
// position.z = log(g_fc0.y + dot(g_fZ, SecondaryColor.zyxw)) * g_fZNorm.x
// position.z = log(1 + Z_INT) * 0.999f / (32 * log(2.0)) = log2(1 + Z_INT) * 0.999f / 32
// log2(...) will range from 0 to 32
position.z = (log(g_fc0.y + dot(g_fZ, SecondaryColor.zyxw)) * g_fZNorm.x + g_fZNorm.y) * g_fZMin.y + dot(g_fZ, SecondaryColor.zyxw) * g_fZMin.x ;
position.w = g_fc0.y;
gl_Position = position;
// For fog
return position.z;
}
void SetFog(float z) {
VSout.fog = z * g_fBilinear.w;
}
// just smooth shadering
void RegularVS() {
float z = SetPosition();
SetColor();
SetZ();
}
// diffuse texture mapping
void TextureVS() {
float z = SetPosition();
SetColor();
SetTex();
SetZ();
}
void RegularFogVS() {
float z = SetPosition();
SetColor();
SetZ();
SetFog(z);
}
void TextureFogVS() {
float z = SetPosition();
SetColor();
SetTex();
SetZ();
SetFog(z);
}
void BitBltVS() {
vec4 position;
position.xy = vec2(Vert.xy) * g_fBitBltPos.xy + g_fBitBltPos.zw;
position.zw = g_fc0.xy;
gl_Position = position;
VSout.tex.xy = TexCoord.xy * g_fBitBltTex.xy + g_fBitBltTex.zw;
VSout.z.xy = position.xy * g_fBitBltTrans.xy + g_fBitBltTrans.zw;
}
#endif