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

Avatar de l’utilisateur
Fabrice Montupet
Administrateur
Administrateur
Messages : 10839
Inscription : 17 mai 2002 11:39
Localisation : Nevers - France

Re: Pourquoi jouer sur une vraie console ?

Message par Fabrice Montupet » 27 mars 2016 22:32

Personnellement, je suis très tactile, j'aime bien le contact avec les livres, manuels et revues de ma collection paléo-informatique. Cela dit, quand il s'agit de chercher une information rapidement, d’étudier simultanément des informations présentes sur différents documents, je les délaisse au profit de leur version numérique. J'essaye donc d'avoir une version .pdf de toute ma littérature.

Avatar de l’utilisateur
DataPro
Fonctionne à 300 bauds
Fonctionne à 300 bauds
Messages : 241
Inscription : 28 mars 2013 09:29

Re: Pourquoi jouer sur une vraie console ?

Message par DataPro » 20 avr. 2016 14:08

BubbleBobble a écrit :A multiplier par le nombre de consoles, il faut presque un appartement pour tout ranger de manière accessible (en résumé, si une grosse envie de jouer à Rick Dangerous sur un Amiga 1000 ou à Stormlord sur Megadrive me prend, passer 2 heures à retrouver où c'est, à le sortir et à le brancher, ça casse un peu l'élan).
C'est assez bien résumé et j'ai vécu cette frustration pendant quelques années...
Après, c'est l'un des quelques avantages d'habiter dans un trou de province ravitaillé par les corbeaux... J'ai l'espace nécessaire chez moi et j'ai même choisi ma maison en fonction de cela.
Dernière édition par DataPro le 20 juil. 2016 13:37, édité 2 fois.

Avatar de l’utilisateur
rene
El Presidente
El Presidente
Messages : 1257
Inscription : 16 mai 2002 20:08
Localisation : Toulouse
Contact :

Re: Pourquoi jouer sur une vraie console ?

Message par rene » 20 avr. 2016 15:56

Les vieux engins, c'est super et les émulateurs, c'est génial.
René

Avatar de l’utilisateur
Forthman
Fonctionne à 300 bauds
Fonctionne à 300 bauds
Messages : 172
Inscription : 03 juin 2009 06:51
Localisation : Castelsarrasin (82)

Re: Pourquoi jouer sur une vraie console ?

Message par Forthman » 20 avr. 2016 22:12

Je n'ai jamais eu de console, mais quelques ordis.
Aujourd'hui encore j'ai lancé l'émulateur HECTOR et... c'est quand-même moins fun que le vrai :roll:

J'ai le souvenir de devoir appuyer toooouuuut doucement sur les touches du clavier (qui était très bruyant )
pour ne pas me faire griller par mes parents le soir tard (j'avais 8 ans) et c'était long, mais long... :lol:

Avatar de l’utilisateur
darius
Fonctionne à 1200 bauds
Fonctionne à 1200 bauds
Messages : 367
Inscription : 09 nov. 2005 08:23

Re: Pourquoi jouer sur une vraie console ?

Message par darius » 13 sept. 2016 12:20

je reponds un peu tard a ce sujet qui pourtant me touche et me concerne :D

je collectionne , et je joue , sur des jeux et consoles des années 90 ,
et croyez moi y'a pas photo entre une console de ces années la ,
convenablement branchée en RGB ou S-video sur un trinitron = on allume et ca demarre !

ca n'empeche pas de les hacker pour ne pas participer a la speculation ,
on achete les jeux si on le desire mais c'est pas obligatoire !

les emulateurs c'est autre chose ... pour le peu que j'en connais vaut mieux etre informaticien pour manipuler ca sinon on s'en sort pas !
c'est une vraie galére pour les neewbies :D
mais pour ceux qui savent s'en servir c'est une mine d'or evidemment !
Image
MES VENTES (allez fouiller ;) )
ARRIVAGES RECENTS (abonnez vous a ce topic pour etre prevenus des mises en vente)
RESERVATIONS (postez y ce que vous voulez acheter et vos questions)
EVALUATIONS (parceque vous aimerez savoir a qui vous envoyez vos sous :D )

farvardin
Fonctionne à 1200 bauds
Fonctionne à 1200 bauds
Messages : 426
Inscription : 18 mai 2009 00:06
Contact :

Re: Pourquoi jouer sur une vraie console ?

Message par farvardin » 15 sept. 2016 10:38

Pour les émulateurs, un petit raspberry pi + emulationstation dans retropie ou happi game center, et c'est vraiment à la portée de tout le monde !

Avatar de l’utilisateur
darius
Fonctionne à 1200 bauds
Fonctionne à 1200 bauds
Messages : 367
Inscription : 09 nov. 2005 08:23

