Pourquoi jouer sur une vraie console ?

Tout sur les consoles de jeux, liens, infos...Avec un thread par machine. Si la machine n'y est pas , créez le premier post la concernant dans ce forum

Modérateur : Politburo

Répondre
Avatar de l’utilisateur
BubbleBobble
Modérateur
Modérateur
Messages : 2642
Inscription : 08 sept. 2004 22:24
Localisation : Ajaccio

Pourquoi jouer sur une vraie console ?

Message par BubbleBobble » 16 août 2013 21:37

Bonjour,

Oui, petite question qui me vient depuis que j'ai terminé de configurer RetroArch et que je regarde le bon millier de cartouches que j'ai encore sur les étagères.
Pourquoi jouer encore sur une vraie console lorsque l'on n'a plus d'écran à tube cathodique (ou que ça ne va pas tarder) ?

Je m'explique : quand on branche l'une de nos vieilles merveilles sur une télé LCD/LED/plasma, on a plutôt envie de pleurer lorsqu'on voit le résultat : ratios un peu fantaisistes dans certains cas, pixels qui dégoulinent comme jamais, image floue, etc.

Alors qu'avec un émulateur sur PC ou Mac et les derniers shaders émulant les écrans CRT, le rendu est bien meilleur et se rapproche méchamment du rendu original. Même les émulateurs micro s'y mettent, comme SainT : http://leonard.oxg.free.fr/SC1425/SC1425.html

On peut même utiliser les manettes d'origine avec des adaptateurs USB.

Pierre
Le frottage de silex, c'est tout sauf une innovation : avant, on attendait simplement que la foudre tombe sur un arbre et qu'elle enflamme une branche, et ça fonctionnait très bien... ©SbM

Avatar de l’utilisateur
io
Fonctionne à 1200 bauds
Fonctionne à 1200 bauds
Messages : 477
Inscription : 14 oct. 2008 21:08
Localisation : En bas de la Meurthe-et-Moselle

Re: Pourquoi jouer sur une vraie console ?

Message par io » 17 août 2013 01:03

C'est pour ça qu'il faut garder des CRT en stock ;)

Avatar de l’utilisateur
etms
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 4418
Inscription : 17 juil. 2002 21:53
Localisation : New Jersey, USA
Contact :

Re: Pourquoi jouer sur une vraie console ?

Message par etms » 17 août 2013 04:03

Ah ouais, bien les filtres shaders là 8O
C'est sur tous les émulos ça ?
Clair, le rendu sur écran plat de nos vieilles bécanes est à chier.
Thierry, partisan de la Blatte Attitude ]=]=)<
"Avec le numérique, on peut tout perdre aussi vite qu'on l'a copié. C'est ça la vraie Révolution."

Avatar de l’utilisateur
BubbleBobble
Modérateur
Modérateur
Messages : 2642
Inscription : 08 sept. 2004 22:24
Localisation : Ajaccio

Re: Pourquoi jouer sur une vraie console ?

Message par BubbleBobble » 17 août 2013 21:11

Oui, les shaders sont supportés par la plupart des émulos maintenant, dont les principaux qui nous intéressent : Mame, UAE, SainT, Retroarch (NES, SNES, MD, MS, PC Engine, FBA, etc.).
Et le résultat est bluffant. J'en ai bricolé un qui simule les blancs qui pètent et le tube qui a vieilli à partir d'un shader existant pour RetroArch.
Tu peux même définir le moiré de l'écran, sa courbure et des bordures moins nettes, comme un vieux Hantarex dans une Jeutel :)

Pierre
Le frottage de silex, c'est tout sauf une innovation : avant, on attendait simplement que la foudre tombe sur un arbre et qu'elle enflamme une branche, et ça fonctionnait très bien... ©SbM

Avatar de l’utilisateur
io
Fonctionne à 1200 bauds
Fonctionne à 1200 bauds
Messages : 477
Inscription : 14 oct. 2008 21:08
Localisation : En bas de la Meurthe-et-Moselle

Re: Pourquoi jouer sur une vraie console ?

Message par io » 17 août 2013 22:09

C'est vrai que le rendu est très agréable.

Tu pourrais nous mettre des screen des tiens s'il te plaît ?

Avatar de l’utilisateur
BubbleBobble
Modérateur
Modérateur
Messages : 2642
Inscription : 08 sept. 2004 22:24
Localisation : Ajaccio

Re: Pourquoi jouer sur une vraie console ?

Message par BubbleBobble » 18 août 2013 18:11

Voici quelques exemples du shader que j'utilise avec RetroArch pour quelques émulateurs :
Pensez à les visualiser en pleine résolution !

