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 du membre
BubbleBobble
Modérateur
Modérateur
Messages : 2641
Enregistré le : 08 sept. 2004 22:24
Localisation : Toulon

Pourquoi jouer sur une vraie console ?

Message par BubbleBobble »

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 du membre
io
Fonctionne à 1200 bauds
Fonctionne à 1200 bauds
Messages : 484
Enregistré le : 14 oct. 2008 21:08
Localisation : En bas de la Meurthe-et-Moselle

Re: Pourquoi jouer sur une vraie console ?

Message par io »

C'est pour ça qu'il faut garder des CRT en stock ;)
Avatar du membre
etms
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 4439
Enregistré le : 17 juil. 2002 21:53
Localisation : New Jersey, USA
Contact :

Re: Pourquoi jouer sur une vraie console ?

Message par etms »

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 ]=]=)<
Rewind the Amiga : http://amigavideo.net
Avatar du membre
BubbleBobble
Modérateur
Modérateur
Messages : 2641
Enregistré le : 08 sept. 2004 22:24
Localisation : Toulon

Re: Pourquoi jouer sur une vraie console ?

Message par BubbleBobble »

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 du membre
io
Fonctionne à 1200 bauds
Fonctionne à 1200 bauds
Messages : 484
Enregistré le : 14 oct. 2008 21:08
Localisation : En bas de la Meurthe-et-Moselle

Re: Pourquoi jouer sur une vraie console ?

Message par io »

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 du membre
BubbleBobble
Modérateur
Modérateur
Messages : 2641
Enregistré le : 08 sept. 2004 22:24
Localisation : Toulon

Re: Pourquoi jouer sur une vraie console ?

Message par BubbleBobble »

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 : 64
Enregistré le : 12 juin 2013 12:03

Re: Pourquoi jouer sur une vraie console ?

Message par flooox »

au passage il existe encore des fabricant de CRT neuve ou ça a disparu ?
Avatar du membre
etms
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 4439
Enregistré le : 17 juil. 2002 21:53
Localisation : New Jersey, USA
Contact :

Re: Pourquoi jouer sur une vraie console ?

Message par etms »

Genial le rendu.
Tu viens de planifier mes prochains WE la :)
Thierry, partisan de la Blatte Attitude ]=]=)<
Rewind the Amiga : http://amigavideo.net
Avatar du membre
BubbleBobble
Modérateur
Modérateur
Messages : 2641
Enregistré le : 08 sept. 2004 22:24
Localisation : Toulon

Re: Pourquoi jouer sur une vraie console ?

Message par BubbleBobble »

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 du membre
etms
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 4439
Enregistré le : 17 juil. 2002 21:53
Localisation : New Jersey, USA
Contact :

Re: Pourquoi jouer sur une vraie console ?

Message par etms »

Ah oui, je veux bien !
Thierry, partisan de la Blatte Attitude ]=]=)<
Rewind the Amiga : http://amigavideo.net
Avatar du membre
gege
Fonctionne à 14400 bauds
Fonctionne à 14400 bauds
Messages : 7141
Enregistré le : 31 janv. 2008 14:24
Localisation : Banlieue Paârisienne
Contact :

Re: Pourquoi jouer sur une vraie console ?

Message par gege »

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 du membre
BubbleBobble
Modérateur
Modérateur
Messages : 2641
Enregistré le : 08 sept. 2004 22:24
Localisation : Toulon

Re: Pourquoi jouer sur une vraie console ?

Message par BubbleBobble »

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 du membre
fabu
Fonctionne à 2400 bauds
Fonctionne à 2400 bauds
Messages : 1346
Enregistré le : 16 oct. 2003 22:54
Localisation : Aveyron

Re: Pourquoi jouer sur une vraie console ?

Message par fabu »

Peux tu m'envoyer tes shaders également.
Je recherche du soft C64,Amstrad,Amiga,Msx
Avatar du membre
BubbleBobble
Modérateur
Modérateur
Messages : 2641
Enregistré le : 08 sept. 2004 22:24
Localisation : Toulon

Re: Pourquoi jouer sur une vraie console ?

Message par BubbleBobble »

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
Enregistré le : 18 juil. 2013 17:30

Re: Pourquoi jouer sur une vraie console ?

Message par mad78 »

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

Retourner vers « Toutes les consoles »