Re: Pourquoi jouer sur une vraie console ?

Message par darius » 15 sept. 2016 11:03

le nombre de fois ou j'ai lu ce genre de phrase et ou , me retrouvant devant le bouzin ,
avec mon manque de bases informatique , je ne pouvais rien en faire ... t'imagine pas :D

tu peux pas comparer : une PS1 pucée tu mets ton cd gravé et tu joue ,
c'est quand méme autre chose , sans compter l'ENOOORME difference de prix :D

et n'oublions pas le plaisir d'allumer ces vieilles consoles :)
Image
MES VENTES (allez fouiller ;) )
ARRIVAGES RECENTS (abonnez vous a ce topic pour etre prevenus des mises en vente)
RESERVATIONS (postez y ce que vous voulez acheter et vos questions)
EVALUATIONS (parceque vous aimerez savoir a qui vous envoyez vos sous :D )

Avatar de l’utilisateur
frodon69
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 3776
Inscription : 29 sept. 2003 22:54
Localisation : A l'ouest de Lyon
Contact :

Re: Pourquoi jouer sur une vraie console ?

Message par frodon69 » 16 sept. 2016 06:51

farvardin a écrit :Pour les émulateurs, un petit raspberry pi + emulationstation dans retropie ou happi game center, et c'est vraiment à la portée de tout le monde !
darius a écrit :le nombre de fois ou j'ai lu ce genre de phrase et ou , me retrouvant devant le bouzin ,
avec mon manque de bases informatique , je ne pouvais rien en faire ... t'imagine pas :D
Surtout que les bouzins pour Rpi sont livrés sans rom, faut se débrouiller pour en trouver des compatibles, savoir dans quel répertoire les mettre et comment faire quand on n'y connait rien en linux... mon Rpi prend la poussière et ne me sert finalement à rien.
Frodon69

Je cherche un Amstrad Mega PC, faire offre.

farvardin
Fonctionne à 1200 bauds
Fonctionne à 1200 bauds
Messages : 426
Inscription : 18 mai 2009 00:06
Contact :

Re: Pourquoi jouer sur une vraie console ?

Message par farvardin » 16 sept. 2016 14:38

c'est quand méme autre chose , sans compter l'ENOOORME difference de prix
oui, c'est un peu plus cher de jouer avec des consoles d'époque, mais ça va quand même. Un rpi + carte sd + alim etc on s'en tire dans les 60 €. Une megadrive c'est entre 30 et 50 € + les cartouches à 5/10 € ensuite. Ou alors une cartouche linker mais ça n'est pas donné (dans les 100 € pour un linker nes)
une PS1 pucée tu mets ton cd gravé et tu joue ,
il faut savoir où télécharger les iso, comme les graver, comme modifier la PS1 bref ce n'est pas forcément plus simple. Si c'est quelqu'un d'extérieur qui l'a fait, tu peux en trouver pareil qui te livreront un raspberry pi avec les 800 Rom de la megadrive ou quelques iso PS1 (c'est illégal mais bon pas plus que de graver des cd)
faut se débrouiller pour en trouver des compatibles,
oui, sur 2 plateformes Mame et Neo geo, il faut effectivement trouver la bonne version sinon ça marche moins bien voire pas du tout. Mais pour le reste, NES, snes, ps1, megadrive, master system etc, aucun soucis.
savoir dans quel répertoire les mettre
tu branches le pi en réseau, dans l'explorateur depuis windows tu tapes \\happi\roms (par exemple, ça doit être similaire sur retropie) et tu as la liste des répertoires de rom, genre "megadrive", tu places les roms dedans et redémarre le raspberry pi (pour faire simple)
mon Rpi prend la poussière et ne me sert finalement à rien.
Dommage parce que c'est plutôt cool comme appareil. Avec les scanlines, même sur écran TFT on n'a pas vraiment l'impression d'utiliser un émulateur. Essaye de te trouver quelqu'un de sympa qui pourra te copier les bonnes rom et tu t'amuseras bien avec ;)

Avatar de l’utilisateur
darius
Fonctionne à 1200 bauds
Fonctionne à 1200 bauds
Messages : 367
Inscription : 09 nov. 2005 08:23

Re: Pourquoi jouer sur une vraie console ?

Message par darius » 16 sept. 2016 17:56

incomprehension totale entre les consoleux et les pcistes :lol: comme d'hab !
on parle pas le méme langage , c'est clair !
Image
MES VENTES (allez fouiller ;) )
ARRIVAGES RECENTS (abonnez vous a ce topic pour etre prevenus des mises en vente)
RESERVATIONS (postez y ce que vous voulez acheter et vos questions)
EVALUATIONS (parceque vous aimerez savoir a qui vous envoyez vos sous :D )

