Jump to content
Welcome Guest!

Join us now to get access to all our features. Once registered and logged in, you will be able to create topics, post replies to existing threads, give reputation to your fellow members, get your own private messenger, and so, so much more. It's also quick and totally free, so what are you waiting for?

pucpuc

ePSXe: found a solution to run the games flawless with psx2psp

Recommended Posts

Edit: This solution is no longer needed

I've managed to get the sound running properly on pcsxr - so no need for epsxe now

pcsxr with spuEternal.dll for sound and gpuPeopsOpenGL.dll is giving me the desired result now

--------------------------------------------------------------------------------------------

managed to run ePSXe without daemon tools.

also sound in subchannel data is no problem.

Solution is: psx2psp

just convert the games to psp - dadaaa! no dtools no black screen on Tomb Raider, CD sound.

I'm really happy with this solution because I like the epsxe plugins. Games look so much better with epsxe compared with other emus.

Comparison Wip3out PS1:

epsxe:

epsxersized.png

retroarch

RetroArchrsized.png

Edited by pucpuc

Share this post


Link to post
Share on other sites
Awesome stuff, but I'm confused. So there's a program that changes psx bins/isos into psp format? Espxe can be used to launch psp games?

Are there any other benefits to converting, smaller file sizes, etc?

psx2psp is a program that can convert ps1 isos to PBP.

Its done pretty easy, but requires a few steps:

1.) If you have PS1 isos this step is not needed - if you have bin/cue sets with multiple bin files you have to genereate a single image file (iso, img or bin) - I use Isobuster for this step

2.) load your PS1 file with psx2psp and export to a PBP file.

3.)load your PBP file like any other iso with epsxe - also working in Hyperlaunch

PBP files are compressed - bigger size than 7zip, but compressed

Edited by pucpuc

Share this post


Link to post
Share on other sites
Works, ePSXe and PCSXR loading perfectly PBP image format.

The other emulators do not.

perhaps other emus especially retroarch will add this feature one day - I'd like to have one game folder for all psx emus. I've only converted 6 games so far and set epsxe only to search PBP files in Hyperlaunch. These games are loaded by epsxe via alternate Emulators.

All other Games (1679 Games) I lauch via Retroarch.

I'd need a converter script for the missing 1671 Games.

And would you convert them back to ISO?

not shure what you mean - I kept the original bin/cue files

Share this post


Link to post
Share on other sites

Yuck, texture filtering. Please don't compare that fake looking stuff to crisp, pixelated visuals the way they were meant to appear. No it doesn't look better, it looks inconsistent when you have flat anti-aliased 3D objects combined with jagged 2D elements like fonts and UI bars. Also don't overlook how inaccurate and buggy ePSXe still is. You cannot compare that to accuracy-based emulation which doesn't require plugins, hacks and workarounds to function properly.

It seems you left billinear filtering on your RetroArch example making it appear overly blurry and low resolution, but this is how the game should look when using unfiltered Mednafen (same as used in RA). Sharp, pixelated and accurate.

SIFLhFy.png

Share this post


Link to post
Share on other sites

I can understand that people like it different - I like the sharp graphics in wip3out.

thanks for the billinear filtering hint - gonna try it. Not all games look better with filters.

I've managed to get the sound running properly on pcsxr - so no need for epsxe now

pcsxr with spuEternal.dll for sound and gpuPeopsOpenGL.dll is ginving me th e desired result now

@fame-shadow: popstation does the same as psx2psp

Edited by pucpuc

Share this post


Link to post
Share on other sites

Personally I like epsxe and I like the shaders as well. I want my games to look as good as posible. Some people like having them look like they did on their tvs back in the day (pixelated and with scalines). I see no reason why I should try emulate old hardware and old tvs. To each his own.

You can try using Retroarch. I haven't tried it yet but I've heard that it does an excellent job.

Share this post


Link to post
Share on other sites

I don't really care about real CRT's that much, but I've found I like good CRT shaders because they blend pixels together in a way that helps hide jaggies without removing the detail of the pixelated look. They also give a much more consistent look than "vaseline" filters or even upscaling the internal resolution. The UI looks like it's "part of the game" in this shot compared to how out of place it looks in upscaled ePSXe shots because of jaggy edging:

retroarch-0110-163237ajs7x.png

