Scanlines mode

[Godlance]

I posted this previously in the additional resolutions topic, and I’ve realized it will get ignored forever.

So, to quote myself:

Apart from the resolutions affair, would it be possible to put an additional Scanline filter? Something like drawing a full black pixel line on even or odd lines.

If it isn’t too much for the already limited Wii gpu, it could save us lots of money in Scanline Generators. Not having shaders due to memory restrictions is something understandable, but if other emulators manage to do 2xSai filtering, why not implementing a scanline one?

And one last question, where in the code is the Bilinear one? I’d like to experiment a little with it, but I only find empty references to it

If it’s impossible, I’ll have to start looking for an SLG-3000 right now.

Edit: Uae Wii has a functional scanlines mode, I’ll parse the source just to try my luck in the mean time.

[Godlance]

I’m just replying to myself to tell anyone interested in this issue that ToadKing is working on it:

https://github.com/libretro/RetroArch/issues/550

[jmckutchin]

Thanks to everyone involved! Scanlines could potentially be great for the Wii. I’m looking forward to using them at some point in the future.

[SuperrSonic]

This sounds cool but I’d rather they focus on fixing the input related issues that were not present in previous versions.

[hunterk]

This sounds cool but I’d rather they focus on fixing the input related issues that were not present in previous versions.

That’s not really how it works. Nobody has any clue what’s causing the input issues, and AFAIK none of the devs can reproduce it, so no amount of time and effort would fix it at this point.

It might help if someone who can reproduce it could spend some time with git bisect and at least track down which commit caused it.

[jmckutchin]

Haven’t the input issues been in every version of Retroarch? Supersonic, do you have a definitive version in mind where the issue didn’t exist? And I thought squarepusher had experienced it (or are we strictly talking reproducing it reliably? because yeah, it’s completely random)?

At this point we might just have to cut our losses and deal with it. I feel like the devs have spent a good amount of time trying to figure out what’s wrong, and nobody from the Wii scene (or what’s left of it) seems to be offering any help.

Also:

here’s lines 201-222 of gx_input.c:

static int16_t gx_input_state(void *data, const struct retro_keybind **binds,
      unsigned port, unsigned device,
      unsigned index, unsigned id)
{
   gx_input_t *gx = (gx_input_t*)data;

   if (port >= MAX_PADS)
      return 0;

   switch (device)
   {
      case RETRO_DEVICE_JOYPAD:
         if (binds[port][id].joykey >= CONSOLE_MENU_FIRST && binds[port][id].joykey <= CONSOLE_MENU_LAST)
            return gx_menu_input_state(binds[port][id].joykey, gx->pad_state[port]) ? 1 : 0;
         else
            return input_joypad_pressed(&gx_joypad, port, binds[port], id);;
      case RETRO_DEVICE_ANALOG:
         return input_joypad_analog(&gx_joypad, port, index, id, binds[port]);
      default:
         return 0;
   }
}

it looks like input_joypad_pressed and input_joypad_analog wind back to input_common.c:

bool input_joypad_pressed(const rarch_joypad_driver_t *driver,
      unsigned port, const struct retro_keybind *binds, unsigned key)
{
   if (!driver)
      return false;

   int joy_index = g_settings.input.joypad_map[port];
   if (joy_index < 0 || joy_index >= MAX_PLAYERS)
      return false;

   // Auto-binds are per joypad, not per player.
   const struct retro_keybind *auto_binds = g_settings.input.autoconf_binds[joy_index];

   if (!binds[key].valid)
      return false;

   uint64_t joykey = binds[key].joykey;
   if (joykey == NO_BTN)
      joykey = auto_binds[key].joykey;

   if (driver->button(joy_index, (uint16_t)joykey))
      return true;

   uint32_t joyaxis = binds[key].joyaxis;
   if (joyaxis == AXIS_NONE)
      joyaxis = auto_binds[key].joyaxis;

   int16_t axis = driver->axis(joy_index, joyaxis);
   float scaled_axis = (float)abs(axis) / 0x8000;
   return scaled_axis > g_settings.input.axis_threshold;
}

int16_t input_joypad_analog(const rarch_joypad_driver_t *driver,
      unsigned port, unsigned index, unsigned id, const struct retro_keybind *binds)
{
   if (!driver)
      return 0;

   int joy_index = g_settings.input.joypad_map[port];
   if (joy_index < 0 || joy_index >= MAX_PLAYERS)
      return 0;

   // Auto-binds are per joypad, not per player.
   const struct retro_keybind *auto_binds = g_settings.input.autoconf_binds[joy_index];

   unsigned id_minus = 0;
   unsigned id_plus = 0;
   input_conv_analog_id_to_bind_id(index, id, &id_minus, &id_plus);

   const struct retro_keybind *bind_minus = &binds[id_minus];
   const struct retro_keybind *bind_plus = &binds[id_plus];
   if (!bind_minus->valid || !bind_plus->valid)
      return 0;

   uint32_t axis_minus = bind_minus->joyaxis;
   uint32_t axis_plus = bind_plus->joyaxis;
   if (axis_minus == AXIS_NONE)
      axis_minus = auto_binds[id_minus].joyaxis;
   if (axis_plus == AXIS_NONE)
      axis_plus = auto_binds[id_plus].joyaxis;

   int16_t pressed_minus = abs(driver->axis(joy_index, axis_minus));
   int16_t pressed_plus = abs(driver->axis(joy_index, axis_plus));

   int16_t res = pressed_plus - pressed_minus;

   if (res != 0)
      return res;

   uint64_t key_minus = bind_minus->joykey;
   uint64_t key_plus = bind_plus->joykey;
   if (key_minus == NO_BTN)
      key_minus = auto_binds[id_minus].joykey;
   if (key_plus == NO_BTN)
      key_plus = auto_binds[id_plus].joykey;

   int16_t digital_left = driver->button(joy_index, (uint16_t)key_minus) ? -0x7fff : 0;
   int16_t digital_right = driver->button(joy_index, (uint16_t)key_plus) ? 0x7fff : 0;
   return digital_right + digital_left;
}

