Learn Multi platform Super-H Assembly Programming... Because Why not?

Simple Samples

In this series we'll learn a how to do simple tasks, with a single small asm file (where possible)

Lesson S1 - Sprite movement on the Saturn
In this lesson we'll create a minimal example on the Sega Saturn. We'll create a BIN file we can run on our emulator, which shows a bitmap sprite we can move around the sprite with the joypad

Sat_JoySprite.asm


Setting up the Saturn
We're gong to show a moving bitmap onscreen.

We will draw it with XOR - an inversion operation.

This means if we draw the sprite twice in the same location, the second draw will remove it.
Our BIN program needs to start at address $6004000, we do this with an ORG statement.
Next we need to set up a valid screen.

We need to set various registers on VDP2 (the video device for the bitmap screen). Shown here are sample values which will work on our emulator

We need to set up the Ram layout and screen mode.

We set up the scroll postition and map offset.

We set up the bitmap screen size.

Finally we enable the layer and turn on the screen
Our screen is on, but we've not set up any colors!

The color ram is at address $25F00000, The screen is set up to use 5 bits per channel in the format %-BBBBBGGGGGRRRRR

We transfer each of the 4 colors to CRAM to set up our color screen



Drawing Our sprite
We need to calculate the VRAM Destination for our sprite.

Our screen base is $25E00000. Each pixel is one byte

The Visible screen is 320 pixels wide, but the logical (virtual screen) is 512 bytes wide. Therefore our formula is:

VRAM = $25E00000 + (Ypos * 512) + Xpos
Our sprite source address (bitmap data) is in R13, our vram destination is now in R12

Our width and height in pixels are in R11,R12

We transfer the image one word (4 bytes) at a time from the source, Xor it with the current screen data, and write it back to VRAM.

Our bitmap is included as binary data - it's the same format as DOS VGA!

We define two 32 bit values in our 'UserRam' for the player position

Reading the joystick
We're going to use the SMPC (System Manager and Peripheral Control) hardware to get the joypad buttons.

We'll use the function INTBACK - Interrupt Back (SMPC Status Acquisition) to get the joypad state.

First we set up DDR1 data direction (All bits to input), IOSEL1 (SPMPC mode) and EXLE1 (VDP latch off)
We have to send a fixed sequence of bytes to the SMPC registers in order to prepare the command to request the joystick data.

We write these to IREGs $20100001-$2010000D

The last write to $2010001F actions the data request
Our command has been sent, but we may need to wait a bit for the reply, we test bit 0 of the Status register at $20100063

The results will be in the output registers at address $20100020+
The response is in the registers $20100020/2/4/6/8 ...
Each 16 bit entry at these addresses contains the same 8 bit byte repeated twice.

The first few bytes contain the following data:
  %11110001    = No multitap
  %00000010    = Standard pad
  %RLDUSABC    = Genesis buttons
  %rXYZl---    = Saturn buttons


Whatever the system to allow for easy porting of programs,  These tutorials use a common format for joypad output of RLDU in bits 3-0, and bits 4+ are fire buttons in decreasing importance (Bit 4=Fire 1, Bit 5=Fire 2 if available etc)

We bitshift all the joypad directions and fires into the correct locations with combinations of SHLR and SHLL
We need to calculate the VRAM destination for our drawing

While not all are visible, Our screen is 512 bytes wide, each pixel is 1 byte
The screen base is $25e00000

So our formula is:

VRAM= $25e00000 + Ypos*512 + Xpos

However our Cursor Xpos and Ypos are measured in characters, so we multiply them by 8 via 3 shifts first.
one screen byte is a pixel... but in our font one bit is a pixel! We shift bits out of the right of our source byte, so we work right to left on our screen.

To do this we add 7 to our Vram destination, to move to the rightmost pixel of the line.

We load a byte from our font into R3,

We shift bits our R3, test them and write the correct color (1 or 0) to the screen in R6.

After a line, we move down the screen by adding 512 (+8 to compensate for the moves)

We repeat until our character is drawn
We're done! so we restore all the registers from the stack.

