Next Generation Emulation banner

1 - 8 of 8 Posts

·
Registered
Joined
·
65 Posts
Discussion Starter #1
Hey! I watch movies using PotPlayer and have good shaders. I wanna friend them with something like 'natural' shader, but I dont know how. These shaders should be applied for resulting image. So, its like universal shader when you can set levels, noise level + shader for improving graphics like naturl

Levels problem - LCD display has too dark black 0-0-0 and too bright white 255-255-255. CRT has another colors. Also, analog creates some noise and CRT # gives texture to objects. It helps.
Compairing



Levels shader

Black

Code:
// Levels=ps_2_0
// Code from MPC fixed by Danila Zabiaka

sampler s0 : register(s0);
#define black 10.0



float4 main(float2 tex : TEXCOORD0) : COLOR

{

    // original pixel

    float4 c0 = tex2D(s0,tex);



    return c0 + black/255.0 - c0*black/255.0  ;

}
White

Code:
sampler s0 : register(s0);

#define white 236.0

float4 main(float2 tex : TEXCOORD0) : COLOR {
    // original pixel
    float4 c0 = tex2D(s0, tex);

    return c0 * white/255.0;
}
Noise

Code:
sampler s0 : register(s0);
float4 p0 :  register(c0);
float4 p1 :  register(c1);

#define amplificationFactor 5
#define offset -15.0
#define dx (p1[0])
#define dy (p1[1])
#define counter (p0[2])
#define clock (p0[3])



float randCust(in float2 uv) {
    float noiseX = (frac(sin(dot(uv, float2(12.9898,78.233)      )) * 43758.5453));
    float noiseY = (frac(sin(dot(uv, float2(12.9898,78.233) * 2.0)) * 43758.5453));
    return noiseX * noiseY;
}

float4 main(float2 tex : TEXCOORD0) : COLOR {
    float4 orig;
    orig = tex2D(s0, tex);
    float noise = randCust(tex*(counter/500)) + offset/100;

    return orig+ (noise*amplificationFactor/100);
}
For people who watch movies there is debanding shader, may be useful

Code:
//From Dreamject . History: MaverickTse(AviUtl)->SAPikachu(Avisynth)->haasn(GLSL)->JPulowski(Reshade HLSL)->mbah.primbon(HLSL)
/* --- Settings --- */

#define Threshold            70.0                     //[0.0:4096.0] //-The debanding filter's cut-off threshold. Higher numbers increase the debanding strength dramatically but progressively diminish image details. (Default 64)
#define Range                16.0                     //[1.0:64.0] //-The debanding filter's initial radius. The radius increases linearly for each iteration. A higher radius will find more gradients, but a lower radius will smooth more aggressively. (Default 16)
#define Iterations            1                        //[1:16] //-The number of debanding steps to perform per sample. Each step reduces a bit more banding, but takes time to compute. Note that the strength of each step falls off very quickly, so high numbers (>4) are practically useless. (Default 1)
#define Grain                0.0                     //[0.0:4096.0] //-Add some extra noise to the image. This significantly helps cover up remaining quantization artifacts. Higher numbers add more noise. (Default 48)

/* ---  Defining Constants --- */
#define myTex2D(s,p) tex2D(s,p)

#ifndef s0
  sampler s0 : register(s0);
  #define s1 s0
//sampler s1 : register(s1);

  float4 p0 : register(c0);
  float4 p1 : register(c1);

//  #define width (p0[0])
//  #define height (p0[1])
//  #define counter (p0[2])
  #define clock (p0[3])
//  #define px (p1[0]) //one_over_width
//  #define py (p1[1]) //one_over_height

  #define px (p1.x) //one_over_width
  #define py (p1.y) //one_over_height

  #define screen_size float2(p0.x,p0.y)

  #define pixel float2(px,py)

//#define pxy float2(p1.xy)

//#define PI acos(-1)
#endif


