MrKWatkins

C#

Vectorized ZX Spectrum Screen Rendering

A vectorized method for rendering the ZX Spectrum screen on modern devices.

C#

Rendering the ZX Spectrum Screen

Using C# to convert the ZX Spectrum screen to a pixel based format for rendering on modern devices.

C#

A Bit of Vectorization

Speeding up a function using SIMD vector operations.

C#

A Pointless Performance Optimisation

Taking a simple, fast function and changing it into a complex, faster function.

Poker

Evaluating Poker Hands

Finally we're in a position to actually evaluate poker hands using my favourite hobby of gratuitous bit twiddling.

Poker

More Bit Representations

Let's look at another way to represent cards using bits that will be much easier to work with when we finally get around to evaluating poker hands.

Poker

Card Combinations

Before we can start evaluating five card poker hands we actually need to get some five card poker hands. So we need some code to produce five card hand combinations from a full deck of cards.

Poker

A Set of Cards

First in a series of post where I discuss how to evaluate poker hands using C# and excessive bit twiddling.

Rendering

Spherical Lights

As mentioned in the previous post I've decided to start looking at rendering again to help me learn a new programming language, Rust. I initially started with just point light sources but I have recently added spherical light sources too. Why bother? What is the difference? Point vs.

Rendering

Rust Rendering

I've decided to start looking at rendering again to help me learn a new programming language, Rust. I haven't learnt a new language for a while and Rust sounds like a good one to learn. It has some nice concepts, especially around enforcing lifetimes, that I&

Algorithms

Topological Ordering

Topological ordering is ordering dependent items in such a way that items you depend upon come first in the ordering. For example if x depends on y and y depends on z then the topological order would be z, y, x. Maybe dependency ordering would be a better name; it

Oakley

Installing Z88DK on Ubuntu 18.04

I had a few issues whilst following the instructions to install Z88DK on Ubuntu 18.04 so thought I would document my solutions here in case anyone else has similar problems. Note that I am a Linux novice so apologies if any of this seems obvious for a Linux pro.

Oakley

Oakley - LoRes Demos

I've been adding some support to the Oakley standard library for the LoRes screen mode of the ZX Spectrum Next, as well as some code for creating palettes and floating point number support. I've created two demos that use the new code: Stripes Displays some stripes.

Oakley

Oakley Progress Report

I've made quite a bit of progress since I last blogged about Oakley. I might actually be able to release an alpha version in the next decade! Better Numbers * No need to specify the type of number anymore, e.g. you can now write 12 rather than 12b.

ZX Spectrum Next

ZX Spectrum Next Test Programs

Whilst developing the second Oakley demo I've hit various behavioural differences between CSpect, ZEsarUX and the real hardware. I thought it might be useful to setup a repository of test programs to reproduce these differences in test cases, as opposed to just moaning about things. (Although I do

Oakley

Oakley - The Second Demo

Time for another demo created with my new programming language for the ZX Spectrum Next. This one has quite a lot more going on than the first demo and if nothing else demonstrates that I'm not completely wasting my time with this project. Here is a video of

Oakley

Performance Tuning Oakley

I've nearly completed the second Oakley demo and by and large it runs very well in CSpect. However there are a few minor display issues at the top of the screen which is due to the code for each frame taking slightly longer than a frame to run,

Oakley

Having Greys Makes a Bit of Difference

The ZX Spectrum Next uses 9-bits for its colours, giving a total of 512 possible different colours. The Next's palettes are only 256 colours in size however. The default palette uses 8-bit colours of the format RRRGGGBB, generated by the taking the numbers 0 - 255 in order.

Oakley

Keeping Things Consistent

The main rule I've tried to follow when designing Oakley is to avoid special cases as far as possible. C# has quite a few of these and they annoy me. For example: * Constructors. Why do these have a special syntax? They're just a static function that

Oakley

Oakley - The First Demo

I've managed to get my new programming language to a state where I can release a demo that is vaguely interesting. Here is a video of the demo running on the CSpect emulator: Yes, it's a bouncy snake thing. Here is the Oakley source code: using

Oakley

Oakley - Writing a New Language

After many years of moaning about various other languages I've decided to try and write my own, if only so I don't have to listen to myself moan about such things any more... The idea to do so originally came from the Facebook group for the

Rendering

Triangles and Meshes

Next step is to add in triangles. From there we can go to meshes of triangles, and then render something a bit more interesting than a sphere... Triangles As with previous shapes to render a triangle we need to be able to calculate if a ray intersects it or not.

Rendering

Transparent Boxes

Transparency. This is similar to reflection, however instead of tracing a reflected ray away from the object we trace a transmitted ray into the object. Transmittance I accidentally added transmittance to the ray tracer when developing reflections; instead of using the reflected direction for the reflected ray I accidentally used

Rendering

Phong and Reflections

Next up is improving the shading model and adding reflections. Phong Reflection Model The Phong reflection model adds to Lambertian reflectance with a term for specular highlights, the sharp highlights you see on shiny surfaces. The equation for Phong reflectance is: \[ C = k_A C_A + \sum_{i} (k_D

Rendering

Attenuation, Textures and Third Party Code

To make the scenes a bit more interesting the next step is to add some more realistic lighting and some textures. Attenuation When modelling Lambertian Reflectance I made the lights have constant intensity, i.e. the intensity at the point on the surface \( I \) was always 1. In reality the