Rotating and scaling are fairly easy to do, as long as you have a firm grasp on linear interpolation. The idea is basically that you simultaneously draw two lines. One line, across the screen, is exactly horizontal (all on the same Y coordinate). The other line traces across the sprite at a different speed and/or angle, which is what achieves the rotation. The trick, then, is to determine what exactly these two lines are.
The basic idea is to store a start and end coordinate for each row on the screen. Many of them will not be used, so you need to initialize them to a value that will be readily identifiable when you go to draw to the screen (perhaps set end X to the left edge of the screen and start X to the right edge, and then check if startX < endX before proceeding for each scan).
Then, you need to apply some trigonometry to get the screen coordinates of each of the 4 corner points of the sprite. This is a fairly short & simple bit of code to write, but if you're not familiar with trigonometry, it can be a daunting task. So, I'll just give it to you:
[tt]
TYPE pt
x
AS INTEGER
y
AS INTEGER
END TYPE
DIM screenPt(1
TO 4)
AS pt
spriteCenterX# = 150
'this can change
spriteCenterY# = 150
'so can this
spriteScaleFactor# = 1
'and this
spriteSize% = 32
'and this
spriteAngle# = Deg2Rad#(37)
'and this
spriteAspect# = 0.8333333#
'this is correct for SCREENs 1, 7 and 13
'Now the actual calculations:
angle# = spriteAngle# + Deg2Rad#(45)
rayLength# = spriteSize% * spriteScaleFactor# *
SQR(2) / 2
FOR i% = 1
TO 4
screenPt(i%).x = spriteCenterX# + rayLength# *
COS(angle#)
screenPt(i%).y = spriteCenterY# - rayLength# *
SIN(angle#) * spriteAspect#
angle# = angle# + 1.570796#
'this is 90 degrees in radians
NEXT i%
FUNCTION Deg2Rad#(degrees#)
Deg2Rad# = degrees# / 57.295779#
END FUNCTION
[/tt]
The help file has a section on calculating the correct aspect ratio for different screen modes, but I can't remember exactly how to get to it
Dig around.
Anyway, now that you have these 4 points, you need to use linear interpolation to connect them. Find the topmost point, and then use some simple facts to draw the right lines into the right endpoints in the previously mentioned scanline buffer.
The output from the code above is in anticlockwise order, so you know that if point 4 is the topmost point, then point 1 will be the one on the left and vertically in the middle and point 3 will be the one on the right and vertically in the middle. Point 2 will be at the bottom. In general, add 1 to the topmost index and wrap around if necessary to get the left point, and subtract 1 & wrap around if necessary to get the right point.
Once you have which lines to draw all sorted out, you then need to use interpolation to place them onto the scanline buffer. Doing this, you will also need to associate each endpoint with the corresponding coordinate in the sprite. I recommend you use better than integer precision to store these coordinates, otherwise you will get jagged edges in the visual result.
Anyway, once you have a list of horizontal lines to draw, along with the starting and ending sprite coordinates, you then apply linear interpolation to each scanline in turn, which tells you what sprite pixel to put onto each screen pixel. This is the simplest of scaling & rotating algorithms, so do not expect stellar results
If you scale up, you will get square sprite pixels, and if you scale down, you will get sparkling (like walls very far away in Doom). It requires obscenely more processing to eliminate these, especially in a video mode with palettized colour, so I recommend you just live with it
It will be a more authentic replica of old console systems anyway.
If you've gotten to this point and understand everything except what exactly linear interpolation is, let me know, and I'll write up an explanation of it for you.
, find a way to emulate this in qbasic. I am a 3d MAX movie maker, not a programmer, I am only doing this for the credits. But hey, it is kinda fun.