http://imageshack.us/g/1/10282036/

Pierre
Le frottage de silex, c'est tout sauf une innovation : avant, on attendait simplement que la foudre tombe sur un arbre et qu'elle enflamme une branche, et ça fonctionnait très bien... ©SbM

flooox
Fonctionne à 75 bauds
Fonctionne à 75 bauds
Messages : 57
Inscription : 12 juin 2013 12:03

Re: Pourquoi jouer sur une vraie console ?

Message par flooox » 19 août 2013 08:55

au passage il existe encore des fabricant de CRT neuve ou ça a disparu ?

Avatar de l’utilisateur
etms
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 4418
Inscription : 17 juil. 2002 21:53
Localisation : New Jersey, USA
Contact :

Re: Pourquoi jouer sur une vraie console ?

Message par etms » 19 août 2013 16:07

Genial le rendu.
Tu viens de planifier mes prochains WE la :)
Thierry, partisan de la Blatte Attitude ]=]=)<
"Avec le numérique, on peut tout perdre aussi vite qu'on l'a copié. C'est ça la vraie Révolution."

Avatar de l’utilisateur
BubbleBobble
Modérateur
Modérateur
Messages : 2642
Inscription : 08 sept. 2004 22:24
Localisation : Ajaccio

Re: Pourquoi jouer sur une vraie console ?

Message par BubbleBobble » 19 août 2013 18:06

Je peux t'envoyer les fichiers de shaders que j'utilise si tu veux.

Pierre
Le frottage de silex, c'est tout sauf une innovation : avant, on attendait simplement que la foudre tombe sur un arbre et qu'elle enflamme une branche, et ça fonctionnait très bien... ©SbM

Avatar de l’utilisateur
etms
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 4418
Inscription : 17 juil. 2002 21:53
Localisation : New Jersey, USA
Contact :

Re: Pourquoi jouer sur une vraie console ?

Message par etms » 19 août 2013 20:42

Ah oui, je veux bien !
Thierry, partisan de la Blatte Attitude ]=]=)<
"Avec le numérique, on peut tout perdre aussi vite qu'on l'a copié. C'est ça la vraie Révolution."

Avatar de l’utilisateur
gege
Fonctionne à 14400 bauds
Fonctionne à 14400 bauds
Messages : 6331
Inscription : 31 janv. 2008 15:24
Localisation : Banlieue Paârisienne
Contact :

Re: Pourquoi jouer sur une vraie console ?

Message par gege » 20 août 2013 00:31

Bonjour,
Ca n'existe pas une interface qui prend la sortie ordi "vers CRT" et sort un signal vidéo adapté aux écrans LCD ?
Hop une idée qui peut faire un millionnaire de l'un d'entre vous (je prends 10%) !
G.E.

Avatar de l’utilisateur
BubbleBobble
Modérateur
Modérateur
Messages : 2642
Inscription : 08 sept. 2004 22:24
Localisation : Ajaccio

Re: Pourquoi jouer sur une vraie console ?

Message par BubbleBobble » 20 août 2013 08:01

Si, ça existe, mais le résultat n'est pas toujours à la hauteur.
Ce sont des boîtiers qui génèrent des scanlines, comme celui-ci par exemple : http://arcadeforge.net/Scaler-and-Strik ... b747c950d5
Certains font aussi de l'upscale avec plus ou moins de bonheur.

Pierre
Le frottage de silex, c'est tout sauf une innovation : avant, on attendait simplement que la foudre tombe sur un arbre et qu'elle enflamme une branche, et ça fonctionnait très bien... ©SbM

Avatar de l’utilisateur
fabu
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1329
Inscription : 16 oct. 2003 22:54
Localisation : Aveyron

Re: Pourquoi jouer sur une vraie console ?

Message par fabu » 20 août 2013 09:11

Peux tu m'envoyer tes shaders également.
Je recherche du soft C64,Amstrad,Amiga,Msx

Avatar de l’utilisateur
BubbleBobble
Modérateur
Modérateur
Messages : 2642
Inscription : 08 sept. 2004 22:24
Localisation : Ajaccio

Re: Pourquoi jouer sur une vraie console ?

Message par BubbleBobble » 20 août 2013 18:45

Voici celui que j'utilise. C'est une version modifiée (comprendre : qui propose un rendu encore plus vintage/tordu/pourri/qui pique) d'un shader dispo sur le GitHub de Libreto.

Code : Tout sélectionner

