Capstone Project | Usage: [options]

This is part 2 in a series on using SDL. See part 1 if you missed it. This post introduces more useful functions, structures, and constants in the SDL 2.0 API. It covers basic details such as return values and parameters of functions and names and data types of members of structs. For more detailed info, visit the links in the references.

Rendering

Call the SDL_CreateRenderer() function to create a renderer in which you can render objects such as rectangles in a window.^[1] The window should have already been initialized. See part 1 to review how to create an SDL_Window instance.

SDL_Renderer *SDL_CreateRenderer(SDL_Window *window,
int index, Uint32 flags);

Returns: if successful, a valid rendering context; on error, NULL

window is an SDL_Window instance where the renderer will be displayed.
index is the index of the rendering driver to initialize, or -1 to initialize the first one supporting the requested flags.
flags is 0, or one or more SDL_RendererFlags OR’d together. Possible values for flags:

SDL_RENDERER_SOFTWARE: the renderer is a software fallback
SDL_RENDERER_ACCELERATED: the renderer uses hardware acceleration
SDL_RENDERER_PRESENTVSYNC: present is synchronized with the refresh rate
SDL_RENDERER_TARGETTEXTURE: the renderer supports rendering to texture

You will likely want to render to a texture, which is created with SDL_CreateTexture().^[2]

SDL_Texture *SDL_CreateTexture(SDL_Renderer *renderer,
                                Uint32 format,
                                int access, int w,
                                int h);

Returns: a pointer to the created texture or NULL if no rendering context was active, the format was unsupported, or the width or height were out of range

renderer is the rendering context.
format is one of the enumerated values in SDL_PixelFormatEnum.
access is one of the enumerated values in SDL_TextureAccess, which are
- SDL_TEXTUREACCESS_STATIC: changes rarely, not lockable
- SDL_TEXTUREACCESS_STREAMING: changes frequently, lockable
- SDL_TEXTUREACCESS_TARGET: can be used as a render target
w is the width of the texture in pixels.
h is the height of the texture in pixels.

Use SDL_SetRenderTarget() is set a texture as the target of a renderer.^[3]

int SDL_SetRenderTarget(SDL_Renderer *renderer,
                        SDL_Texture *texture);

Returns: 0 on success or a negative error code on failure

renderer is the rendering context.
texture is the targeted texture, which must be created with the SDL_TEXTUREACCESS_TARGET flag, or NULL to render to the window instead of a texture.

To set the color used when rendering, use SDL_SetRenderDrawColor().^[4]

int SDL_SetRenderDrawColor(SDL_Renderer *renderer,
                   Uint8 r, Uint8 g, Uint8 b,
                   Uint8 a);

Returns: 0 on success or a negative error code on failure

renderer is the rendering context.
r, g, and b are the red, green, and blues value used to draw on the rendering target, respectively. These should be a value between 0 and 255, inclusive.
a is the alpha value (opacity) used to draw on the rendering target. This should be a value between 0 and 255, inclusive. Use SDL_ALPHA_OPAQUE or 255 to specify opaque. If you want to have a transparent object, use SDL_SetRenderDrawBlendMode().

Use SDL_RenderClear()^[5] to color the entire rendering target with the color previously set with SDL_SetRenderDrawColor().

int SDL_RenderClear(SDL_Renderer *renderer);

Returns: 0 on success or a negative error code on failure

renderer is the rendering context.

Use SDL_RenderFillRect() to render a filled rectangle with no outline.^[6]

int SDL_RenderFillRect(SDL_Renderer *renderer,
                       const SDL_Rect *rect);

Returns: 0 on success or a negative error code on failure

renderer is the rendering context.
rect is the SDL_Rect structure representing the rectangle to fill, or NULL for the entire rendering target.

[7]
typedef struct SDL_Rect
{
    int x, y;
    int w, h;
} SDL_Rect;

x and y are the x and y values of the rectangle’s upper left corner.
w and h are the width and height of the rectangle, respectively.

Use SDL_RenderDrawRect() to draw the outline of a rectangle.^[8] Its arguments are identical to the arguments for SDL_RenderFillRect().

int SDL_RenderDrawRect(SDL_Renderer *renderer,
                       const SDL_Rect *rect);

Returns: 0 on success or a negative error code on failure

To destroy a renderer for a window and free associated textures, use SDL_DestroyRenderer().^[9]

void SDL_DestroyRenderer(SDL_Renderer *renderer);

renderer is the rendering context to destroy.

References

My Capstone project this term is Build an Emulator and Run Space Invaders ROM. I will be working with a team of three other students. I am excited about working on this project because I am interested in low-level programming and old-school video games. Most of the code will be written in C (my favorite programming language!), but 8080 assembly code will also be used.

The program will take a ROM file as input. Currently, we are planning to target the Space Invaders ROM, but we may test with other ROM files if time allows. Since my group includes both Linux and Windows users, the program will be compatible with Linux and Windows. As an extension, we may develop for compatibility with other platforms, such as mobile.

Building the Disassembler

The first step will be to build a disassembler that will read hexadecimal data from the ROM file and print out the corresponding 8080 assembly instruction. There are 256 instructions, corresponding to opcodes 0x00 through 0xff. Thus, the implementation will likely involve a really long switch statement. For example, this snippet from emulator 101:

	switch (*code) {    
	case 0x00: 
		printf("NOP"); break;    
	case 0x01: 
		printf("LXI    B,#$%02x%02x", code[2], code[1]);
		opbytes=3; break;

Memory Map

The Intel 8080 CPU has 16 address pins, so it uses 16 bit addresses (0000 through ffff). The memory map for Space Invaders tells us what each address is used for.

0000-1FFF 8K ROM
2000-23FF 1K RAM
2400-3FFF 7K Video RAM
4000- RAM mirror

Implementing Opcodes

The next step will be to implement the instructions. We will create data structures to store info about the current state of the registers and the values of the FLAGS. The Intel 8080 CPU has seven 8-bit registers (A, B, C, D, E, H, and L) as well as the 16-bit registers for the stack pointer (SP), program counter (PC), and status register (FLAGS).

The program will modify the state (stored in the data structures) according to what effect that instruction would actually have on the registers in the 8080.

Emulating the Rest of the Hardware

We will need to emulate the rest of the hardware in the Space Invaders machine to actually see and play the game. This includes interrupts, graphics, buttons, and sounds. We will also need to emulate the speed of the 8080 processor, which has a CPU clock rate of 2 Mhz.

Usage: [options]

Category Archives: Capstone Project

Using SDL Part 2