iDunnoDev/assembly-graphics
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added the filled rectangle function

Browse Source 
Added comments for the new functions
Finished the circle function
This commit is contained in:
iDunnoDev
2022-11-13 00:53:24 +00:00
committed by iDunnoDev
parent 3d102dd9b8
commit c3113bc245
14 changed files with 877 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

637
stage4/bootasm2.S Normal file
View File

@ -0,0 +1,637 @@
# Second stage of the boot loader
.code16 # Assemble for 16-bit mode
.globl start
start:
jmp real_start
# Write to the console using BIOS.
#
# Input: SI contains the address of the null-terminated string to be displayed
cons_write:
movb $0x0e, %ah # 0x0e is the INT 10h BIOS call to output the value contained in AL to screen
cons_write_rpt:
movb (%si), %al # Load the byte at the location contained in the SI register into AL
inc %si # Add 1 to the value in SI
cmp $0, %al # Compare the value in AL with 0
jz cons_write_done # If it is zero, then we are done
int $0x10 # Output the character in AL to the screen
jmp cons_write_rpt # and continue
cons_write_done: # Something that is called will never return
ret # until a 'ret' instruction is encountered. Labels do
# not give a program any structure. They just give a
# memory location a name that we can use in our code.
cons_write_crlf:
movb $0x0e, %ah # Output CR
movb $0x0d, %al
int $0x10
movb $0x0a, %al # Output LF
int $0x10
ret
cons_writeline:
call cons_write
call cons_write_crlf
ret
# Added Write Hex and Int functions to help with debugging
HexChars: .ascii "0123456789ABCDEF"
cons_write_hex:
movw $4, %cx
movb $0x0E, %ah
hexloop:
rol $4, %bx
movw %bx, %si
and $0x000F, %si
movb HexChars(%si), %al
int $0x10
loop hexloop
ret
cons_write_int:
movw $IntBuffer + 4, %si
movw %bx, %ax
cmpw $0, %ax
jge getdigit
xor %ax, %ax # Added to handle signed numbers, it adds the minus and then neg's the number
movb $0x0E, %ah
movb $0x2D, %al
int $0x10
movw %bx, %ax
negw %ax
getdigit:
xor %dx, %dx
movw $10, %cx
idiv %cx
addb $48, %dl
movb %dl, (%si)
dec %si
cmp $0, %ax
jne getdigit
inc %si
call cons_write
ret
IntBuffer: .string " "
# Draw Line function DrawLine(x0 (4), y0 (6), x1 (8), y1 (10), color (12))
# Define parameter address positions in stack
#define color 12
#define y1 10
#define x1 8
#define y0 6
#define x0 4
# Define local variable positions in stack
#define deltax -2
#define deltay -4
#define sx -6
#define sy -8
#define err -10
#define e2 -12
cons_draw_line:
pushw %bp
movw %sp, %bp
subw $12, %sp # Make room for our local variables in the stack
# Store existing register values to the stack so we can restore later
pushw %ax
pushw %bx
pushw %cx
pushw %dx
pushw %si
pushw %di
movw $0, err(%bp) # Make sure that err starts at 0
movw x1(%bp), %cx # Load x1 and y1 into the registers
movw y1(%bp), %dx
sub x0(%bp), %cx # Remove x/y0 from x/y1 to get the delta values
sub y0(%bp), %dx
movw %cx, deltax(%bp) # Store the delta values
movw %dx, deltay(%bp)
cons_line_check_x:
movw x0(%bp), %cx # Load x0 into register cx so we can manipulate this value to plot each pixel
movw $1, sx(%bp) # Preload the x slope with 1
cmp x1(%bp), %cx # Check if x0 is less than x1 and we can move to y
jl cons_line_check_y
negw sx(%bp) # If x1 is greater than we need to flip the slope and the x delta values
negw deltax(%bp) # Flipping the deltax here saves us from having to have an abs function because if
# x0 was greater than x1 we know we have a negative delta value and we flip it to pos
cons_line_check_y:
movw y0(%bp), %dx # Load y0 into register dx so we can manipulate this value to plot each pixel
movw $1, sy(%bp) # Preload the y slope with 1
cmpw y1(%bp), %dx # Check if y0 is less than y1 and we can start our plotting
jl cons_line_prep_loop
negw sy(%bp) # if y1 is greater than we need to flip the slope y and delta y values
negw deltay(%bp)
cons_line_prep_loop:
movw deltax(%bp), %ax # Calculate the err variable by subtracting delta y from delta x
sub deltay(%bp), %ax
movw %ax, err(%bp)
cons_line_loop_start:
pushw color(%bp)
pushw %dx
pushw %cx
call cons_plot_pixel
cmpw x1(%bp), %cx # Check if x0 and x1 are equal, if not then we are still plotting
jne cons_line_loop_next_point
cmpw y1(%bp), %dx # Check if y0 and y1 are equal, if not then we are still plotting
jne cons_line_loop_next_point
jmp cons_line_loop_end # if both x's and y's are equal then we can end the function
cons_line_loop_next_point:
movw err(%bp), %ax # Load err into ax so that we can change it
sal %ax # e2 is 2 * err, so we can arithmatic shift left
cons_line_loop_move_y_point:
movw deltay(%bp), %bx
negw %bx # We need negative deltay to compare
cmpw %bx, %ax # Check if we need to apply the slope value to y
jle cons_line_loop_move_x_point
negw %bx # Change deltay back to normal
subw %bx, err(%bp) # Remove the deltay from the err check
addw sx(%bp), %cx # Add the slope value to the current y value
cons_line_loop_move_x_point:
movw deltax(%bp), %bx
cmpw %bx, %ax # Check if we need to apply the x slope value
jge cons_line_loop_start
addw %bx, err(%bp) # Add the deltax to the err value
addw sy(%bp), %dx # Add the slope value to the current x value
jmp cons_line_loop_start # Go back to the start of the loop
cons_line_loop_end:
# Return all the original values to each register before we return back
popw %di
popw %si
popw %dx
popw %cx
popw %bx
popw %ax
movw %bp, %sp
popw %bp
ret $10 # Finish the loop and return to the call address
# we also tell it to free the 10 bytes in the stack for the paramters
# 5 x Word (2 bytes)
# Function PlotPixel(pixelx (4), pixely (6), pixelColor (8))
#define pixelcolor 8
#define pixely 6
#define pixelx 4
# I split the pixel plotting off into its own function so that we can use it for any other function that plots pixels
# and any boundary checks will be applied with the same rules
cons_plot_pixel:
# Setup the stack
pushw %bp
movw %sp, %bp
# Store existing register values to the stack so we can restore later
pushw %ax
pushw %bx
pushw %cx
pushw %dx
pushw %si
pushw %di
xor %ax, %ax # Clear ax and bx for use with the draw function
xor %bx, %bx
movw pixelx(%bp), %cx # Move x and y into their registers
movw pixely(%bp), %dx
cmpw (screen_width), %cx # Check if the x value has gone past the width of the screen
jg cons_plot_pixel_end # If so we ignore the pixel so that we dont draw into unrelated memory
cmpw $0, %cx # also check if x has gotten less than 0
jl cons_plot_pixel_end
cmpw (screen_height), %dx # Do the same checks for the y position, i chose to ignore the pixel rather than
jg cons_plot_pixel_end # end the entire draw because when we come to the circles and polygons we
cmpw $0, %dx # can still partially show the output that falls within the boundaries
jl cons_plot_pixel_end
# Pixel point = 0xA0000 + (y * 320) + x
movw (screen_width), %ax # Set ax to 320 so that we can multiply this by y
mul %dx # does the (y * 320) part of our math
add %cx, %ax # Add the value of x to register ax
movw %ax, %si # Move the value of ax into the si counter
movw $0xA000, %bx # Set the start of the video memory location
movw %bx, %es # Move that address into the "extra segment" es register
movw pixelcolor(%bp), %bx # Load the color into a register
movb %bl, %es:(%si) # Load the lower half of the color (since they should only be from 0 to 255)
# and place it at the given byte in the segment
cons_plot_pixel_end:
# Return all the original values to each register before we return back
popw %di
popw %si
popw %dx
popw %cx
popw %bx
popw %ax
movw %bp, %sp
popw %bp
ret $6 # Finish the loop and return to the call address
# Draw Line function DrawFilledRect(rectx (4), recty (6), rectWidth (8), rectHeight (10), rectColor (12))
# Define parameter address positions in stack
#define rectcolor 12
#define rectheight 10
#define rectwidth 8
#define recty 6
#define rectx 4
#define rectendx -2
#define rectendy -4
cons_draw_filled_rect:
pushw %bp
movw %sp, %bp
subw $4, %sp # Make room for our local variables in the stack
# Store existing register values to the stack so we can restore later
pushw %ax
pushw %bx
pushw %cx
pushw %dx
pushw %si
pushw %di
cons_filled_rect_setup:
movw rectwidth(%bp), %ax
add rectx(%bp), %ax
movw %ax, rectendx(%bp)
movw rectheight(%bp), %bx
add recty(%bp), %bx
movw %bx, rectendy(%bp)
movw $0xA000, %bx # Set the start of the video memory location
movw %bx, %es # Move that address into the "extra segment" es register
movw recty(%bp), %dx
movw (screen_width), %ax # Set ax to 320 so that we can multiply this by y
mul %dx # does the (y * 320) part of our math
add rectx(%bp), %ax # Add the value of x to register ax
movw %ax, %si
lea %es:(%si), %bx # Move the value of ax into the si counter
movw rectheight(%bp), %si
cons_filled_rect_loop_start:
movw rectcolor(%bp), %ax
movw %bx, %di
movw rectwidth(%bp), %cx
cld
rep stosb
movw (screen_width), %cx
add %cx, %bx
dec %si
jnz cons_filled_rect_loop_start
cons_filled_rect_loop_end:
# Return all the original values to each register before we return back
popw %di
popw %si
popw %dx
popw %cx
popw %bx
popw %ax
movw %bp, %sp
popw %bp
ret $10 # Finish the loop and return to the call address
# we also tell it to free the 10 bytes in the stack for the paramters
# 5 x Word (2 bytes)
# Draw Line function DrawCircle(circlex (4), circley (6), circleRadius (8), circleColor (10))
# This follows the bresenham circle drawing algorithm so that we can stick to integer values
# Define parameter address positions in stack
#define circlecolor 10
#define circleradius 8
#define circley 6
#define circlex 4
# Define local variable positions in stack
#define circled -4 # Decision variable
#define circlexcax -6
#define circlexcsx -8
#define circleycay -10
#define circleycsy -12
#define circlexcay -14
#define circlexcsy -16
#define circleycax -18
#define circleycsx -20
cons_draw_circle:
pushw %bp
movw %sp, %bp
subw $20, %sp # Make room for our local variables in the stack
# Store existing register values to the stack so we can restore later
pushw %ax
pushw %bx
pushw %cx
pushw %dx
pushw %si
pushw %di
cons_draw_circle_setup:
movw $0, %cx # x starts at 0
movw circleradius(%bp), %dx # y starts as the radius
movw circleradius(%bp), %bx # d = 3 - (2 * r), we load the radius into a register
sal %bx # and multiply it by 2
movw $3, %ax # load a 3 into a register to subtract the above from
sub %bx, %ax
movw %ax, circled(%bp) # Move the d variable into the stack
cons_circle_loop_start:
# We need to plot all 8 points for this step
xor %ax, %ax # Clear a and b registers for use below
xor %bx, %bx
movw circlex(%bp), %ax # Points xc + x, yc + y
add %cx, %ax
movw circley(%bp), %bx
add %dx, %bx
movw %ax, circlexcax(%bp)
movw %bx, circleycay(%bp)
movw circlex(%bp), %ax # Points xc - x, yc - y
sub %cx, %ax
movw circley(%bp), %bx
sub %dx, %bx
movw %ax, circlexcsx(%bp)
movw %bx, circleycsy(%bp)
movw circlex(%bp), %ax # Points xc + y, yc + x
add %dx, %ax
movw circley(%bp), %bx
add %cx, %bx
movw %ax, circlexcay(%bp)
movw %bx, circleycax(%bp)
movw circlex(%bp), %ax # Points xc - y, yc - x
sub %dx, %ax
movw circley(%bp), %bx
sub %cx, %bx
movw %ax, circlexcsy(%bp)
movw %bx, circleycsx(%bp)
# Plot the 8 pixels for this turn of the circle
pushw circlecolor(%bp)
pushw circleycay(%bp)
pushw circlexcax(%bp)
call cons_plot_pixel
pushw circlecolor(%bp)
pushw circleycay(%bp)
pushw circlexcsx(%bp)
call cons_plot_pixel
pushw circlecolor(%bp)
pushw circleycsy(%bp)
pushw circlexcax(%bp)
call cons_plot_pixel
pushw circlecolor(%bp)
pushw circleycsy(%bp)
pushw circlexcsx(%bp)
call cons_plot_pixel
pushw circlecolor(%bp)
pushw circleycax(%bp)
pushw circlexcay(%bp)
call cons_plot_pixel
pushw circlecolor(%bp)
pushw circleycax(%bp)
pushw circlexcsy(%bp)
call cons_plot_pixel
pushw circlecolor(%bp)
pushw circleycsx(%bp)
pushw circlexcay(%bp)
call cons_plot_pixel
pushw circlecolor(%bp)
pushw circleycsx(%bp)
pushw circlexcsy(%bp)
call cons_plot_pixel
inc %cx # Inc the x value
cmpw $0, circled(%bp) # check if the decision variable is less than 0
jle cons_circle_skip_y
dec %dx # If not we decrement the Y value and calculate the new decision value
movw %cx, %ax # Move the x value into ax for mul
movw %dx, %bx # Move the y value into bx since mul destroys the value in dx
movw $4, %si # Move 4 into si because we are out of registers
sub %bx, %ax # d = d + 4 * (x - y) + 10
imul %si
add $10, %ax
add %ax, circled(%bp) # Add the result to the current D value
movw %bx, %dx # Move y back into the dx register
jmp cons_circle_check_end # jump over the next section to the end check
cons_circle_skip_y:
movw %cx, %ax # If the decision var was greater than 0 we use another formula for d
movw %dx, %bx # Store y in bx because we are using mul again
movw $4, %si # d = d + 4 * x + 6
imul %si
add $6, %ax
add %ax, circled(%bp)
movw %bx, %dx # Restore y to the dx register
cons_circle_check_end:
cmpw %cx, %dx # Check if y is greater than or equal to x
jge cons_circle_loop_start # If so we carry on the loop until it is no longer
cons_circle_loop_end:
# Return all the original values to each register before we return back
popw %di
popw %si
popw %dx
popw %cx
popw %bx
popw %ax
movw %bp, %sp
popw %bp
ret $8 # Finish the loop and return to the call address
# we also tell it to free the 10 bytes in the stack for the paramters
# 4 x Word (2 bytes)
real_start:
movw $boot_message, %si # Display our boot message
call cons_writeline
draw_start:
# Set the Video mode to VGA 320 x 200 x 256
movb $0, %ah
movb $0x13, %al
int $0x10
xor %ax, %ax
# Setup the registers to loop through the flag stripes
movw $150, %ax # x Offset
movw $15, %bx # y Offset
movw $6, %cx # Sets of stripes (12 red/white) for the loop to decrement
draw_flag_loop:
# Draw our filled rectangles for the flag stripes
add $5, %bx # add the height of stripe to the y offset
pushw $12 # Color
pushw $5 # height
pushw $120 # width
pushw %bx # y
pushw %ax # x
call cons_draw_filled_rect
add $5, %bx # add the height of stripe to the y offset
pushw $15 # Color
pushw $5 # height
pushw $120 # width
pushw %bx # y
pushw %ax # x
call cons_draw_filled_rect
loop draw_flag_loop
draw_flag_loop_end:
# Draw the 13th stripe
add $5, %bx
pushw $12 # Color
pushw $5 # height
pushw $120 # width
pushw %bx # y
pushw %ax # x
call cons_draw_filled_rect
# Draw the blue box that would hold the stars
pushw $1 # Color
pushw $35 # height
pushw $45 # width
pushw $20 # y
pushw $150 # x
call cons_draw_filled_rect
pushw $6 # Color
pushw $180 # height
pushw $5 # width
pushw $20 # y
pushw $145 # x
call cons_draw_filled_rect
# Draw some circles to show off that function
pushw $14 # Color
pushw $3 # radius
pushw $17 # y
pushw $147 # x
call cons_draw_circle
pushw $2 # Color
pushw $25 # radius
pushw $80 # y
pushw $90 # x
call cons_draw_circle
pushw $15 # Color
pushw $5 # radius
pushw $75 # y
pushw $80 # x
call cons_draw_circle
pushw $15 # Color
pushw $5 # radius
pushw $75 # y
pushw $100 # x
call cons_draw_circle
# Plot a line, we add the parameters to the stack in reverse order
pushw $15 # Color
pushw $90 # y1
pushw $75 # x1
pushw $95 # y0
pushw $90 # x0
call cons_draw_line
pushw $15 # Color
pushw $90 # y1
pushw $105 # x1
pushw $95 # y0
pushw $90 # x0
call cons_draw_line
# Draw the rest of the lines
pushw $2 # Color
pushw $200 # y1
pushw $90 # x1
pushw $105 # y0
pushw $90 # x0
call cons_draw_line
pushw $2 # Color
pushw $100 # y1
pushw $145 # x1
pushw $120 # y0
pushw $90 # x0
call cons_draw_line
# Line borders
pushw $9 # Color
pushw $10 # y1
pushw $310 # x1
pushw $10 # y0
pushw $10 # x0
call cons_draw_line
pushw $10 # Color
pushw $190 # y1
pushw $310 # x1
pushw $10 # y0
pushw $310 # x0
call cons_draw_line
pushw $13 # Color
pushw $190 # y1
pushw $10 # x1
pushw $190 # y0
pushw $310 # x0
call cons_draw_line
pushw $15 # Color
pushw $10 # y1
pushw $10 # x1
pushw $190 # y0
pushw $10 # x0
call cons_draw_line
endless_loop: # Loop forever more
jmp endless_loop
# Program data
boot_message:
.string "Boot Loader Stage 2 loaded"
screen_width:
.word 320
screen_height:
.word 200