/* ---  Main code --- */

   /*-----------------------------------------------------------.  
  /                     Deband Filter                           /
  '-----------------------------------------------------------*/

float permute(float x) { return ((34.0 * x + 1.0) * x) % 289.0; }
float rand(float x)    { return frac(x * 0.024390243); }


float3 average(sampler2D tex, float2 pos, float range, inout float h)
{
    // Compute a random rangle and distance
    float dist = rand(h) * range;     h = permute(h);
    float dir  = rand(h) * 6.2831853; h = permute(h);

    float2 pt = dist * pixel;
    float2 o = float2(cos(dir), sin(dir));

    // Sample at quarter-turn intervals around the source pixel
    float3 ref[4];
    ref[0] = tex2D(tex, pos + pt * float2( o.x,  o.y)).rgb;
    ref[1] = tex2D(tex, pos + pt * float2(-o.y,  o.x)).rgb;
    ref[2] = tex2D(tex, pos + pt * float2(-o.x, -o.y)).rgb;
    ref[3] = tex2D(tex, pos + pt * float2( o.y, -o.x)).rgb;

    // Return the (normalized) average
    return (ref[0] + ref[1] + ref[2] + ref[3]) * 0.25;
}


/* --- Main --- */

float4 main(float2 texcoord : TEXCOORD0) : COLOR
{  
    float h;
    // Initialize the PRNG by hashing the position + a random uniform
    float3 m = float3(texcoord, clock * 0.0002) + 1.0;
    h = permute(permute(permute(m.x) + m.y) + m.z);

    // Sample the source pixel
    float3 col = tex2D(s0, texcoord).rgb;
    float3 avg; float3 diff;
   
    #if (Iterations == 1)
        [unroll]
    #endif
    for (int i = 1; i <= Iterations; i++) {
        // Sample the average pixel and use it instead of the original if the difference is below the given threshold
        avg = average(s0, texcoord, i * Range, h);
        diff = abs(col - avg);
        col = lerp(avg, col, diff > Threshold * 0.00006103515625 * i);
    }

    if (Grain > 0.0) {
        // Add some random noise to smooth out residual differences
        float3 noise;
        noise.x = rand(h); h = permute(h);
        noise.y = rand(h); h = permute(h);
        noise.z = rand(h); h = permute(h);
        col += (Grain * 0.000122070313) * (noise - 0.5);
    }

    return float4(col, 1.0);
}
 

·
Registered
Joined
·
30 Posts
Isn't the "best" (hard to define I would say :D) just xBR? After I found out about xBR, I think via a shader in Snes9x, it literally knocked me off my chair. ^^ It gets rid of any noticeable pixel and generally enhance/upgrade the graphics, without blurring, sharpening at all. I admit, this fully lies in the eye of the beholder, because it adds some kind of "oil" style or something, if you want. Some just use scanlines and are more than happy with them, no offence. Right now, I play Breath of Fire III via RetroArch (sorry ePSXe :/ ) and BeetlePSX. I don't want to advertise anything, but RetroArch, at least for PSX, has so many damn great options, I can't imagine anything more I would need.

For BoF3, I use Vulkan, 8x Internal GPU Resolution, xBR Texture Filtering, Adaptive Smoothing, 16x MSAA, MDEC Chroma Filter, Dynarec+DMA only etc. It also has full PGXP support, but I don't use it for BoF3, because some lines appear on the sprites and polygon walls flicker. It looks perfect without PGXP, but works great with Vagrant Story as an example. And that's not all, it offers stuff like built-in widescreen hacks, downsampling, overclocking, skip BIOS, CD loading speed (anything above x2 crashes BoF3) and precaching etc., PAL timing override (I play PAL BoF3 in German with 60 FPS), autodetection of xInput gamepads, like my Logitech F510 (can also manage dInput). Even the "Logitech" button in the middle of my pad opens the RetroArch menu and I didn't had to configure that myself (was surprised, normally this button is completely useless and my wife pressed it accidentally). RetroArch also has great Memory Card and Savestate options.

