Drawing a square

Hey guys. I'm DOS programming in 16-bit, using INT 10H.

So I know how to create a line, basically by drawing a pixel, and creating a loop to continue drawing pixels beside each other. But I don't know how to create a square. Does anybody have any ideas how I could create a square?

I could create a procedure to repeat the code that draws a line, to produce a bunch of lines that are on top of each other, which would look like a square. I don't think this is the most efficient way, and could cause me more problems down the road as I try to move the square around the screen.

Anyways, any help would be really appreciated. Thanks.

G'day.

That is how you do it, just be sure to use a function that only draws horizontal lines, as opposed to a generic line algo.

The optimizations available depend on the language you're using and the screen mode you're in.

If you're using mode 0x13h (320x200x256 cols) and doing it in assembly I've got some routines that are fairly speedy. Part of the trick is to write to the screen memory directly, and in a loop - as opposed to calling a Pixel function.

as an (ashamedly, rather rough) example, to draw a square that's 4x4 in the top left corner of the screen, using color 10d:



Another tip worth pointing out is that bit-shift operations were quicker than multiply instructions last time I looked.

So, assuming you were using mode 13h, if you wanted to draw a pixel at 10,30 using C you'd simply have a pointer that pointed to screen memory, and just use it like any other array
Screen[30*200 + 10] = colour;

But there's a quicker way than 30*200.
It's 30*8 + 30*64 + 30*128. Now, while that may seem like a contradiction, 8, 64 and 128 are all powers of 2, so you can use the bit shift operations to calculate them.
e.g
offset = 30<<3 + 30<<6 + 30<<7;
[EDIT]
should have been:
offset = (30<<3 + 30<<6 + 30<<7) + 10;
[/EDIT]

For clarity's sake I've done the full shift each time, but using the registers, you can simply accumulate the previous result.
This is also unoptimized, for clarity's sake.

e.g

It's more instructions than a simple MUL, but with pipelining taken into account you can run several of them per clock cycle. When I was last playing with ASM (486 era) A mul took many more cycles than that little snippet. Once you've got your index into the array that's screen memory, all you have to do is write a byte to ds:[si], then increment si to point at the next pixel. MUCH quicker than going through the whole operation of calculating an offset for each pixel.