This is in the Mednafen PSX RetroArch core with the CRT-Royale shader using Mask Type 2, Mask Sample Mode 1, Border 0.0001 and Integer Scaling on.

Using a more accurate emulator that has less bugs to deal with and just works without a billion plugin settings to mess with is a huge advantage too.

Share this post


Link to post
Share on other sites
impressing result. Could you please explain how to apply these settings, or post your cgp file?

icing on the cake would be rounded edges of the screen border.

I alter the user-settings.h file in Royale's folder with the line "#define RUNTIME_SHADER_PARAMS_ENABLE" commented out because you get much better performance that way versus altering the shader's parameters in RA's UI. I'm using the user-settings-royale-with-cheese-nvidia.h file from the crt-royale-settings-files folder as a base, so this won't work on Intel or ATI GPUs, but here's my user-settings.h contents:

#ifndef USER_SETTINGS_H
#define USER_SETTINGS_H

/////////////////////////////  DRIVER CAPABILITIES  ////////////////////////////

//  The Cg compiler uses different "profiles" with different capabilities.
//  This shader requires a Cg compilation profile >= arbfp1, but a few options
//  require higher profiles like fp30 or fp40.  The shader can't detect profile
//  or driver capabilities, so instead you must comment or uncomment the lines
//  below with "//" before "#define."  Disable an option if you get compilation
//  errors resembling those listed.  Generally speaking, all of these options
//  will run on nVidia cards, but only DRIVERS_ALLOW_TEX2DBIAS (if that) is
//  likely to run on ATI/AMD, due to the Cg compiler's profile limitations.

//  Derivatives: Unsupported on fp20, ps_1_1, ps_1_2, ps_1_3, and arbfp1.
//  Among other things, derivatives help us fix anisotropic filtering artifacts
//  with curved manually tiled phosphor mask coords.  Related errors:
//  error C3004: function "float2 ddx(float2);" not supported in this profile
//  error C3004: function "float2 ddy(float2);" not supported in this profile
   #define DRIVERS_ALLOW_DERIVATIVES

//  Fine derivatives: Unsupported on older ATI cards.
//  Fine derivatives enable 2x2 fragment block communication, letting us perform
//  fast single-pass blur operations.  If your card uses coarse derivatives and
//  these are enabled, blurs could look broken.  Derivatives are a prerequisite.
   #ifdef DRIVERS_ALLOW_DERIVATIVES
       #define DRIVERS_ALLOW_FINE_DERIVATIVES
   #endif

//  Dynamic looping: Requires an fp30 or newer profile.
//  This makes phosphor mask resampling faster in some cases.  Related errors:
//  error C5013: profile does not support "for" statements and "for" could not
//  be unrolled
   #define DRIVERS_ALLOW_DYNAMIC_BRANCHES

//  Without DRIVERS_ALLOW_DYNAMIC_BRANCHES, we need to use unrollable loops.
//  Using one static loop avoids overhead if the user is right, but if the user
//  is wrong (loops are allowed), breaking a loop into if-blocked pieces with a
//  binary search can potentially save some iterations.  However, it may fail:
//  error C6001: Temporary register limit of 32 exceeded; 35 registers
//  needed to compile program
   #define ACCOMODATE_POSSIBLE_DYNAMIC_LOOPS

//  tex2Dlod: Requires an fp40 or newer profile.  This can be used to disable
//  anisotropic filtering, thereby fixing related artifacts.  Related errors:
//  error C3004: function "float4 tex2Dlod(sampler2D, float4);" not supported in
//  this profile
   #define DRIVERS_ALLOW_TEX2DLOD

//  tex2Dbias: Requires an fp30 or newer profile.  This can be used to alleviate
//  artifacts from anisotropic filtering and mipmapping.  Related errors:
//  error C3004: function "float4 tex2Dbias(sampler2D, float4);" not supported
//  in this profile
   #define DRIVERS_ALLOW_TEX2DBIAS