<?xml version="1.0" encoding="UTF-8"?>
<!--

	Shader d'écran arcade qui a des heures de vols.
	Version modifiée de :

    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.
	
    -->
<shader language="GLSL">
<fragment filter="nearest" scale="1.0"><![CDATA[
uniform sampler2D     rubyTexture;
uniform vec2 rubyTextureSize;
uniform vec2 rubyInputSize;
uniform vec2 rubyOutputSize;

#define CRTgamma 6.5
#define display_gamma 2.2
#define TEX2D(c) pow(texture2D(rubyTexture,(c)),vec4(CRTgamma))

void main()
{
  vec2 xy = gl_TexCoord[0].st;
  float oney = 1.0/rubyTextureSize.y;

  float wid = 2.0;

  float c1 = exp(-1.0/wid/wid);
  float c2 = exp(-4.0/wid/wid);
  float c3 = exp(-9.0/wid/wid);
  float c4 = exp(-16.0/wid/wid);
  float norm = 1.0 / (1.0 + 2.0*(c1+c2+c3+c4));

  vec4 sum = vec4(0.0);

  sum += TEX2D(xy + vec2(0.0, -4.0 * oney)) * vec4(c4);
  sum += TEX2D(xy + vec2(0.0, -3.0 * oney)) * vec4(c3);
  sum += TEX2D(xy + vec2(0.0, -2.0 * oney)) * vec4(c2);
  sum += TEX2D(xy + vec2(0.0, -1.0 * oney)) * vec4(c1);
  sum += TEX2D(xy);
  sum += TEX2D(xy + vec2(0.0, +1.0 * oney)) * vec4(c1);
  sum += TEX2D(xy + vec2(0.0, +2.0 * oney)) * vec4(c2);
  sum += TEX2D(xy + vec2(0.0, +3.0 * oney)) * vec4(c3);
  sum += TEX2D(xy + vec2(0.0, +4.0 * oney)) * vec4(c4);

  gl_FragColor = pow(sum*vec4(norm),vec4(1.0/display_gamma));
}
]]></fragment>
<fragment filter="nearest" scale="1.0"><![CDATA[
uniform sampler2D     rubyTexture;
uniform vec2 rubyTextureSize;
uniform vec2 rubyInputSize;
uniform vec2 rubyOutputSize;

#define display_gamma 1.6
#define TEX2D(c) pow(texture2D(rubyTexture,(c)),vec4(display_gamma))

void main()
{
  vec2 xy = gl_TexCoord[0].st;
  float onex = 1.0/rubyTextureSize.x;

  float wid = 2.0;

  float c1 = exp(-1.0/wid/wid);
  float c2 = exp(-4.0/wid/wid);
  float c3 = exp(-9.0/wid/wid);
  float c4 = exp(-16.0/wid/wid);
  float norm = 1.0 / (1.0 + 2.0*(c1+c2+c3+c4));

  vec4 sum = vec4(0.0);

  sum += TEX2D(xy + vec2(-4.0 * onex, 0.0)) * vec4(c4);
  sum += TEX2D(xy + vec2(-3.0 * onex, 0.0)) * vec4(c3);
  sum += TEX2D(xy + vec2(-2.0 * onex, 0.0)) * vec4(c2);
  sum += TEX2D(xy + vec2(-1.0 * onex, 0.0)) * vec4(c1);
  sum += TEX2D(xy);
  sum += TEX2D(xy + vec2(+1.0 * onex, 0.0)) * vec4(c1);
  sum += TEX2D(xy + vec2(+2.0 * onex, 0.0)) * vec4(c2);
  sum += TEX2D(xy + vec2(+3.0 * onex, 0.0)) * vec4(c3);
  sum += TEX2D(xy + vec2(+4.0 * onex, 0.0)) * vec4(c4);

  gl_FragColor = pow(sum*vec4(norm),vec4(1.0/display_gamma));
}
]]></fragment>
<vertex><![CDATA[
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 vec2 rubyOrigInputSize;
uniform vec2 rubyOrigTextureSize;
uniform vec2 rubyOutputSize;
uniform vec2 rubyInputSize;

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

#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.0;
  // gamma of display monitor (typically 2.2 is correct)
  monitorgamma = 2.0;
  // overscan (e.g. 1.02 for 2% overscan)
  overscan = vec2(1.00,1.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 = 3.5;
  // radius of curvature
  R = 2.2;
  // tilt angle in radians
  // (behavior might be a bit wrong if both components are nonzero)
  const vec2 angle = vec2(0.0,-0.0);
  // size of curved corners
  cornersize = 0.015;
  // border smoothness parameter
  // decrease if borders are too aliased
  cornersmooth = 100.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;
  
  ilfac = vec2(1.0,floor(rubyInputSize.y/200.0));

  // The size of one texel, in texture-coordinates.
  one = ilfac / rubyOrigTextureSize;

  // Resulting X pixel-coordinate of the pixel we're drawing.
  mod_factor = texCoord.x * rubyOrigTextureSize.x * rubyOutputSize.x / rubyOrigInputSize.x;			
}
]]></vertex>
<fragment filter="linear" outscale="1.0"><![CDATA[
uniform int rubyFrameCount;

// 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(rubyOrigTexture, (c)), vec4(CRTgamma))
#else
#       define TEX2D(c) texture2D(rubyOrigTexture, (c))
#endif

uniform sampler2D rubyOrigTexture;
uniform vec2 rubyOrigInputSize;
uniform vec2 rubyOrigTextureSize;

uniform sampler2D rubyTexture;
uniform vec2 rubyInputSize;
uniform vec2 rubyTextureSize;

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

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 *= rubyOrigTextureSize / rubyOrigInputSize;
  coord = vec2(1.0,1.0)*(coord-vec2(0.5))*aspect*stretch.z+stretch.xy;
  return (bkwtrans(coord)/overscan/aspect+vec2(0.5)) * rubyOrigInputSize / rubyOrigTextureSize;
}

float corner(vec2 coord)
{
  coord *= rubyOrigTextureSize / rubyOrigInputSize;
  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
}

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);

  vec2 xy2 = ((xy*rubyOrigTextureSize/rubyOrigInputSize-vec2(0.5))*vec2(1.0,1.0)+vec2(0.5))*rubyInputSize/rubyTextureSize;
  // Of all the pixels that are mapped onto the texel we are
  // currently rendering, which pixel are we currently rendering?
  vec2 ilvec = vec2(0.0,ilfac.y > 1.5 ? mod(float(rubyFrameCount),2.0) : 0.0);
  vec2 ratio_scale = (xy * rubyTextureSize - vec2(0.5) + ilvec)/ilfac;
