I think this is about as fast as it gets for drawing a white square to both buffers. It is not clipped. The code given is for drawing a 6x6 square, but it can be modified to draw a rectangle of any width from 1-9 and any height.

I haven't actually tested this, but hopefully it works. If it does work, it will be very fast. It is faster than drawing a single unaligned sprite to only one buffer.


Lbl CLR
.Clear a 6*6 spot on both buffers
.r₁ is the X coordinate and r₂ is the Y coordinate
Asm(447D85856F29293AA5834FCB39CB39CB390911409319E5E607874F)
([03FF81FFC0FFE07FF03FF81FFC0FFE07])
Asm(095E2356E10606C57EA377237EA277013105097EA377237EA27701D9FA09C110E6)
Return


  ld b,h
  ld a,l
  add a,l
  add a,l
  ld l,a
  add hl,hl
  add hl,hl
  ld a,(axv_r1)
  ld c,a
  srl c
  srl c
  srl c
  add hl,bc
  ld de,plotSScreen
  add hl,de
  push hl
  and %00000111
  add a,a
  ld c,a
  ld hl,$0000        ;Replace with mask LUT
  add hl,bc
  ld e,(hl)
  inc hl
  ld d,(hl)
  pop hl
  ld b,6
DrawLoop:
  push bc
  ld a,(hl)
  and e
  ld (hl),a
  inc hl
  ld a,(hl)
  and d
  ld (hl),a
  ld bc,appBackUpScreen-plotSScreen-1
  add hl,bc
  ld a,(hl)
  and e
  ld (hl),a
  inc hl
  ld a,(hl)
  and d
  ld (hl),a
  ld bc,plotSScreen-appBackUpScreen-1+12
  add hl,bc
  pop bc
  djnz DrawLoop


I found an error and fixed it, try it again? Hopefully it was the last error.

Simple stuff that you probably know already, but I'll post it here anyway.

To round a fixed-point number down (floor function), it's pretty simple. Just mask the first eight bits (· being the 16-bit AND operator):
A·EFF00
To round up (ceiling function), add 255:
A+255·EFF00
These obviously don't work (and don't need to work) on integers, but if you want integer division to round up instead of down, you can do:
A-1/B+1

Polygons:

I made a subroutine that can draw a shaded polygon with an arbitrarily high amount of vertexes.

It can also handle convex and almost handle concave polygons.

You have to designate a segment of memory that contains a list of vertex.  The 0th byte is the X-coordinate of the first vertex, the 1st byte is the Y-coordinate of the first vertex, the 2nd byte is the X-coordinate of the second vertex, etc...  The last pair of vertexes has to be identical to the first pair, to 'close the loop'.

Also, the first (and therefore last) point in the list has to be the left-most or right-most point of the polygon, otherwise it'll look weird.

I made a demo -- source attached, and comments and pic below.
[2ND] to place a vertex, [ALPHA] to display the polygon, and [DEL] to clear the screen.  [CLEAR] exits.

It should be compatible with Axe 0.5.x and 1.0.x

.POLYGON

Fix 5

10->A        .The X coordinate of the vertex selector
10->B        .The Y coordinate of the vertex selector

0->T         .Total amount of vertexes
20->M        .Maximum amount of vertexes (not necessary -- only for sanity checks)

L4->V        .Pointer to the list of Vertexes
L1->C        .Pointer to some free ram (for Calculations)

ClrDraw
ClrDraw^^r

RectI(A-1,B-1,3,3)^^r