//  Integrated graphics compatibility: Integrated graphics like Intel HD 4000
//  impose stricter limitations on register counts and instructions.  Enable
//  INTEGRATED_GRAPHICS_COMPATIBILITY_MODE if you still see error C6001 or:
//  error C6002: Instruction limit of 1024 exceeded: 1523 instructions needed
//  to compile program.
//  Enabling integrated graphics compatibility mode will automatically disable:
//  1.) PHOSPHOR_MASK_MANUALLY_RESIZE: The phosphor mask will be softer.
//      (This may be reenabled in a later release.)
//  2.) RUNTIME_GEOMETRY_MODE
//  3.) The high-quality 4x4 Gaussian resize for the bloom approximation
   //#define INTEGRATED_GRAPHICS_COMPATIBILITY_MODE


////////////////////////////  USER CODEPATH OPTIONS  ///////////////////////////

//  To disable a #define option, turn its line into a comment with "//."

//  RUNTIME VS. COMPILE-TIME OPTIONS (Major Performance Implications):
//  Enable runtime shader parameters in the Retroarch (etc.) GUI?  They override
//  many of the options in this file and allow real-time tuning, but many of
//  them are slower.  Disabling them and using this text file will boost FPS.
//#define RUNTIME_SHADER_PARAMS_ENABLE
//  Specify the phosphor bloom sigma at runtime?  This option is 10% slower, but
//  it's the only way to do a wide-enough full bloom with a runtime dot pitch.
#define RUNTIME_PHOSPHOR_BLOOM_SIGMA
//  Specify antialiasing weight parameters at runtime?  (Costs ~20% with cubics)
#define RUNTIME_ANTIALIAS_WEIGHTS
//  Specify subpixel offsets at runtime? (WARNING: EXTREMELY EXPENSIVE!)
#define RUNTIME_ANTIALIAS_SUBPIXEL_OFFSETS
//  Make beam_horiz_filter and beam_horiz_linear_rgb_weight into runtime shader
//  parameters?  This will require more math or dynamic branching.
#define RUNTIME_SCANLINES_HORIZ_FILTER_COLORSPACE
//  Specify the tilt at runtime?  This makes things about 3% slower.
#define RUNTIME_GEOMETRY_TILT
//  Specify the geometry mode at runtime?
#define RUNTIME_GEOMETRY_MODE
//  Specify the phosphor mask type (aperture grille, slot mask, shadow mask) and
//  mode (Lanczos-resize, hardware resize, or tile 1:1) at runtime, even without
//  dynamic branches?  This is cheap if mask_resize_viewport_scale is small.
#define FORCE_RUNTIME_PHOSPHOR_MASK_MODE_TYPE_SELECT

//  PHOSPHOR MASK:
//  Manually resize the phosphor mask for best results (slower)?  Disabling this
//  removes the option to do so, but it may be faster without dynamic branches.
   #define PHOSPHOR_MASK_MANUALLY_RESIZE
//  If we sinc-resize the mask, should we Lanczos-window it (slower but better)?
   #define PHOSPHOR_MASK_RESIZE_LANCZOS_WINDOW
//  Larger blurs are expensive, but we need them to blur larger triads.  We can
//  detect the right blur if the triad size is static or our profile allows
//  dynamic branches, but otherwise we use the largest blur the user indicates
//  they might need:
   #define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_3_PIXELS
   #define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_6_PIXELS
   #define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_9_PIXELS
   #define PHOSPHOR_BLOOM_TRIADS_LARGER_THAN_12_PIXELS
   //  Here's a helpful chart:
   //  MaxTriadSize    BlurSize    MinTriadCountsByResolution
   //  3.0             9.0         480/640/960/1920 triads at 1080p/1440p/2160p/4320p, 4:3 aspect
   //  6.0             17.0        240/320/480/960 triads at 1080p/1440p/2160p/4320p, 4:3 aspect
   //  9.0             25.0        160/213/320/640 triads at 1080p/1440p/2160p/4320p, 4:3 aspect
   //  12.0            31.0        120/160/240/480 triads at 1080p/1440p/2160p/4320p, 4:3 aspect
   //  18.0            43.0        80/107/160/320 triads at 1080p/1440p/2160p/4320p, 4:3 aspect


///////////////////////////////  USER PARAMETERS  //////////////////////////////

//  Note: Many of these static parameters are overridden by runtime shader
//  parameters when those are enabled.  However, many others are static codepath
//  options that were cleaner or more convert to code as static constants.

//  GAMMA:
   static const float crt_gamma_static = 2.5;                  //  range [1, 5]
   static const float lcd_gamma_static = 2.2;                  //  range [1, 5]

