For a game I am making, which uses interrupt-based 4-level greyscale, I am trying to superimpose a static effect onto the screen, using xor. However, Im at an impasse as to how to do this. I could use a pre-set xor value and apply the same effect to every byte on the front buffers, or use a few full-screen bitmaps and xor them to the front buffers. However, I wanted to avoid option 2 because I was aiming for a relatively small program, and I already have 2 full-screen images, greyscale. Not to mention a few sprites left to add.

The details on the static is this: it only occurs under two very specific circumstances, and the static is white. I can't give any more details without giving away the project (and I kind of want it to be a surprise). If you already know, sssh.

Anyone any ideas?

If you're running the game at 15MHz, you can insert a LFSR right into the 4 level grayscale routine.

8-bit LFSR:


16-bit LFSR:


Both are fairly fast and you can do whatever you want with the data it generates. Also, you can change the masks to something else to achieve "different" effects.


Code:


I hope this helps!

EDIT: Remembered that I had another variation of a LFSR that I did for an older project, which uses a different (and probably much more optimum) method of generating "random" values.


Code:

Code modified from original to get it to look similar to the 16-bit test

Code originally found in the audio driver routine, used to generate this:

These are PERFECT!!

Numbering the images from top to bottom, I could probably use #2 or 3 for the game ending static, but for the in-game static it might need to be a bit... err..fainter.

The screenshots in the first post use monochrome images. If you want something a bit fainter, you can try to clear out the dark gray buffer and apply the LFSR to the light gray buffer.


EDIT:

Play around with the masks and see what you can come up with. Tho the results aren't static-y, they do make interesting effects.

Neglected to mention that while the first two screenshots were generated with a Galois LFSR, the latter two were generated with a Fibonacci LFSR. The masks in the latter routines are changed with the number of shifts you do, rather than an actual mask.

ah ok. I might use the 16-bit Galois FFSR bc the effect is closer to what I want to do. And for the lighter effect, do as you say.

Now, is there a way to basically set in the program whether to apply static, apply dark static, or apply light static, so that when the interrupt fires, it will do only what it is supposed to?

Edit: If the result of a conditional reveals that light static should be displayed, the define staticFunc is set to 1. If dark static, then its set to 2. If no static, then 0. Then the interrupt reads out the value of staticFunc

If the grayscale routine separates the current input bytes from the buffers into two different registers (like how E:SoR does), then doing this should be pretty trivial, with the only real variations being which byte goes where.

For light: LSFR -> light ; 0 -> dark
For dark: 0 -> light ; LFSR -> dark
For regular: LFSR -> light ; LFSR -> dark.

The actual logic on how to do it is up to you, tho if you want a hint or possible suggestions, here's a relevent snippet from E:SoR that does color layer effects, among other things, right in the LCD routine via jp (ix) and copying the routines to RAM:


Code:


Important note: Do NOT attempt to use this routine verbatim. It does things only insane people do under conditions that only insane people would run it under.

Fair enough. Hey, talked to Sorunome. The greyscale I use is actually the one you helped him with. That's portable to this, right?

The code I used in E:SoR is not portable anywhere in any form. You shouldn't even try to use it. I posted it to demonstrate that you can call a different piece of code by use of jp (ix) to change what sort of transform you do between data retrieval from the grayscale buffer and output to the screen.

The exercise of writing or finding a suitable 4 level grayscale routine, then modifying the routine is up to you.

Let me rephrase. The 4-layer greyscale Sorunome uses (which I can inbox to you for reference, if you like). Would it be trivial to modify that to add this static effect?

bump:

Here's a paste-bin of the greyscale interrupt routine.
http://pastebin.com/KXFUi8Ux#

I'm wondering where in that would the LSFR be inserted? Right at the beginning, after Disp4Lvl? And what buffer does that interact with? How would you change that?


Edit: Wait, geekboy helped me understand. That 16-bit LSFR routine generates a random mask. I then go into the greyscale routine and xor the mask not onto the buffers, but directly onto the byte that is being written to the LCD port. And (not sure how to do this bit), but for the darker static, apply the mask to where it writes from the dark grey buffer. For lighter, do it where it writes from the light grey buffer. For no static, just don't xor it.

Right. That code as it stands won't run at 15MHz. You'll need to add in a bunch of delay cycles between writes. At 6MHz, adding in the LFSR will effectively double the amount of time the routine needs to render to the screen. If you still want to do it at 6MHz, you can (probably?) do it this way:


Code:

what about this bit:


Code:


That still go after the djnz __Disp4LvlLoop ?

Aren't you missing this bit too?

Code:


I didn't put that down because it wasn't relevant to what's being changed, but is understood to be there because it's relevant to the overall code.

Yeah, thats what I meant. Well, that completes this. Now... one more thing....and then its done... \m/