Moving our sprite
Ok! We have all the subroutines we need.

First we draw the initial position of our player sprite, Next we read in from the joystick, and wait for a direction to be pressed.
Throughout the next part of our code R1,R2 contain the X,Y position of the sprite, and R0 contains the joystick directions.

We test each direction buttons bit.
If a direction is pressed, we check the position of the sprite, if it's not at the edge of the screen we change the co-ordinate, moving in the direction specified.
Ok, we need to remove the old sprite from the screen.

As we're using XOR, all we need to do to remove the old sprite is draw again in the old position.
We store the new sprite position, and redraw the sprite.
Finally we pause for a while - otherwise our demo would be too fast! (thanks sh2!!!), and repeat!


Using a crude delay loop like this isn't really very good, we should really wait for VBLank or something!

Still it's good enough for this simple test.


Lesson S2 - Sprite movement on the 32x
In this lesson we'll create a minimal example on the 32x. We'll create a cartridge file we can run on our emulator, which shows a bitmap sprite we can move around the sprite with the joypad

MDHeader_MinJoy.asm
32x_JoySprite.asm

Normally in these tutorials we would have a single ASM file, but this time we need two because of how the 32x works.

The first is a Megadrive/Genesis 68000 'boot strap' which starts up the system, before starting up the 32x part.
We'll assemble the genesis 68000 part with VASM
We'll assemble the 32x part with ASW


The 32x be so dumb! How dumb is it? it can't even read from it's own joypad!!!

To read the joypa
d we have to get the genesis to do it... and pass the result to the 32x via one of the 'Shared registers'

The Genesis bootstrap

At the start of the 68000 memory map is the 'exception table', however on the 32x, this is moved to $00000200

The old table is filled with branches to the 32x startup routine are $000003F0
Next we have our cartridge header, this just contains the description of our cartridge, and a few other bits.
The exception table is now at address $00000200

We only need the reset address, which points to the program code for the 68000 Genesis processor
We now have the 32x header.

Address $000003D4 has the address of the 32x program code in the genesis cartridge
This will be copied to the 32x memory

$3E0 and $3E4 have the execution address of the 32x code for the two SH2 processors. These should be at address $06000000+


 
At address $3F0+ we have the 32x startup code.

As a security feature, Much of this has to byte match the same code in the 32x rom, so is included as binary data.
Our Geneisis 68000 program is very basic, we release the video hardware to the SH2, and drop into an infinate loop

The infinite loop reads in from the joypad
There are two ports which are read and written for the joypad...
Joypad 1 is at address $A10005
Joypad 2 is at address $A10003

First, however, we need to set one of the bits of these ports to WRITE... we do this with 2 ports...
Joypad 1 is at address $A1000B
Joypad 2 is at address $A10009
The Joypad needs a sequence of writes to select the 'sections' of the joypad... this is achieved by writes with bit 6 as a 1

The first batch returns Up, Down, Left, Right... button C and Button B

The second batch returns Button A and Start

The final batch are Button X, Button Y and Button Z... as well as Mode.

Note: some of the buttons are duplicated... eg Up is returned in the first and second batch.
Finally, we shift around the bits, so we have all the buttons in a neat order in a single register.
In the rom file, After our 68000 code we will 'attach' the assembled 32x binary.

We do this 'combining' with a batch file.


The 32x bootstrap!

When it's loaded into the 32x memory, our SH2 program will start at address $06000000

We specified the secondary SH2 would start executing this address... we don't actually plan to use that CPU, so we lock it into an infinite loop.
CPU 1's entry point was defined as $06000004 in the 32x header.

First we wait for the 68000 to release the VDP
We use the Bitmap Mode Register $20004100 to turn on the screen.

Here we select a 256 color screen mode.

The SH2 screen memory needs to start with a 'Line Table'

This defines the memory addresses that are used for each line of the screen. We do this twice, once for each screen buffer.

We'll take a look at this in a moment!
Our screen is nearly ready, it's on, but we need to set up it's colors.

Each color is defined by 16 bits, from address $20004200 - The bits are in the format %-BBBBBGGGGGRRRRR