Repeat getKey(15)
    RectI(A-1,B-1,3,3)^^r
    getKey(3)-getKey(2)+A->A
    getKey(1)-getKey(4)+B->B
    RectI(A-1,B-1,3,3)^^r
       
    Rect(80,9,40,40)
    RectI(80,9,40,40)

    Text(80,10,A>Dec)
    Text(80,18,B>Dec)
    Text(80,30,T>Dec)
       
    If getKey(54)          .Adds a vertex
        If T<M
            A->{T*2+V}     .The last element in the list must equal the first one.
            B->{T*2+1+V}
            T+1->T
            Pxl-On(A,B)
        End
        For(Z,0,20)        .Delay for usability
            DispGraph^^r
        End
    End

    If getKey(48)          .Draws the polygon
        {V}->{T*2+V}
        {V+1}->{T*2+V+1}
        sub(POL,T,V,C)
        0->T
        For(Z,0,20)
            DispGraph^^r
        End
    End

    If getKey(56)           .Clears the screen
        ClrDraw
        ClrDraw^^r
        RectI(A-1,B-1,3,3)^^r
        0->T
    End

    DispGraph^^r
End

Return


Lbl POL
    .Parameters
    .  r1: The total amount of vertexes
    .  r2: A list of vertexes (pairs of X and Y coordinates, each one byte)
    .  r3: A pointer to some free ram (Amount needed == approx. (max polygon width) * 2)
    .
    .Destroyed
    .  W, X, Y, Z, r3, r4, r5, r6
    .
    r3->W
    For(r4,0,r1-1)
        r4*2+r2->r5
        r4+1*2+r2->r6

        {r5}-{r6}->X
        {r5+1}-{r6+1}->Y
       
        If X>=>=0
            For(Z,0,X)
                {r5}-Z->{r3}
                ~Y*Z//X+{r5+1}->{r3+1}
                r3+2->r3
                M+2->M
            End
        Else
            For(Z,0,abs(X))
                {r5}+Z->{r3}
                Y*Z//X+{r5+1}->{r3+1}
                r3+2->r3
                M+2->M
            End
        End
    End

    For(Z,1,r3-W/2-1)
        Line({Z*2+W},{Z*2+W+1},{Z*2+W},{Z*~2+r3+1})^^r
    End
Return


Could someone make a routine to rotate the screen (or a 64x64 region) 64 (90) degrees?

This is an untested routine for displaying text with newlines in Axe.

:Lbl TXT
:.sub(TXT,Initial X,Initial Y,String)
:r1->r4
:For(I,0,length(r3))
:If {I+r3}->{L1}^r-255
:Text(r1,r2,L1)
:r4+4->r4
:Else
:r2+7->r2
:r1->r4
:End
:End
:Return

Here is a sample usage:

:"TEXT[FF]NEWLINE[FF]ANOTHER LINE"->Str1
:sub(TXT,X,Y,Str1)

They're actually pretty simple. (Let's see if I can find my routine...)

The idea behind it is to shorten the X- and Y-lengths of the line so it's completely within the screen, but keeping them proportional (so the slope Y/X stays the same). For example, if the line runs from (X1,Y1) to (X2,Y2) and X2 is the only out-of-bounds point (say 99), you assign 95 to X2 (within the screen bounds), then move Y2 so the slope stays the same.

Take 95–X1 (which is the horizontal length of the clipped line), divide it by the original horizontal length (in our case, 99–X1), and multiply it by the current vertical length (Y2–Y1), to find the vertical length of the clipped line. Add that to Y1 and you get the new value for Y2. Now that both the points are completely within the screen, you can use Line() to draw the new line.

Ok, I'm confused.  Using the ideas from Deep's post I threw something together:
(S,T)="(X1,Y1)"
(X,Y) are manipulated
(N,O)="(X2,Y2)"
But for some reason, once the manipulable point goes off-screen, the program does something wrong and will only draw horizontal or vertical lines.  I'm suspecting it's rounding down to zero where the division happens, but idk.

After screwing around with it for a bit, I got this:
...and it somewhat* works, I have no idea why but it does.

So um yeah, I guess have a really unoptimized line routine (with other stuff thrown in)!

*watching the screenie, you can tell the endpoint of the line is fixed on the edge, so the slope doesn't change accordingly...?

EDIT: btw it runs a bit slower than it should b/c there's a Pause 20 in there.  It can run faster than in the screenshot.