Is there some sort of clear state callback in the button press event that isn’t firing?

hunterk, did you guys ever see this post?

PS Sorry I’m taking this more off topic. Trying to steer back, how would these scanlines compare to hardware scanline generators? Pretty much the same?

[Vague_Rant]

Sorry to again go off-topic, but I think SuperrSonic is referring to issues like standalone Wiimote control mapping and the Neo Geo Pocket controls being broken since 1.0.0.0. To play Neo Geo Pocket games you have to roll back to the 0.9.9 core, because input is no longer hooked up at all on that platform. However, that’s not relevant to this thread, so I’d suggest starting a separate one to discuss the issue rather than bringing it up in the middle of an unrelated discussion.

[hunterk]

Ah, the NGP thing is news to me, though Squarepusher and ToadKing may be on top of it. I’ll ask them about it later today, if I see them.

The scanlines should be pretty comparable to a scanline generator, yeah. It might require some device/resolution-specific fiddling–I know you guys have some pretty specific requirements for things–but Squarepusher is setting up an overlay repo, so won’t be cluttering up the main codebase with a million device-specific overlays.

[Godlance]

For the life of me, I can’t figure out how to upload this to the overlays repo.

I’ve been testing this files with the latest cores I managed to compile and they work like true scanline generators.

First things first, a nightly build of the cores and the final overlay files:

https://www.dropbox.com/s/2hgwgagy3g56o8v/dols.rar

Then, my scanline overlays:

https://www.dropbox.com/sh/nyo4j159zo7n8ic/AvGfc7x-sr

I’ve included a modified background from one of the GB shaders. If you choose it from the menu and drop opacity a little bit, you will be able to finally play GB games in black and green. The effect is quite awesome.

NOTE: Only the GB, scanlines and scanlinesbold overlays are working properly. The other ones are just trials and tests.

The proper way to use the scanline overlays is to follow this simple steps:

[ol] [li]Copy the overlays to your folder of choice. It doesn’t matter if it’s USB or SD.[/2azbg2c6][/li][li]Choose the scanlines.cfg file from the new overlay preset option in the input settings menu.[/2azbg2c6][/li][li]Drop the opacity to 0.65 and pump the scale to 1.50.[/2azbg2c6][/li][li]Enjoy your new scanlines! You may have to fiddle with your TV brightness settings, as scanlines darken the image a little bit.[/2azbg2c6][/ol][/li] Oh, and the Quake core is broken. Don’t know why.

And there is a new Virtual Boy core! It’s kinda sluggish, but hey, thanks anyway developers!

[hunterk]

@Godlance Ah, thanks for compiling those, and I’m glad to see someone working on the scanlines That’s a clever idea with the GB overlay, too.

You have to have ‘commit’ access to the repo to upload things to it, so the best way to get things up for now is probably to just post them here on the forum (or PM them to me) when they’re finished/ready and I’ll push them to the repo. I’ll get the scanlines, scanlines-bold and gb overlays up there in a wii subdirectory soon.

[system]

@Godlance This sounds cool, can you post some screenshots please?

[Godlance]

@hunterk

Working? Me? You are the ones doing all the coding! This is the least I can do to say THANKS!

I’m testing some grid overlays for the GBA and GB cores. Let’s see what I can do.

@Charco

Unfortunately, Retroarch disables overlays when taking screenshots, so the only way to do it is to take a picture of my TV screen. I’ll take some tomorrow and post them here.

[system]

Ah no problem, thanks.

[Godlance]

Okay, some screenshots:

//I’m having some trouble with the image size and the forum, so for now you’ll have to click the following Imgur link.

Imgur gallery link: http://imgur.com/a/LPEmk

Dropbox folder with all the overlays (for hunterk): https://www.dropbox.com/sh/nyo4j159zo7n8ic/AvGfc7x-sr

[system]

That looks pretty wicked!

[hunterk]

Here are a couple of screenshots from the gbgridgreen and scanlinesgrid overlays, respectively, via PC: http://imgur.com/AnHNwW0 http://imgur.com/CnIlGrv

[askot]

Looks awesome!!

Anyone can point me out how do I set it on Wii?

[system]

Very cool, hopefully these can be included in the next release. Do they work on other cores, like CPS2 and Neo Geo?

[hunterk]

@askot Just use a recent build (like from Godlance’s link a few posts back), go into RGUI and then go to settings > input settings > overlay preset and choose the *.cfg file you want to load (I believe Squarepusher just moved the setting in the very latest git, but Godlance’s build should still use this location, I think). The cfg and its accompanying png image need to be in the same directory on your SD card. For Godlance’s overlays, set the overlay opacity to 0.65 and the scale to 1.5 (this may need adjustment for some games, depending on resolution, but you can tweak it on the fly). For the various borders and other effects, you should be able to leave the scale to 1.0.

@Charco They should work anywhere, since they’re totally independent of the core. It’s literally just an image laid over the screen and then made semi-transparent.