//  LEVELS MANAGEMENT:
   //  Control the final multiplicative image contrast:
   static const float levels_contrast_static = 1.0;            //  range [0, 4)
   //  We auto-dim to avoid clipping between passes and restore brightness
   //  later.  Control the dim factor here: Lower values clip less but crush
   //  blacks more (static only for now).
   static const float levels_autodim_temp = 0.5;               //  range (0, 1]

//  HALATION/DIFFUSION/BLOOM:
   //  Halation weight: How much energy should be lost to electrons bounding
   //  around under the CRT glass and exciting random phosphors?
   static const float halation_weight_static = 0.0;            //  range [0, 1]
   //  Refractive diffusion weight: How much light should spread/diffuse from
   //  refracting through the CRT glass?
   static const float diffusion_weight_static = 0.075;         //  range [0, 1]
   //  Underestimate brightness: Bright areas bloom more, but we can base the
   //  bloom brightpass on a lower brightness to sharpen phosphors, or a higher
   //  brightness to soften them.  Low values clip, but >= 0.8 looks okay.
   static const float bloom_underestimate_levels_static = 0.8; //  range [0, 5]
   //  Blur all colors more than necessary for a softer phosphor bloom?
   static const float bloom_excess_static = 0.0;               //  range [0, 1] //Default 0.0 Custom 0.25
   //  The BLOOM_APPROX pass approximates a phosphor blur early on with a small
   //  blurred resize of the input (convergence offsets are applied as well).
   //  There are three filter options (static option only for now):
   //  0.) Bilinear resize: A fast, close approximation to a 4x4 resize
   //      if min_allowed_viewport_triads and the BLOOM_APPROX resolution are sane
   //      and beam_max_sigma is low.
   //  1.) 3x3 resize blur: Medium speed, soft/smeared from bilinear blurring,
   //      always uses a static sigma regardless of beam_max_sigma or
   //      mask_num_triads_desired.
   //  2.) True 4x4 Gaussian resize: Slowest, technically correct.
   //  These options are more pronounced for the fast, unbloomed shader version.
   static const float bloom_approx_filter_static = 2.0;