//  vec2 ratio_scale = xy * rubyOrigTextureSize - 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)*ilfac + vec2(0.5) - ilvec) / rubyTextureSize;
//  xy = (floor(ratio_scale) + vec2(0.5)) / rubyOrigTextureSize;

  // 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;
  mul_res += pow(texture2D(rubyTexture, xy2).rgb, vec3(monitorgamma))*0.1;
  mul_res *= 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));

  // Color the texel.
  gl_FragColor = vec4(mul_res, 1.0);
}
]]></fragment>
</shader>
Le frottage de silex, c'est tout sauf une innovation : avant, on attendait simplement que la foudre tombe sur un arbre et qu'elle enflamme une branche, et ça fonctionnait très bien... ©SbM

mad78
Fonctionne à 75 bauds
Fonctionne à 75 bauds
Messages : 12
Inscription : 18 juil. 2013 17:30

Re: Pourquoi jouer sur une vraie console ?

Message par mad78 » 22 août 2013 11:39

Salut ,
Je vais aller à contre courant du fil de la discussion.
Pourquoi jouer avec les vraies consoles ?
Pour moi, jouer sur émulateur c'est comme avoir un toile de grand maître sur un poster sérigraphie en se disant que c’est pareil finalement.
Je reconnais qu’il y a une spéculation abusive sur le prix des articles rétro, mais quand on sais chercher on trouve toujours de bonnes affaires (tiens chiner c’est aussi une des choses sympathique avec les vrais consoles).
Le plaisir de jouer avec du vrai, le touché, le visuel, le son, l’odeur même, aucun émulateur ne le donnera .
Cela permet aussi de conserver un patrimoine vidéo culturel qui entre de bonnes mains comme les nôtres :) ,les passionnés, permet à toutes ses machines et jeux de survires au poids des années et aussi d’éviter la poubelle :cry: .

Idem pour les écrans cathodique, je ne suis pas d'accord , ça se trouve facilement et pour pas chère voir gratuitement (les gens ne savent plus quoi en faire) il en reste suffisamment sur le marche pour tenir encore plusieurs années, aussi contrairement aux TV actuelle beaucoup peuvent se réparer assez facilement,bon c' est vrai c'est lourd et encombrant :lol: un défaut non négligeable, mais finalement cela fait aussi parti du coté rétro :D .
Pour en finir , je ne critique pas les utilisateurs d’émulateur , mais pour moi , il y a deux écoles et l 'une ne peut pas se substituer à l 'autre.

Répondre

Revenir vers « Toutes les consoles »