Pourquoi jouer sur une vraie console ?
Modérateur : Politburo
- BubbleBobble
- Modérateur
- Messages : 2641
- Enregistré le : 08 sept. 2004 22:24
- Localisation : Toulon
Pourquoi jouer sur une vraie console ?
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
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
- io
- 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 ?
C'est pour ça qu'il faut garder des CRT en stock ;)
- etms
- Fonctionne à 9600 bauds
- Messages : 4439
- Enregistré le : 17 juil. 2002 21:53
- Localisation : New Jersey, USA
- Contact :
Re: Pourquoi jouer sur une vraie console ?
Ah ouais, bien les filtres shaders là
C'est sur tous les émulos ça ?
Clair, le rendu sur écran plat de nos vieilles bécanes est à chier.
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
Rewind the Amiga : http://amigavideo.net
- BubbleBobble
- Modérateur
- Messages : 2641
- Enregistré le : 08 sept. 2004 22:24
- Localisation : Toulon
Re: Pourquoi jouer sur une vraie console ?
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
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
- io
- 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 ?
C'est vrai que le rendu est très agréable.
Tu pourrais nous mettre des screen des tiens s'il te plaît ?
Tu pourrais nous mettre des screen des tiens s'il te plaît ?
- BubbleBobble
- Modérateur
- Messages : 2641
- Enregistré le : 08 sept. 2004 22:24
- Localisation : Toulon
Re: Pourquoi jouer sur une vraie console ?
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
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
Re: Pourquoi jouer sur une vraie console ?
au passage il existe encore des fabricant de CRT neuve ou ça a disparu ?
- etms
- Fonctionne à 9600 bauds
- Messages : 4439
- Enregistré le : 17 juil. 2002 21:53
- Localisation : New Jersey, USA
- Contact :
Re: Pourquoi jouer sur une vraie console ?
Genial le rendu.
Tu viens de planifier mes prochains WE la
Tu viens de planifier mes prochains WE la
Thierry, partisan de la Blatte Attitude ]=]=)<
Rewind the Amiga : http://amigavideo.net
Rewind the Amiga : http://amigavideo.net
- BubbleBobble
- Modérateur
- Messages : 2641
- Enregistré le : 08 sept. 2004 22:24
- Localisation : Toulon
Re: Pourquoi jouer sur une vraie console ?
Je peux t'envoyer les fichiers de shaders que j'utilise si tu veux.
Pierre
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
- etms
- Fonctionne à 9600 bauds
- Messages : 4439
- Enregistré le : 17 juil. 2002 21:53
- Localisation : New Jersey, USA
- Contact :
Re: Pourquoi jouer sur une vraie console ?
Ah oui, je veux bien !
Thierry, partisan de la Blatte Attitude ]=]=)<
Rewind the Amiga : http://amigavideo.net
Rewind the Amiga : http://amigavideo.net
- gege
- Fonctionne à 14400 bauds
- Messages : 7148
- Enregistré le : 31 janv. 2008 14:24
- Localisation : Banlieue Paârisienne
- Contact :
Re: Pourquoi jouer sur une vraie console ?
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.
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.
- BubbleBobble
- Modérateur
- Messages : 2641
- Enregistré le : 08 sept. 2004 22:24
- Localisation : Toulon
Re: Pourquoi jouer sur une vraie console ?
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
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
- fabu
- Fonctionne à 2400 bauds
- Messages : 1346
- Enregistré le : 16 oct. 2003 22:54
- Localisation : Aveyron
Re: Pourquoi jouer sur une vraie console ?
Peux tu m'envoyer tes shaders également.
Je recherche du soft C64,Amstrad,Amiga,Msx
- BubbleBobble
- Modérateur
- Messages : 2641
- Enregistré le : 08 sept. 2004 22:24
- Localisation : Toulon
Re: Pourquoi jouer sur une vraie console ?
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
Re: Pourquoi jouer sur une vraie console ?
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 .
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 un défaut non négligeable, mais finalement cela fait aussi parti du coté rétro .
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.
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 .
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 un défaut non négligeable, mais finalement cela fait aussi parti du coté rétro .
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.