Avatar de l’utilisateur
frodon69
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 3776
Inscription : 29 sept. 2003 22:54
Localisation : A l'ouest de Lyon
Contact :

Re: Pourquoi jouer sur une vraie console ?

Message par frodon69 » 17 sept. 2016 04:10

farvardin a écrit :
savoir dans quel répertoire les mettre
tu branches le pi en réseau, dans l'explorateur depuis windows tu tapes \\happi\roms (par exemple, ça doit être similaire sur retropie) et tu as la liste des répertoires de rom, genre "megadrive", tu places les roms dedans et redémarre le raspberry pi (pour faire simple)
mon Rpi prend la poussière et ne me sert finalement à rien.
Dommage parce que c'est plutôt cool comme appareil. Avec les scanlines, même sur écran TFT on n'a pas vraiment l'impression d'utiliser un émulateur. Essaye de te trouver quelqu'un de sympa qui pourra te copier les bonnes rom et tu t'amuseras bien avec ;)
J'essayerai la commande que tu indiques, il faut mettre une ip spéciales pour que l'ordinateur voit le Rpi ?
Sinon il faudrait faire un atelier Rpi pour les nuls aux VM ou à la RGC ;)
Frodon69

Je cherche un Amstrad Mega PC, faire offre.

farvardin
Fonctionne à 1200 bauds
Fonctionne à 1200 bauds
Messages : 426
Inscription : 18 mai 2009 00:06
Contact :

Re: Pourquoi jouer sur une vraie console ?

Message par farvardin » 17 sept. 2016 22:12

il faut mettre une ip spéciales pour que l'ordinateur voit le Rpi ?
non, c'est du dhcp donc ta box va attribuer une ip au rpi, qui sera sur le même réseau local que ton ordinateur.
Voir ici à la section "samba share" : https://github.com/retropie/retropie-se ... rring-Roms (si c'est bien retropie que tu utilises, perso je trouve Happi meilleur, pas au niveau de la doc, mais du rendu).

Et une fois qu'un pack de roms est installé, pas forcément besoin d'y revenir si c'est complet...

Avatar de l’utilisateur
frodon69
Fonctionne à 9600 bauds
Fonctionne à 9600 bauds
Messages : 3776
Inscription : 29 sept. 2003 22:54
Localisation : A l'ouest de Lyon
Contact :

Re: Pourquoi jouer sur une vraie console ?

Message par frodon69 » 11 oct. 2016 22:07

Pas moyen se se connecter au Pi depuis un pc, et je n'ai pas trouvé comment sortir de l'interface jeux de retropie pour accéder au mode console ?
il y a des commandes "sudo" à taper dans ces tutos :
http://www.place4geek.com/blog/2014/10/ ... pberry-pi/
http://goodmorningamers.com/configurati ... tropie/108
Frodon69

Je cherche un Amstrad Mega PC, faire offre.

farvardin
Fonctionne à 1200 bauds
Fonctionne à 1200 bauds
Messages : 426
Inscription : 18 mai 2009 00:06
Contact :

Re: Pourquoi jouer sur une vraie console ?

Message par farvardin » 12 oct. 2016 00:19

Si c'est retropie, il y a un menu qui affiche ton ip locale, c'est genre 192.168.0.12
Ensuite, depuis window \ \192.168.... (sans espace entre les antislash et l'ip complète bien sûr) et tu verras le dossier partagé

Sinon pour passer en console on peut faire alt+shift+f1 ou f2. Et alt+f quelque chose, genre f8 ou f2 (selon les distrib) pour revenir.
En console, un fois loggé, il faut taper ifconfig ou sudo ifconfig pour voir l'IP
Par contre, selon les dis tr ibutions linux / pi, une fois passé en console il n'y a plus forcément de login de libre pour ça.
De mémoire, Tu peux essayer de faire ctrl + c pour interrompre le programme en cours, ça peut couper emulationstation

Avatar de l’utilisateur
darius
Fonctionne à 1200 bauds
Fonctionne à 1200 bauds
Messages : 367
Inscription : 09 nov. 2005 08:23

Re: Pourquoi jouer sur une vraie console ?

Message par darius » 12 oct. 2016 08:17

nan , pis surtout , ce qu'il y a de bien avec les emulateurs c'est que c'est simple 8O :twisted: :lol:




BubbleBobble a écrit :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>
Image
MES VENTES (allez fouiller ;) )
ARRIVAGES RECENTS (abonnez vous a ce topic pour etre prevenus des mises en vente)
RESERVATIONS (postez y ce que vous voulez acheter et vos questions)
EVALUATIONS (parceque vous aimerez savoir a qui vous envoyez vos sous :D )

Répondre

Revenir vers « Toutes les consoles »