Graphics routines.

The Line table starts at $24000000, each entry is one word - 224 line entries in total , and contains the offset IN WORDS for the bitmap data of that line.

Effectively we write $100+(Line*160)  repeating for 224 lines.
To force a page flip, we need to flip bit 0 of $2000410A.

This transfers the buffer fat address $24000000 into VRAM.

But there's a catch! the flip won't actually occur until VBLANK, so once we attempt the flip, we wait until it actually occurs by waiting for the read back bit to match the one we wrote.
We have a 'Clear Screen' routine, which will fill the buffer with zero bytes

Drawing Our sprite
We need to calculate the VRAM Destination for our sprite.

Our screen base is $24000200. Each pixel is one byte

The Visible screen is 320 pixels wide,  Therefore our formula is:

VRAM = $24000200 + (Ypos * 320) + Xpos
Our sprite source address (bitmap data) is in R13, our vram destination is now in R12

Our width and height in pixels are in R11,R12

We transfer the image one word (4 bytes) at a time from the source, and write them to the screen

Our bitmap is included as binary data - it's the same format as DOS VGA!

We define two 32 bit values in our 'UserRam' for the player position

Moving our sprite
Ok! We have all the subroutines we need.

First we draw the initial position of our player sprite, and flip the buffer to get it onto the screen


Next we read in from the joystick from the shared register $20004020 ($A15120 on the genesis side)

We wait for a direction to be pressed.
Throughout the next part of our code R1,R2 contain the X,Y position of the sprite, and R0 contains the joystick directions.

We test each direction buttons bit.
If a direction is pressed, we check the position of the sprite, if it's not at the edge of the screen we change the co-ordinate, moving in the direction specified.
We store the updated sprite position.

We need to remove the old sprite from the screen. we run the CLS routine to do this

We redraw the sprite, flip the page buffer and repeat







 

View Options
Default Dark
Simple (Hide this menu)
Print Mode (white background)

Top Menu
***Main Menu***
Youtube channel
Patreon
Introduction to Assembly (Basics for absolute beginners)
Amazon Affiliate Link
Forum
AkuSprite Editor
ChibiTracker
Dec/Bin/Hex/Oct/Ascii Table

Alt Tech
Archive.org
Bitchute
Odysee
Rumble
DailyMotion
Please note: I wlll upload more content to these alt platforms based on the views they bring in

Z80 Content
***Z80 Tutorial List***
Learn Z80 Assembly (2021)
Learn Z80 Assembly (old)
Hello World
Simple Samples
Advanced Series
Multiplatform Series
Platform Specific Series
ChibiAkumas Series
Grime Z80
Z80 Downloads
Z80 Cheatsheet
Sources.7z
DevTools kit
Z80 Platforms
Amstrad CPC
Elan Enterprise
Gameboy & Gameboy Color
Master System & GameGear
MSX & MSX2
Sam Coupe
TI-83
ZX Spectrum
Spectrum NEXT
Camputers Lynx

6502 Content
***6502 Tutorial List***
Learn 6502 Assembly
Advanced Series
Platform Specific Series
Hello World Series
Simple Samples
Grime 6502
6502 Downloads
6502 Cheatsheet
Sources.7z
DevTools kit
6502 Platforms
Apple IIe
Atari 800 and 5200
Atari Lynx
BBC Micro
Commodore 64
Commodore PET
Commander x16
Super Nintendo (SNES)
Nintendo NES / Famicom
PC Engine (Turbografx-16)
Vic 20

68000 Content
***68000 Tutorial List***
Learn 68000 Assembly
Hello World Series
Platform Specific Series
Simple Samples
Grime 68000
68000 Downloads
68000 Cheatsheet
Sources.7z
DevTools kit
68000 Platforms
Amiga 500
Atari ST
Neo Geo
Sega Genesis / Mega Drive
Sinclair QL
X68000 (Sharp x68k)

8086 Content
Learn 8086 Assembly
Platform Specific Series
Hello World Series
Simple Samples
8086 Downloads
8086 Cheatsheet
Sources.7z
DevTools kit
8086 Platforms
Wonderswan
MsDos