On top of that (and many more settings I forgot or haven't used myself yet), I can easily move the emulated game to my TV (whole RetroArch, also audio is easily routed separately), can play on my couch with my gamepad AND the PC is still fully useable with mouse and keyboard! I could play on TV and my wife on PC, with splitted audio and games, on one PC without any further software and problems (as I have tested so far). Normally, I use "Audio Router" to, as an example, route the audio of some Youtube stream to my TV, because the window of those streams runs there too.

You can also bind any button (mouse, keyboard, gamepad, whatever) to any function, like fast-forward on L2 (you can't play without it after using it some time...) or savestate managing or whatever you want. Currently, I play BoF3 without any issue, no graphic or sound problems, no crashes, all simply perfect in much better than on real hardware. I mean, I knew about RetroArch for years, but never really tried and used it (I think it wasn't that nice all the time). Just some weeks ago, I read some relatively short comment somewhere about it (in use for PSX) and finally gave it a try and I have tried many emulators for many systems. The most advanced I knew with many options, and used since many years are PCSX2/Dolphin, ePSXe, Snes9x. I never liked ZSnes as an example. Anyway, the thing is, RetroArch just blew me away... how comfortable you navigate through the (multilingual) menus and how many possibilities you have. And I would call myself a ePSXe "fanboy" if you want (never liked PCSXR or Xebra), which is switching to RetroArch right now. It might become my next Frontend too, after partly using QuickPlay for years on windows.
 

·
Registered
Joined
·
65 Posts
Discussion Starter #3 (Edited)
I did it, but I have some problem that my noise is freezed. Can you say me how apply noise for each frame?



gpuPeteOGL2.slf
Code:
//patched by Danila Zabiaka - white black noise
#define white 236.0
#define black 20.0
#define noise 10.0
#define offset -15.0

/*
    CRT shader

    Copyright (C) 2010-2012 cgwg, Themaister and DOLLS

    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.

    (cgwg gave their consent to have the original version of this shader
    distributed under the GPL in this message:

        http://board.byuu.org/viewtopic.php?p=26075#p26075

        "Feel free to distribute my shaders under the GPL. After all, the
        barrel distortion code was taken from the Curvature shader, which is
        under the GPL."
    )
*/

        // Comment the next line to disable interpolation in linear gamma (and
        // gain speed).
        #define LINEAR_PROCESSING

        // Enable screen curvature.
        //#define CURVATURE

        // Enable 3x oversampling of the beam profile
        #define OVERSAMPLE

        // Use the older, purely gaussian beam profile
        //#define USEGAUSSIAN

        // Macros.
        #define FIX(c) max(abs(c), 1e-5);
        #define PI 3.141592653589

        #ifdef LINEAR_PROCESSING
        #       define TEX2D(c) pow(texture2D(OGL2Texture, (c)), vec4(CRTgamma))
        #else
        #       define TEX2D(c) texture2D(OGL2Texture, (c))
        #endif

        uniform sampler2D OGL2Texture;
        uniform vec4 OGL2Param, OGL2Size;

        vec2 rubyTextureSize = OGL2Size.xy;
        vec2 rubyInputSize = vec2(640.0f, 240.0f);

        varying vec2 texCoord;
        varying vec2 one;
        varying float mod_factor;

        varying float CRTgamma;
        varying float monitorgamma;

        varying vec2 overscan;
        varying vec2 aspect;

        varying float d;
        varying float R;

        varying float cornersize;
        varying float cornersmooth;

        varying vec3 stretch;
        varying vec2 sinangle;
        varying vec2 cosangle;

        float intersect(vec2 xy)
        {
                float A = dot(xy,xy)+d*d;
                float B = 2.0*(R*(dot(xy,sinangle)-d*cosangle.x*cosangle.y)-d*d);
                float C = d*d + 2.0*R*d*cosangle.x*cosangle.y;
                return (-B-sqrt(B*B-4.0*A*C))/(2.0*A);
        }

        vec2 bkwtrans(vec2 xy)
        {
                float c = intersect(xy);
                vec2 point = vec2(c)*xy;
                point -= vec2(-R)*sinangle;
                point /= vec2(R);
                vec2 tang = sinangle/cosangle;
                vec2 poc = point/cosangle;
                float A = dot(tang,tang)+1.0;
                float B = -2.0*dot(poc,tang);
                float C = dot(poc,poc)-1.0;
                float a = (-B+sqrt(B*B-4.0*A*C))/(2.0*A);
                vec2 uv = (point-a*sinangle)/cosangle;
                float r = FIX(R*acos(a));
                return uv*r/sin(r/R);
        }

        vec2 transform(vec2 coord)
        {
                coord *= rubyTextureSize / rubyInputSize;
                coord = (coord-vec2(0.5))*aspect*stretch.z+stretch.xy;
                return (bkwtrans(coord)/overscan/aspect+vec2(0.5)) * rubyInputSize / rubyTextureSize;
        }

        float corner(vec2 coord)
        {
                coord *= rubyTextureSize / rubyInputSize;
                coord = (coord - vec2(0.5)) * overscan + vec2(0.5);
                coord = min(coord, vec2(1.0)-coord) * aspect;
                vec2 cdist = vec2(cornersize);
                coord = (cdist - min(coord,cdist));
                float dist = sqrt(dot(coord,coord));
                return clamp((cdist.x-dist)*cornersmooth,0.0, 1.0);
        }

        // Calculate the influence of a scanline on the current pixel.
        //
        // 'distance' is the distance in texture coordinates from the current
        // pixel to the scanline in question.
        // 'color' is the colour of the scanline at the horizontal location of
        // the current pixel.
        vec4 scanlineWeights(float distance, vec4 color)
        {
                // "wid" controls the width of the scanline beam, for each RGB
                // channel The "weights" lines basically specify the formula
                // that gives you the profile of the beam, i.e. the intensity as
                // a function of distance from the vertical center of the
                // scanline. In this case, it is gaussian if width=2, and
                // becomes nongaussian for larger widths. Ideally this should
                // be normalized so that the integral across the beam is
                // independent of its width. That is, for a narrower beam
                // "weights" should have a higher peak at the center of the
                // scanline than for a wider beam.
        #ifdef USEGAUSSIAN
                vec4 wid = 0.3 + 0.1 * pow(color, vec4(3.0));
                vec4 weights = vec4(distance / wid);
                return 0.4 * exp(-weights * weights) / wid;
        #else
                vec4 wid = 2.0 + 2.0 * pow(color, vec4(4.0));
                vec4 weights = vec4(distance / 0.3);
                return 1.4 * exp(-pow(weights * inversesqrt(0.5 * wid), wid)) / (0.6 + 0.2 * wid);
        #endif
        }
float pseudoNoise(vec2 co)
{
return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453)*fract(sin(dot(co.xy ,vec2(12.9898,78.233)*2.0)) * 43758.5453); //pseudo random number generator
}
        void main()
        {
                // Here's a helpful diagram to keep in mind while trying to
                // understand the code:
                //
                //  |      |      |      |      |
                // -------------------------------
                //  |      |      |      |      |
                //  |  01  |  11  |  21  |  31  | <-- current scanline
                //  |      | @    |      |      |
                // -------------------------------
                //  |      |      |      |      |
                //  |  02  |  12  |  22  |  32  | <-- next scanline
                //  |      |      |      |      |
                // -------------------------------
                //  |      |      |      |      |
                //
                // Each character-cell represents a pixel on the output
                // surface, "@" represents the current pixel (always somewhere
                // in the bottom half of the current scan-line, or the top-half
                // of the next scanline). The grid of lines represents the
                // edges of the texels of the underlying texture.

                // Texture coordinates of the texel containing the active pixel.
        #ifdef CURVATURE
                vec2 xy = transform(texCoord);
        #else
                vec2 xy = texCoord;
        #endif
                float cval = corner(xy);

                // Of all the pixels that are mapped onto the texel we are
                // currently rendering, which pixel are we currently rendering?
                vec2 ratio_scale = xy * rubyTextureSize - vec2(0.5);
        #ifdef OVERSAMPLE
                float filter = fwidth(ratio_scale.y);
        #endif
                vec2 uv_ratio = fract(ratio_scale);

                // Snap to the center of the underlying texel.
                xy = (floor(ratio_scale) + vec2(0.5)) / rubyTextureSize;

                // Calculate Lanczos scaling coefficients describing the effect
                // of various neighbour texels in a scanline on the current
                // pixel.
                vec4 coeffs = PI * vec4(1.0 + uv_ratio.x, uv_ratio.x, 1.0 - uv_ratio.x, 2.0 - uv_ratio.x);

                // Prevent division by zero.
                coeffs = FIX(coeffs);

                // Lanczos2 kernel.
                coeffs = 2.0 * sin(coeffs) * sin(coeffs / 2.0) / (coeffs * coeffs);

                // Normalize.
                coeffs /= dot(coeffs, vec4(1.0));

                // Calculate the effective colour of the current and next
                // scanlines at the horizontal location of the current pixel,
                // using the Lanczos coefficients above.
                vec4 col  = clamp(mat4(
                        TEX2D(xy + vec2(-one.x, 0.0)),
                        TEX2D(xy),
                        TEX2D(xy + vec2(one.x, 0.0)),
                        TEX2D(xy + vec2(2.0 * one.x, 0.0))) * coeffs,
                        0.0, 1.0);
                vec4 col2 = clamp(mat4(
                        TEX2D(xy + vec2(-one.x, one.y)),
                        TEX2D(xy + vec2(0.0, one.y)),
                        TEX2D(xy + one),
                        TEX2D(xy + vec2(2.0 * one.x, one.y))) * coeffs,
                        0.0, 1.0);

        #ifndef LINEAR_PROCESSING
                col  = pow(col , vec4(CRTgamma));
                col2 = pow(col2, vec4(CRTgamma));
        #endif

                // Calculate the influence of the current and next scanlines on
                // the current pixel.
                vec4 weights  = scanlineWeights(uv_ratio.y, col);
                vec4 weights2 = scanlineWeights(1.0 - uv_ratio.y, col2);
        #ifdef OVERSAMPLE
                uv_ratio.y =uv_ratio.y+1.0/3.0*filter;
                weights = (weights+scanlineWeights(uv_ratio.y, col))/3.0;
                weights2=(weights2+scanlineWeights(abs(1.0-uv_ratio.y), col2))/3.0;
                uv_ratio.y =uv_ratio.y-2.0/3.0*filter;
                weights=weights+scanlineWeights(abs(uv_ratio.y), col)/3.0;
                weights2=weights2+scanlineWeights(abs(1.0-uv_ratio.y), col2)/3.0;
        #endif
                vec3 mul_res  = (col * weights + col2 * weights2).rgb * vec3(cval);

                // dot-mask emulation:
                // Output pixels are alternately tinted green and magenta.
                vec3 dotMaskWeights = mix(
                        vec3(1.0, 0.7, 1.0),
                        vec3(0.7, 1.0, 0.7),
                        floor(mod(mod_factor, 2.0))
                    );
               

               
               
                mul_res *= dotMaskWeights;

                // Convert the image gamma for display on our output device.
                mul_res = pow(mul_res, vec3(1.0 / monitorgamma))*white/255.0+black/255.0-mul_res*black/255.0+(pseudoNoise(texCoord)+offset/100.0)*noise/100.0;

                // Color the texel.
                gl_FragColor = vec4(mul_res, 1.0);
        }