//  ELECTRON BEAM SCANLINE DISTRIBUTION:
   //  How many scanlines should contribute light to each pixel?  Using more
   //  scanlines is slower (especially for a generalized Gaussian) but less
   //  distorted with larger beam sigmas (especially for a pure Gaussian).  The
   //  max_beam_sigma at which the closest unused weight is guaranteed <
   //  1.0/255.0 (for a 3x antialiased pure Gaussian) is:
   //      2 scanlines: max_beam_sigma = 0.2089; distortions begin ~0.34; 141.7 FPS pure, 131.9 FPS generalized
   //      3 scanlines, max_beam_sigma = 0.3879; distortions begin ~0.52; 137.5 FPS pure; 123.8 FPS generalized
   //      4 scanlines, max_beam_sigma = 0.5723; distortions begin ~0.70; 134.7 FPS pure; 117.2 FPS generalized
   //      5 scanlines, max_beam_sigma = 0.7591; distortions begin ~0.89; 131.6 FPS pure; 112.1 FPS generalized
   //      6 scanlines, max_beam_sigma = 0.9483; distortions begin ~1.08; 127.9 FPS pure; 105.6 FPS generalized
   static const float beam_num_scanlines = 4.0;                //  range [2, 6]
   //  A generalized Gaussian beam varies shape with color too, now just width.
   //  It's slower but more flexible (static option only for now).
   static const bool beam_generalized_gaussian = true;
   //  What kind of scanline antialiasing do you want?
   //  0: Sample weights at 1x; 1: Sample weights at 3x; 2: Compute an integral
   //  Integrals are slow (especially for generalized Gaussians) and rarely any
   //  better than 3x antialiasing (static option only for now).
   static const float beam_antialias_level = 1.0;              //  range [0, 2]
   //  Min/max standard deviations for scanline beams: Higher values widen and
   //  soften scanlines.  Depending on other options, low min sigmas can alias.
   static const float beam_min_sigma_static = 0.02;            //  range (0, 1]
   static const float beam_max_sigma_static = 0.3;             //  range (0, 1]
   //  Beam width varies as a function of color: A power function (0) is more
   //  configurable, but a spherical function (1) gives the widest beam
   //  variability without aliasing (static option only for now).
   static const float beam_spot_shape_function = 0.0;
   //  Spot shape power: Powers <= 1 give smoother spot shapes but lower
   //  sharpness.  Powers >= 1.0 are awful unless mix/max sigmas are close.
   static const float beam_spot_power_static = 1.0/3.0;    //  range (0, 16]
   //  Generalized Gaussian max shape parameters: Higher values give flatter
   //  scanline plateaus and steeper dropoffs, simultaneously widening and
   //  sharpening scanlines at the cost of aliasing.  2.0 is pure Gaussian, and
   //  values > ~40.0 cause artifacts with integrals.
   static const float beam_min_shape_static = 2.0;         //  range [2, 32]
   static const float beam_max_shape_static = 4.0;         //  range [2, 32]
   //  Generalized Gaussian shape power: Affects how quickly the distribution
   //  changes shape from Gaussian to steep/plateaued as color increases from 0
   //  to 1.0.  Higher powers appear softer for most colors, and lower powers
   //  appear sharper for most colors.
   static const float beam_shape_power_static = 1.0/4.0;   //  range (0, 16]
   //  What filter should be used to sample scanlines horizontally?
   //  0: Quilez (fast), 1: Gaussian (configurable), 2: Lanczos2 (sharp)
   static const float beam_horiz_filter_static = 0.0;
   //  Standard deviation for horizontal Gaussian resampling:
   static const float beam_horiz_sigma_static = 0.35;      //  range (0, 2/3]
   //  Do horizontal scanline sampling in linear RGB (correct light mixing),
   //  gamma-encoded RGB (darker, hard spot shape, may better match bandwidth-
   //  limiting circuitry in some CRT's), or a weighted avg.?
   static const float beam_horiz_linear_rgb_weight_static = 1.0;   //  range [0, 1]
   //  Simulate scanline misconvergence?  This needs 3x horizontal texture
   //  samples and 3x texture samples of BLOOM_APPROX and HALATION_BLUR in
   //  later passes (static option only for now).
   static const bool beam_misconvergence = true;
   //  Convergence offsets in x/y directions for R/G/B scanline beams in units
   //  of scanlines.  Positive offsets go right/down; ranges [-2, 2]
   static const float2 convergence_offsets_r_static = float2(0.1, 0.2);
   static const float2 convergence_offsets_g_static = float2(0.3, 0.4);
   static const float2 convergence_offsets_b_static = float2(0.5, 0.6);
   //  Detect interlacing (static option only for now)?
   static const bool interlace_detect = false;
   //  Assume 1080-line sources are interlaced?
   static const bool interlace_1080i_static = false;
   //  For interlaced sources, assume TFF (top-field first) or BFF order?
   //  (Whether this matters depends on the nature of the interlaced input.)
   static const bool interlace_bff_static = false;

//  ANTIALIASING:
   //  What AA level do you want for curvature/overscan/subpixels?  Options:
   //  0x (none), 1x (sample subpixels), 4x, 5x, 6x, 7x, 8x, 12x, 16x, 20x, 24x
   //  (Static option only for now)
   static const float aa_level = 12.0;                     //  range [0, 24]
   //  What antialiasing filter do you want (static option only)?  Options:
   //  0: Box (separable), 1: Box (cylindrical),
   //  2: Tent (separable), 3: Tent (cylindrical),
   //  4: Gaussian (separable), 5: Gaussian (cylindrical),
   //  6: Cubic* (separable), 7: Cubic* (cylindrical, poor)
   //  8: Lanczos Sinc (separable), 9: Lanczos Jinc (cylindrical, poor)
   //      * = Especially slow with RUNTIME_ANTIALIAS_WEIGHTS
   static const float aa_filter = 6.0;                     //  range [0, 9]
   //  Flip the sample grid on odd/even frames (static option only for now)?
   static const bool aa_temporal = false;
   //  Use RGB subpixel offsets for antialiasing?  The pixel is at green, and
   //  the blue offset is the negative r offset; range [0, 0.5]
   static const float2 aa_subpixel_r_offset_static = float2(-1.0/3.0, 0.0);//float2(0.0);
   //  Cubics: See http://www.imagemagick.org/Usage/filter/#mitchell
   //  1.) "Keys cubics" with B = 1 - 2C are considered the highest quality.
   //  2.) C = 0.5 (default) is Catmull-Rom; higher C's apply sharpening.
   //  3.) C = 1.0/3.0 is the Mitchell-Netravali filter.
   //  4.) C = 0.0 is a soft spline filter.
   static const float aa_cubic_c_static = 0.5;             //  range [0, 4]
   //  Standard deviation for Gaussian antialiasing: Try 0.5/aa_pixel_diameter.
   static const float aa_gauss_sigma_static = 0.5;     //  range [0.0625, 1.0]