ARM Content
Learn ARM Assembly
Learn ARM Thumb Assembly
Platform Specific Series
Hello World
Simple Samples
ARM Downloads
ARM Cheatsheet
Sources.7z
DevTools kit
ARM Platforms
Gameboy Advance
Nintendo DS
Risc Os

Risc-V Content
Learn Risc-V Assembly
Risc-V Downloads
Risc-V Cheatsheet
Sources.7z
DevTools kit

MIPS Content
Learn Risc-V Assembly
Platform Specific Series
Hello World
Simple Samples
MIPS Downloads
MIPS Cheatsheet
Sources.7z
DevTools kit
MIPS Platforms
Playstation
N64

PDP-11 Content
Learn PDP-11 Assembly
Platform Specific Series
Simple Samples
PDP-11 Downloads
PDP-11 Cheatsheet
Sources.7z
DevTools kit
PDP-11 Platforms
PDP-11
UKNC

TMS9900 Content
Learn TMS9900 Assembly
Platform Specific Series
Hello World
TMS9900 Downloads
TMS9900 Cheatsheet
Sources.7z
DevTools kit
TMS9900 Platforms
Ti 99

6809 Content
Learn 6809 Assembly
Learn 6309 Assembly
Platform Specific Series
Hello World Series
Simple Samples
6809 Downloads
6809/6309 Cheatsheet
Sources.7z
DevTools kit
6809 Platforms
Dragon 32/Tandy Coco
Fujitsu FM7
TRS-80 Coco 3
Vectrex

65816 Content
Learn 65816 Assembly
Hello World
Simple Samples
65816 Downloads
65816 Cheatsheet
Sources.7z
DevTools kit
65816 Platforms
SNES

eZ80 Content
Learn eZ80 Assembly
Platform Specific Series
eZ80 Downloads
eZ80 Cheatsheet
Sources.7z
DevTools kit
eZ80 Platforms
Ti84 PCE

IBM370 Content
Learn IBM370 Assembly
Simple Samples
IBM370 Downloads
IBM370 Cheatsheet
Sources.7z
DevTools kit

Super-H Content
Learn SH2 Assembly
Hello World Series
Simple Samples
SH2 Downloads
SH2 Cheatsheet
Sources.7z
DevTools kit
SH2 Platforms
32x
Saturn

PowerPC Content
Learn PowerPC Assembly
Hello World Series
Simple Samples
PowerPC Downloads
PowerPC Cheatsheet
Sources.7z
DevTools kit
PowerPC Platforms
Gamecube

Work in Progress
ChibiAndroids

Misc bits
Ruby programming









Buy my Assembly programming book
on Amazon in Print or Kindle!


Buy my Assembly programming book



Available worldwide!
Search 'ChibiAkumas' on
your local Amazon website!
Click here for more info!


































































































































































Buy my Assembly programming book
on Amazon in Print or Kindle!


Buy my Assembly programming book



Available worldwide!
Search 'ChibiAkumas' on
your local Amazon website!
Click here for more info!












































































































Buy my Assembly programming book
on Amazon in Print or Kindle!


Buy my Assembly programming book



Available worldwide!
Search 'ChibiAkumas' on
your local Amazon website!
Click here for more info!



































































































Buy my Assembly programming book
on Amazon in Print or Kindle!


Buy my Assembly programming book



Available worldwide!
Search 'ChibiAkumas' on
your local Amazon website!
Click here for more info!



































































































Buy my Assembly programming book
on Amazon in Print or Kindle!


Buy my Assembly programming book



Available worldwide!
Search 'ChibiAkumas' on
your local Amazon website!
Click here for more info!



































































































Buy my Assembly programming book
on Amazon in Print or Kindle!


Buy my Assembly programming book



Available worldwide!
Search 'ChibiAkumas' on
your local Amazon website!
Click here for more info!



































































































Buy my Assembly programming book
on Amazon in Print or Kindle!


Buy my Assembly programming book



Available worldwide!
Search 'ChibiAkumas' on
your local Amazon website!
Click here for more info!