gpuPeteOGL2.slv

Code:
            varying float CRTgamma;
        varying float monitorgamma;
        varying vec2 overscan;
        varying vec2 aspect;
        varying float d;
        varying float R;
        varying float cornersize;
        varying float cornersmooth;

        varying vec3 stretch;
        varying vec2 sinangle;
        varying vec2 cosangle;

        uniform vec4 OGL2Param, OGL2Size;

        vec2 rubyTextureSize = OGL2Size.xy;
        vec2 rubyInputSize = vec2(640.0f, 240.0f);
        vec2 rubyOutputSize = vec2(1280.0f, 960.0f);

        varying vec2 texCoord;
        varying vec2 one;
        varying float mod_factor;

        #define FIX(c) max(abs(c), 1e-5);

        float intersect(vec2 xy)
        {
                float A = dot(xy,xy)+d*d;
                float B = 2.0*(R*(dot(xy,sinangle)-d*cosangle.x*cosangle.y)-d*d);
                float C = d*d + 2.0*R*d*cosangle.x*cosangle.y;
                return (-B-sqrt(B*B-4.0*A*C))/(2.0*A);
        }

        vec2 bkwtrans(vec2 xy)
        {
                float c = intersect(xy);
                vec2 point = vec2(c)*xy;
                point -= vec2(-R)*sinangle;
                point /= vec2(R);
                vec2 tang = sinangle/cosangle;
                vec2 poc = point/cosangle;
                float A = dot(tang,tang)+1.0;
                float B = -2.0*dot(poc,tang);
                float C = dot(poc,poc)-1.0;
                float a = (-B+sqrt(B*B-4.0*A*C))/(2.0*A);
                vec2 uv = (point-a*sinangle)/cosangle;
                float r = R*acos(a);
                return uv*r/sin(r/R);
        }

        vec2 fwtrans(vec2 uv)
        {
                float r = FIX(sqrt(dot(uv,uv)));
                uv *= sin(r/R)/r;
                float x = 1.0-cos(r/R);
                float D = d/R + x*cosangle.x*cosangle.y+dot(uv,sinangle);
                return d*(uv*cosangle-x*sinangle)/D;
        }

        vec3 maxscale()
        {
                vec2 c = bkwtrans(-R * sinangle / (1.0 + R/d*cosangle.x*cosangle.y));
                vec2 a = vec2(0.5,0.5)*aspect;
                vec2 lo = vec2(fwtrans(vec2(-a.x,c.y)).x,
                             fwtrans(vec2(c.x,-a.y)).y)/aspect;
                vec2 hi = vec2(fwtrans(vec2(+a.x,c.y)).x,
                             fwtrans(vec2(c.x,+a.y)).y)/aspect;
                return vec3((hi+lo)*aspect*0.5,max(hi.x-lo.x,hi.y-lo.y));
        }


        void main()
        {
                // START of parameters

                // gamma of simulated CRT
                CRTgamma = 2.4;
                // gamma of display monitor (typically 2.2 is correct)
                monitorgamma = 2.2;
                // overscan (e.g. 1.02 for 2% overscan)
                overscan = vec2(0.00,0.00);
                // aspect ratio
                aspect = vec2(1.0, 0.75);
                // lengths are measured in units of (approximately) the width
                // of the monitor simulated distance from viewer to monitor
                d = 2.0;
                // radius of curvature
                R = 1.5;
                // tilt angle in radians
                // (behavior might be a bit wrong if both components are
                // nonzero)
                const vec2 angle = vec2(0.0,-0.15);
                // size of curved corners
                cornersize = 0.001;
                // border smoothness parameter
                // decrease if borders are too aliased
                cornersmooth = 1000.0;

                // END of parameters

                // Do the standard vertex processing.
                gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;

                // Precalculate a bunch of useful values we'll need in the fragment
                // shader.
                sinangle = sin(angle);
                cosangle = cos(angle);
                stretch = maxscale();

                // Texture coords.
                texCoord = gl_MultiTexCoord0.xy;

                // The size of one texel, in texture-coordinates.
                one = 1.0 / rubyTextureSize;

                // Resulting X pixel-coordinate of the pixel we're drawing.
                mod_factor = texCoord.x * rubyTextureSize.x * rubyOutputSize.x / rubyInputSize.x;
        }
 