//  PHOSPHOR MASK:
   //  Mask type: 0 = aperture grille, 1 = slot mask, 2 = EDP shadow mask
   static const float mask_type_static = 2.0;                  //  range [0, 2] // Default [1.0]
   //  We can sample the mask three ways.  Pick 2/3 from: Pretty/Fast/Flexible.
   //  0.) Sinc-resize to the desired dot pitch manually (pretty/slow/flexible).
   //      This requires PHOSPHOR_MASK_MANUALLY_RESIZE to be #defined.
   //  1.) Hardware-resize to the desired dot pitch (ugly/fast/flexible).  This
   //      is halfway decent with LUT mipmapping but atrocious without it.
   //  2.) Tile it without resizing at a 1:1 texel:pixel ratio for flat coords
   //      (pretty/fast/inflexible).  Each input LUT has a fixed dot pitch.
   //      This mode reuses the same masks, so triads will be enormous unless
   //      you change the mask LUT filenames in your .cgp file.
   static const float mask_sample_mode_static = 1.0;           //  range [0, 2] // Default [0.0]
   //  Prefer setting the triad size (0.0) or number on the screen (1.0)?
   //  If RUNTIME_PHOSPHOR_BLOOM_SIGMA isn't #defined, the specified triad size
   //  will always be used to calculate the full bloom sigma statically.
   static const float mask_specify_num_triads_static = 0.0;    //  range [0, 1]
   //  Specify the phosphor triad size, in pixels.  Each tile (usually with 8
   //  triads) will be rounded to the nearest integer tile size and clamped to
   //  obey minimum size constraints (imposed to reduce downsize taps) and
   //  maximum size constraints (imposed to have a sane MASK_RESIZE FBO size).
   //  To increase the size limit, double the viewport-relative scales for the
   //  two MASK_RESIZE passes in crt-royale.cgp and user-cgp-contants.h.
   //      range [1, mask_texture_small_size/mask_triads_per_tile]
   static const float mask_triad_size_desired_static = 24.0 / 8.0;
   //  If mask_specify_num_triads is 1.0/true, we'll go by this instead (the
   //  final size will be rounded and constrained as above); default 480.0
   static const float mask_num_triads_desired_static = 480.0;
   //  How many lobes should the sinc/Lanczos resizer use?  More lobes require
   //  more samples and avoid moire a bit better, but some is unavoidable
   //  depending on the destination size (static option for now).
   static const float mask_sinc_lobes = 3.0;                   //  range [2, 4]
   //  The mask is resized using a variable number of taps in each dimension,
   //  but some Cg profiles always fetch a constant number of taps no matter
   //  what (no dynamic branching).  We can limit the maximum number of taps if
   //  we statically limit the minimum phosphor triad size.  Larger values are
   //  faster, but the limit IS enforced (static option only, forever);
   //      range [1, mask_texture_small_size/mask_triads_per_tile]
   //  TODO: Make this 1.0 and compensate with smarter sampling!
   static const float mask_min_allowed_triad_size = 2.0;

//  GEOMETRY:
   //  Geometry mode:
   //  0: Off (default), 1: Spherical mapping (like cgwg's),
   //  2: Alt. spherical mapping (more bulbous), 3: Cylindrical/Trinitron
   static const float geom_mode_static = 0.0;      //  range [0, 3]
   //  Radius of curvature: Measured in units of your viewport's diagonal size.
   static const float geom_radius_static = 2.0;    //  range [1/(2*pi), 1024]
   //  View dist is the distance from the player to their physical screen, in
   //  units of the viewport's diagonal size.  It controls the field of view.
   static const float geom_view_dist_static = 2.0; //  range [0.5, 1024]
   //  Tilt angle in radians (clockwise around up and right vectors):
   static const float2 geom_tilt_angle_static = float2(0.0, 0.0);  //  range [-pi, pi]
   //  Aspect ratio: When the true viewport size is unknown, this value is used
   //  to help convert between the phosphor triad size and count, along with
   //  the mask_resize_viewport_scale constant from user-cgp-constants.h.  Set
   //  this equal to Retroarch's display aspect ratio (DAR) for best results;
   //  range [1, geom_max_aspect_ratio from user-cgp-constants.h];
   //  default (256/224)*(54/47) = 1.313069909 (see below)
   static const float geom_aspect_ratio_static = 1.313069909;
   //  Before getting into overscan, here's some general aspect ratio info:
   //  - DAR = display aspect ratio = SAR * PAR; as in your Retroarch setting
   //  - SAR = storage aspect ratio = DAR / PAR; square pixel emulator frame AR
   //  - PAR = pixel aspect ratio   = DAR / SAR; holds regardless of cropping
   //  Geometry processing has to "undo" the screen-space 2D DAR to calculate
   //  3D view vectors, then reapplies the aspect ratio to the simulated CRT in
   //  uv-space.  To ensure the source SAR is intended for a ~4:3 DAR, either:
   //  a.) Enable Retroarch's "Crop Overscan"
   //  b.) Readd horizontal padding: Set overscan to e.g. N*(1.0, 240.0/224.0)
   //  Real consoles use horizontal black padding in the signal, but emulators
   //  often crop this without cropping the vertical padding; a 256x224 [s]NES
   //  frame (8:7 SAR) is intended for a ~4:3 DAR, but a 256x240 frame is not.
   //  The correct [s]NES PAR is 54:47, found by blargg and NewRisingSun:
   //      http://board.zsnes.com/phpBB3/viewtopic.php?f=22&t=11928&start=50
   //      http://forums.nesdev.com/viewtopic.php?p=24815#p24815
   //  For flat output, it's okay to set DAR = [existing] SAR * [correct] PAR
   //  without doing a. or b., but horizontal image borders will be tighter
   //  than vertical ones, messing up curvature and overscan.  Fixing the
   //  padding first corrects this.
   //  Overscan: Amount to "zoom in" before cropping.  You can zoom uniformly
   //  or adjust x/y independently to e.g. readd horizontal padding, as noted
   //  above: Values < 1.0 zoom out; range (0, inf)
   static const float2 geom_overscan_static = float2(1.0, 1.0);// * 1.005 * (1.0, 240/224.0)
   //  Compute a proper pixel-space to texture-space matrix even without ddx()/
   //  ddy()?  This is ~8.5% slower but improves antialiasing/subpixel filtering
   //  with strong curvature (static option only for now).
   static const bool geom_force_correct_tangent_matrix = true;

//  BORDERS:
   //  Rounded border size in texture uv coords:
   static const float border_size_static = 0.0001;           //  range [0, 0.5]
   //  Border darkness: Moderate values darken the border smoothly, and high
   //  values make the image very dark just inside the border:
   static const float border_darkness_static = 2.0;        //  range [0, inf)
   //  Border compression: High numbers compress border transitions, narrowing
   //  the dark border area.
   static const float border_compress_static = 2.5;        //  range [1, inf)


#endif  //  USER_SETTINGS_H

You can change "static const float border_size_static" back to the default 0.015 if you want the border on. I don't like it because it can obscure stuff on the edges and it looks off with games that have black overscan bars. Like on the left side of this shot. If you have Intel or ATI graphics, there are various base settings files from the settings folder you can use and just change these three:

#define RUNTIME_SHADER_PARAMS_ENABLE to

//#define RUNTIME_SHADER_PARAMS_ENABLE

static const float mask_type_static = 1.0; // range [0, 2] to

static const float mask_type_static = 2.0; // range [0, 2]

static const float mask_sample_mode_static = 0.0; // range [0, 2] to

static const float mask_sample_mode_static = 1.0; // range [0, 2]

And leave or change the border setting as you like. Oh, I also have "static const bool interlace_detect" set to false because if it's on it makes MAME vertical games look bad.

Edited by Awakened

Share this post