·
Registered
Joined
·
65 Posts
Discussion Starter #4
I have old laptop 4gb ram, intel 1.7Ghz + intel HD and dont have money to buy new, but actually I dont wanna change my old laptop. I fucked with retroarch, as for me its horrible software without intuitive user interface

Actually, its really to build laptop on arm64 chips, they dont eat much energy, but it destroys inter/amd...
 

·
Registered
Joined
·
65 Posts
Discussion Starter #5
Vulkan, 8x Internal GPU Resolution, xBR Texture Filtering, Adaptive Smoothing, 16x MSAA, MDEC Chroma Filter, Dynarec+DMA

I think you dont understand some basics how it works. PS1 has its own native resolution and everything opimized for it

It was designed for TV CRT matrix. Picture should be natural, it actually was cause of analog noise + tv matrix. Its very bad to scale this
 

·
Registered
Joined
·
30 Posts
I really would want to help you with your shader, but I have no real clue about programming shaders. :p Raising the internal resolution is good for all 3D graphics, and adding MSAA improves this even more. xBR enhanced all sprites (2D) graphics and textures (on 3D) itself. About the RetroArch menu, I couldn't think about any better one, if you want all those options and a menu which is controllable through a gamepad (or other input devices). I can't access any real options in ePSXe via gamepad, only some keyboard only shortcuts (on a couch with a gamepad...). I also can't access any ePSXe options while in-game, I need to close the whole emulator and do it before starting a game. So setting up anything would need to stand up from the couch, going to my PC and do all this. But it could be, that ePSXe has better performance in general on your laptop, I understand that. I doubt that you can use the same configuration on RetroArch, like I use on my desktop PC (i7 6800K, 32GB Ram, GTX 1080).

I mean I used ePSXe always and just recently begun to use RetroArch and it was overwhelming how much more it offers. I haven't tried custom shaders in RetroArch for now (just the build-in, like xBR), but maybe later with Super xBR or anything. It also has some CRT options, but i haven't used any from them too. So, I fully understand how a PSX works, but I want more than native, I want to optimize and enhance the graphics as much as possible. I had the real PSX experience as a kid foor many years and don't need it 1:1 the same again. Why not improve stuff with a higher internal resolution, widescreen, anti-jitter hacks and filters to de-pixelate sprites? You do the same (altering filters to archive some optic you desire), just with some other way. You're trying to archive a natural CRT PSX experience, which is completely okay with me, more possibilities, the better. I only listed some of all the options and possibilities RetroArch has, some of them can also be found with ePSXe, but compared with RA, for me, it's simply outdated/obsolete. The Beetle HW PSX core offers all options I have ever dreamed of, much more than any PSX emulator I tried before, simply matchless. But I don't know about the performance of RetroArch on other systems. Maybe ePSXe runs better on low end hardware?
 

·
Registered
Joined
·
65 Posts
Discussion Starter #7
retroarch is awful, man. its so blotwared and slow as it possible, just capitalism and tons of coders
I fixed glsl shader, but I didnt have some nerves for this

I tried PPSSPP, and its GREAT program. Very comfortable, from PC

Retroarch? wtf....
 

·
Registered
Joined
·
65 Posts
Discussion Starter #8
I hardly installed NES and it was very laggy. No normal PC interface, its 10000x time more complex than nestopia
I tried to find windows build ready-to-work out of box, but I didnt. No on torrent or whatever. I think only geeks like retroarch

~____~
 
1 - 8 of 8 Posts
Top