Link to post
Share on other sites

Wow. Gigapig, that looks great. I'm not a fan of scanlines or curves screens at all but your setup looks really good. I'm considering following your lead. Do you have similar settings for Mame as well?

Edited by Styphelus

Share this post


Link to post
Share on other sites

The PBP format is a compressed Playstation 1 ISO, which saves space and do not need to be uncompressed to be played, I'm replacing RetroArch to virtually every system it emulates, because of its accuracy and it makes life easier for not needing to remap my PS3 controller (recognized as a Xbox 360), which makes life easier, but it still doesn't run PBP.

PCSXR proved to be a better emulator than EPSXE, it runs more fluently and I haven't any compatibility issues till date, also it runs PBP from HLHQ and HS without any loading times, my PS1 collection has 456 PBPs and it only needs 138 GB, if it were in ISO format, it easily should be around 300 GB, because we can choose compression rate and there's lots of titles that end up with half its original size, when I finish the Ps1 collection, about 1100 roms (I deleted lots of sport games and left only the latest releases, I didn't want to have Fifa 96,97,98,99,2000, only the latest ones for each sports games are OK for me) the size will be probably around 300 GB or less.

Its a great deal compressing to PBP for those who needs to save space, 7z can be more usefull for non cd bases systems because of its loading time.

I agree with Danmedregistrations, the games should be displayed like they were mean't to be, what's wrong with pixels?

Share this post


Link to post
Share on other sites

I agree with Danmedregistrations, the games should be displayed like they were mean't to be, what's wrong with pixels?

I agree to a degree, but would you feel the same about Wii emulation? I tried playing Zelda Skyward Sword on the console, but when you run it through Dolphin there is a world of difference; so I now play only through Dolphin unless the emulation of a certain game is bad.

What's good here is we are talking about getting the best visual quality for the games, whether you are a purist or you like filters. It can be fun to play around with filters but also a little frustrating especially in RetroArch as there are so many. That's kind of why I've stuck with Advanced AA and crt-Geom-Curved.

Share this post


Link to post
Share on other sites

Yes, the multi tracks games works OK, there's a correct way to convert them, the only thing that these emulators can't handle like PSP are multi discs like final fantasy 7, PSP can switch discs inside only one pbp, I.e, all 4 CDs compressed into one pbp, for the emulators we use in computers so far I know, each disc should be in a separeted pbp, like Final Fantasy 7 Disc1.pbp, final fantasy 7 disc 2.pbp, etc, funny is that android epsxe can handle multi discs pbp easily.

Share this post


Link to post
Share on other sites
I agree to a degree, but would you feel the same about Wii emulation? I tried playing Zelda Skyward Sword on the console, but when you run it through Dolphin there is a world of difference; so I now play only through Dolphin unless the emulation of a certain game is bad.

What's good here is we are talking about getting the best visual quality for the games, whether you are a purist or you like filters. It can be fun to play around with filters but also a little frustrating especially in RetroArch as there are so many. That's kind of why I've stuck with Advanced AA and crt-Geom-Curved.

Yes, I understand what you mean, there are those who'd like to reproduce the games as they were when we played them on the real console, I was surprised how good are PCSXR filters for PS1 and the graphics looks very clean, but in SSF we have only bilinear and scan-lines, and the latter makes me feel much more like on a real saturn than applying aa filters, for wii and gamecube games, maybe if we use our desktop resolution can be the trick, I'm not messing with GC and Wii now but i do agree with your point, I'm setting up my PC games inside HS.

Share this post


Link to post
Share on other sites

I don't really understand anyone getting elitist about visuals. It's all about what's best for you. I can 100 percent understand someone who wants it to look as authentic as possible, and I can 100 percent understand someone who wants it smooth, rough, under the bridge.... I'm turning myself on, now. And after all, isn't that the point?

Share this post


Link to post
Share on other sites
I don't really understand anyone getting elitist about visuals. It's all about what's best for you. I can 100 percent understand someone who wants it to look as authentic as possible, and I can 100 percent understand someone who wants it smooth, rough, under the bridge.... I'm turning myself on, now. And after all, isn't that the point?

I was almost saying that, in the end, your personal taste is what matter, I understand that too, both sides of this story, maybe we can make these preferences comments in the right thread.

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

×