1726 lines
89 KiB
Plaintext
1726 lines
89 KiB
Plaintext
{{
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// VGA64 Tilemap Engine
|
|
//
|
|
// Author: Kwabena W. Agyeman
|
|
// Updated: 7/27/2010
|
|
// Designed For: P8X32A
|
|
// Version: 1.0
|
|
//
|
|
// Copyright (c) 2010 Kwabena W. Agyeman
|
|
// See end of file for terms of use.
|
|
//
|
|
// Update History:
|
|
//
|
|
// v1.0 - Original release - 7/27/2010.
|
|
//
|
|
// For each included copy of this object only one spin interpreter should access it at a time.
|
|
//
|
|
// Nyamekye,
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Video Circuit:
|
|
//
|
|
// 0 1 2 3 Pin Group
|
|
//
|
|
// 240OHM
|
|
// Pin 0, 8, 16, 24 ----R-------- Vertical Sync
|
|
//
|
|
// 240OHM
|
|
// Pin 1, 9, 17, 25 ----R-------- Horizontal Sync
|
|
//
|
|
// 470OHM
|
|
// Pin 2, 10, 18, 26 ----R-------- Blue Video
|
|
// |
|
|
// 240OHM |
|
|
// Pin 3, 11, 19, 27 ----R-----
|
|
//
|
|
// 470OHM
|
|
// Pin 4, 12, 20, 28 ----R-------- Green Video
|
|
// |
|
|
// 240OHM |
|
|
// Pin 5, 13, 21, 29 ----R-----
|
|
//
|
|
// 470OHM
|
|
// Pin 6, 14, 22, 30 ----R-------- Red Video
|
|
// |
|
|
// 240OHM |
|
|
// Pin 7, 15, 23, 31 ----R-----
|
|
//
|
|
// 5V
|
|
// |
|
|
// --- 5V
|
|
//
|
|
// --- Vertical Sync Ground
|
|
// |
|
|
// GND
|
|
//
|
|
// --- Hoirzontal Sync Ground
|
|
// |
|
|
// GND
|
|
//
|
|
// --- Blue Return
|
|
// |
|
|
// GND
|
|
//
|
|
// --- Green Return
|
|
// |
|
|
// GND
|
|
//
|
|
// --- Red Return
|
|
// |
|
|
// GND
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
}}
|
|
|
|
CON
|
|
|
|
#$FC, Light_Grey, #$A8, Grey, #$54, Dark_Grey
|
|
#$C0, Light_Red, #$80, Red, #$40, Dark_Red
|
|
#$30, Light_Green, #$20, Green, #$10, Dark_Green
|
|
#$0C, Light_Blue, #$08, Blue, #$04, Dark_Blue
|
|
#$F0, Light_Orange, #$A0, Orange, #$50, Dark_Orange
|
|
#$CC, Light_Purple, #$88, Purple, #$44, Dark_Purple
|
|
#$3C, Light_Teal, #$28, Teal, #$14, Dark_Teal
|
|
#$FF, White, #$00, Black
|
|
|
|
#0, Cursor_Left, Cursor_Right, #10, Cursor_Down, Cursor_Up
|
|
'# -1, Focus
|
|
#8, Backspace, Tab, Line_feed, Vertical_Tab, Form_Feed, Carriage_Return
|
|
|
|
VAR
|
|
|
|
byte printRow, printColumn, printBoxFGColor[8], printBoxBGColor[8], printStartRow[8], printStartColumn[8], printEndRow[8], printEndColumn[8]
|
|
byte win
|
|
byte yendwin[8],xendwin[8],yanf[8],xanf[8],cursorx[8],cursory[8]
|
|
word puffer[12]
|
|
long bufferaddress[12]
|
|
{PUB printString(characters) '' 30 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Prints a string to the screen inside of the print box defined by the print settings.
|
|
'' //
|
|
'' // Characters - A pointer to a string of characters to be printed.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
repeat strsize(characters)
|
|
printCharacter(byte[characters++])
|
|
}
|
|
pub printat(y,x)
|
|
printColumn:=x
|
|
printRow:=y
|
|
{pub PlotPixel(color,startColumn,startRow)|punkt
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Displays a Dot on screen.
|
|
'' //
|
|
'' // Color - A color byte (%RR_GG_BB_xx) to use.
|
|
'' // StartRow - The row to start drawing on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // StartColumn - The column to start drawing on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
color := computeFillColor(color)
|
|
drawingStart(startRow, startColumn, startRow, startColumn)
|
|
punkt := (startRow*40)+ startColumn
|
|
chromaBuffer[punkt]:=color
|
|
drawingStop
|
|
}
|
|
pub put(c,x,y)
|
|
|
|
displayCharacter(c, printBoxFGColor[win], printBoxBGColor[win], y, x)
|
|
|
|
pub setx(x)
|
|
printColumn:=x
|
|
|
|
pub sety(y)
|
|
printRow:=y
|
|
|
|
pub getx
|
|
return printColumn
|
|
|
|
pub gety
|
|
return printRow
|
|
|
|
PUB printCharacter(character) '' 26 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Prints a character to the screen inside of the print box defined by the print settings.
|
|
'' //
|
|
'' // 0 - Move the cursor left one space.
|
|
'' // 1 - Move the cursor right one space.
|
|
'' // 8 - Backspace. Move the cursor back one space and delete the character underneath it.
|
|
'' // 9 - Tab. Move the cursor forward eight spaces.
|
|
'' // 10 - Line Feed. Move the cursor down.
|
|
'' // 11 - Vertical Tab. Move the cursor up.
|
|
'' // 12 - Form Feed. Move the cursor back to the start of the print box and clear the print box.
|
|
'' // 13 - Carriage Return. Move the cursor back to the start of the line.
|
|
'' //
|
|
'' // Character - A character to be printed. -1 to focus.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
if(printStartRow[win] =< printEndRow[win])
|
|
if(character <> -1)
|
|
|
|
case character
|
|
4: printColumn :=0
|
|
5: printColumn -= 1
|
|
6: printColumn += 1
|
|
7: printColumn:=0
|
|
printRow:=0
|
|
8:
|
|
printColumn -= 1
|
|
character := " "
|
|
|
|
9: printColumn += (4 - (printColumn & $3))
|
|
10: printRow += 2
|
|
11: printRow -= 2
|
|
|
|
12:
|
|
printRow := printStartRow[win]
|
|
printColumn := printStartColumn[win]
|
|
display2DBox(printBoxBGColor[win], printStartRow[win], printStartColumn[win], printEndRow[win], printEndColumn[win])
|
|
|
|
13: printColumn := printStartColumn[win]
|
|
printRow += 2
|
|
other: result := true
|
|
|
|
if((~printColumn) < printStartColumn[win])
|
|
printColumn := printEndColumn[win]
|
|
printRow -= 2
|
|
|
|
if((~printRow) < printStartRow[win])
|
|
printRow := printStartRow[win]
|
|
scrollDown(2, printBoxBGColor[win], printStartRow[win], printStartColumn[win], printEndRow[win], printEndColumn[win],1)
|
|
|
|
repeat 2
|
|
|
|
if((~printColumn) > printEndColumn[win])
|
|
printColumn := printStartColumn[win]
|
|
printRow += 2
|
|
|
|
if((~printRow) => printEndRow[win])
|
|
printRow := (printEndRow[win] - 1)
|
|
scrollUp(2, printBoxBGColor[win], printStartRow[win], printStartColumn[win], printEndRow[win], printEndColumn[win],1)
|
|
|
|
if(result or (character == " "))
|
|
displayCharacter(character~, printBoxFGColor[win], printBoxBGColor[win], printRow, printColumn)
|
|
|
|
printColumn -= result~
|
|
printPosition := @chromaBuffer[computeIndex(printRow, printColumn)]
|
|
PUB printqChar(character) '' 26 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Prints a character to the screen inside of the print box defined by the print settings.
|
|
'' //
|
|
'' // 0 - Move the cursor left one space.
|
|
'' // 1 - Move the cursor right one space.
|
|
'' // 8 - Backspace. Move the cursor back one space and delete the character underneath it.
|
|
'' // 9 - Tab. Move the cursor forward eight spaces.
|
|
'' // 10 - Line Feed. Move the cursor down.
|
|
'' // 11 - Vertical Tab. Move the cursor up.
|
|
'' // 12 - Form Feed. Move the cursor back to the start of the print box and clear the print box.
|
|
'' // 13 - Carriage Return. Move the cursor back to the start of the line.
|
|
'' //
|
|
'' // Character - A character to be printed. -1 to focus.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
if(printStartRow[win] < printEndRow[win])
|
|
if(character <> -1)
|
|
|
|
result := true
|
|
|
|
if((~printColumn) < printStartColumn[win])
|
|
printColumn := printEndColumn[win]
|
|
printRow -= 2
|
|
|
|
if((~printRow) < printStartRow[win])
|
|
printRow := printStartRow[win]
|
|
scrollDown(2, printBoxBGColor[win], printStartRow[win], printStartColumn[win], printEndRow[win], printEndColumn[win],1)
|
|
|
|
repeat 2
|
|
|
|
if((~printColumn) > printEndColumn[win])
|
|
printColumn := printStartColumn[win]
|
|
printRow += 2
|
|
|
|
if((~printRow) => printEndRow[win])
|
|
printRow := (printEndRow[win] - 1)
|
|
scrollUp(2, printBoxBGColor[win], printStartRow[win], printStartColumn[win], printEndRow[win], printEndColumn[win],1)
|
|
|
|
if(result or (character == " "))
|
|
displayCharacter(character~, printBoxFGColor[win], printBoxBGColor[win], printRow, printColumn)
|
|
|
|
printColumn -= result~
|
|
printPosition := @chromaBuffer[computeIndex(printRow, printColumn)]
|
|
|
|
PUB printBoxColor(fenster,fore, back) '' 5 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Changes the print box colors.
|
|
'' //
|
|
'' // ForegroundColor - A color byte (%RR_GG_BB_xx) for the foreground character color.
|
|
'' // BackgroundColor - A color byte (%RR_GG_BB_xx) for the background character color.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
win:=fenster
|
|
printBoxFGColor[win] := fore
|
|
printBoxBGColor[win] := back
|
|
|
|
PUB printBoxSize(fenster,startRow, startColumn, endRow, endColumn) '' 31 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Changes the print box size and position.
|
|
'' //
|
|
'' // StartRow - The row to start printing on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // StartColumn - The column to start printing on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' // EndRow - The row to end printing on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // EndColumn - The column to end printing on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
win:=fenster
|
|
yendwin[win]:=endrow
|
|
xendwin[win]:=endColumn
|
|
yanf[win]:=startRow
|
|
xanf[win]:=startColumn
|
|
printEndRow[win]:= limitRow(yendwin[win])
|
|
printEndColumn[win] := limitColumn(xendwin[win])
|
|
printStartRow[win] := computeLimit(yanf[win], printEndRow[win])
|
|
printStartColumn[win] := computeLimit(xanf[win], printEndColumn[win])
|
|
'printEndRow += (not((printEndRow - printStartRow) & 1))
|
|
'printCharacter(12)
|
|
printRow := printStartRow[win]
|
|
printColumn := printStartColumn[win]
|
|
display2DBox(printBoxBGColor[win], printStartRow[win], printStartColumn[win], printEndRow[win], printEndColumn[win])
|
|
|
|
pub printwindow(fenster)
|
|
cursorx[win]:=printCursorColumn
|
|
cursory[win]:=printCursorRow
|
|
win:=fenster
|
|
'printEndRow[win]:= limitRow(yendwin[win])
|
|
'printEndColumn[win] := limitColumn(xendwin[win])
|
|
'printStartRow[win] := computeLimit(yanf[win], printEndRow[win])
|
|
'printStartColumn[win] := computeLimit(xanf[win], printEndColumn[win])
|
|
printrow:=cursory[win]'printStartrow
|
|
printcolumn:=cursorx[win]'printStartColumn
|
|
|
|
pub del_win(fenster)
|
|
printStartRow[fenster] :=printStartRow[0]
|
|
printStartColumn[fenster]:=printStartColumn[0]
|
|
printEndRow[fenster] :=printEndRow[0]
|
|
printEndColumn[fenster] :=printEndColumn[0]
|
|
printBoxBGColor[fenster] :=printBoxBGColor[0]
|
|
printBoxFGColor[fenster] :=printBoxFGColor[0]
|
|
cursory[fenster] :=cursory[0]
|
|
cursorx[fenster] :=cursorx[0]
|
|
win:=0
|
|
printwindow(0)
|
|
|
|
PUB printCursorColor(color) '' 8 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Changes the print cursor color.
|
|
'' //
|
|
'' // Color - A color byte (%RR_GG_BB_xx) describing the print cusor color.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
printColor := computeFillColor(color)
|
|
|
|
PUB printCursorRate(rate) '' 8 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Changes the print cursor (blink) rate.
|
|
'' //
|
|
'' // Rate - A blink rate for the print cursor. 0=0Hz, 1=0.46875Hz, 2=0.9375Hz, 3=1.875Hz, 4=3.75Hz, 5=7.5Hz, 6=15Hz, 7=30Hz.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
printRate := ($100 >> computeLimit(rate, 7))
|
|
|
|
PUB printCursorRow '' 3 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Returns the current row the print cursor is on.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
return ~printRow
|
|
|
|
PUB printCursorColumn '' 3 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Returns the current column the print cursor is on.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
return ~printColumn
|
|
|
|
PUB scrollUp(lines, color, startRow, startColumn, endRow, endColumn,rate) '' 24 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Scrolls the contents of whatever is in the specified area up and scrolls in blank space of the selected color.
|
|
'' //
|
|
'' // Color - A color byte (%RR_GG_BB_xx) to use for the background color being scrolled in.
|
|
'' // Lines - Number of rows to scroll up. This function will do nothing if this value is invalid.
|
|
'' // StartRow - The row to start scrolling on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // StartColumn - The column to start scrolling on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' // EndRow - The row to end scrolling on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // EndColumn - The column to end scrolling on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
color := computeFillColor(color)
|
|
endRow := limitRow(endRow)
|
|
endColumn := limitColumn(endColumn)
|
|
startRow := computeLimit(startRow, endRow)
|
|
startColumn := computeLimit(startColumn, endColumn)
|
|
lines := (computeLimit(lines, (endRow - startRow + 1)) * 40)
|
|
|
|
if(lines)
|
|
drawingStart(startRow, startColumn, endRow, endColumn)
|
|
startRow := computeIndex(startRow, startColumn)
|
|
endRow := computeIndex(endRow, startColumn)
|
|
endColumn -= --startColumn
|
|
|
|
if(lines =< (endRow - startRow))
|
|
repeat result from startRow to (endRow - lines) step 40
|
|
wordmove(@lumaBuffer[result], @lumaBuffer[result + lines], endColumn)
|
|
longmove(@chromaBuffer[result], @chromaBuffer[result + lines], endColumn)
|
|
if rate>0
|
|
waitcnt( cnt+=clkfreq / (1000/rate))
|
|
repeat result from (endRow + 40 - lines) to endRow step 40
|
|
longfill(@chromaBuffer[result], color, endColumn)
|
|
if rate >0
|
|
waitcnt( cnt+=clkfreq / (1000/rate))
|
|
drawingStop
|
|
|
|
PUB scrollDown(lines, color, startRow, startColumn, endRow, endColumn,rate) '' 24 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Scrolls the contents of whatever is in the specified area down and scrolls in blank space of the selected color.
|
|
'' //
|
|
'' // Color - A color byte (%RR_GG_BB_xx) to use for the background color being scrolled in.
|
|
'' // Lines - Number of rows to scroll down. This function will do nothing if this value is invalid.
|
|
'' // StartRow - The row to start scrolling on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // StartColumn - The column to start scrolling on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' // EndRow - The row to end scrolling on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // EndColumn - The column to end scrolling on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
color := computeFillColor(color)
|
|
endRow := limitRow(endRow)
|
|
endColumn := limitColumn(endColumn)
|
|
startRow := computeLimit(startRow, endRow)
|
|
startColumn := computeLimit(startColumn, endColumn)
|
|
lines := (computeLimit(lines, (endRow - startRow + 1)) * 40)
|
|
|
|
if(lines)
|
|
drawingStart(startRow, startColumn, endRow, endColumn)
|
|
startRow := computeIndex(startRow, startColumn)
|
|
endRow := computeIndex(endRow, startColumn)
|
|
endColumn -= --startColumn
|
|
|
|
if(lines =< (endRow - startRow))
|
|
repeat result from endRow to (startRow + lines) step 40
|
|
wordmove(@lumaBuffer[result], @lumaBuffer[result - lines], endColumn)
|
|
longmove(@chromaBuffer[result], @chromaBuffer[result - lines], endColumn)
|
|
if rate>0
|
|
waitcnt( cnt+=clkfreq / (1000/rate))
|
|
repeat result from startRow to (startRow - 40 + lines) step 40
|
|
longfill(@chromaBuffer[result], color, endColumn)
|
|
if rate>0
|
|
waitcnt( cnt+=clkfreq / (1000/rate))
|
|
drawingStop
|
|
|
|
PUB display3DTextBox(characters, textColor, topColor, centerColor, bottomColor, row, column) '' 35 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Displays a 3D text box on screen.
|
|
'' //
|
|
'' // Characters - A string to display using the internal ROM font. Each character is 1 tile wide and 2 tiles tall.
|
|
'' // TextColor - Text color byte (%RR_GG_BB_xx) to use.
|
|
'' // TopColor - Top edge and side color byte (%RR_GG_BB_xx) to use.
|
|
'' // CenterColor - Center color byte (%RR_GG_BB_xx) to use.
|
|
'' // BottomColor - Bottom edge and side color byte (%RR_GG_BB_xx) to use.
|
|
'' // Row - Top right corner row of the text box. The box will be 4 rows tall and 2 + string size wide.
|
|
'' // Column - Top right corner column of the text box. The box will be 4 rows tall and 2 + string size wide.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
displayString(characters, textColor, centerColor, ++row, ++column)
|
|
display3DFrame(topColor, centerColor, bottomColor, --row, --column, (row + 3), (++column + strsize(characters)))
|
|
|
|
{PUB display3DpressedTextBox(characters, textColor, topColor, centerColor, bottomColor, row, column) '' 35 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Displays a 3D text box on screen.
|
|
'' //
|
|
'' // Characters - A string to display using the internal ROM font. Each character is 1 tile wide and 2 tiles tall.
|
|
'' // TextColor - Text color byte (%RR_GG_BB_xx) to use.
|
|
'' // TopColor - Top edge and side color byte (%RR_GG_BB_xx) to use.
|
|
'' // CenterColor - Center color byte (%RR_GG_BB_xx) to use.
|
|
'' // BottomColor - Bottom edge and side color byte (%RR_GG_BB_xx) to use.
|
|
'' // Row - Top right corner row of the text box. The box will be 4 rows tall and 2 + string size wide.
|
|
'' // Column - Top right corner column of the text box. The box will be 4 rows tall and 2 + string size wide.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
displayString(characters, textColor, centerColor, ++row, ++column)
|
|
display3DFrame(topColor, centerColor, bottomColor, --row, --column, (row + 3), (++column + strsize(characters)))
|
|
}
|
|
'PUB display2DTextBox(characters, forgroundColor, backgroundColor, row, column) '' 31 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Displays a 2D text box on screen.
|
|
'' //
|
|
'' // Characters - A string to display using the internal ROM font. Each character is 1 tile wide and 2 tiles tall.
|
|
'' // ForegroundColor - The color to use for the foreground of the text box.
|
|
'' // BackgroundColor - The color to use for the background of the text box.
|
|
'' // Row - Top right corner row of the text box. The box will be 4 rows tall and 2 + string size wide.
|
|
'' // Column - Top right corner column of the text box. The box will be 4 rows tall and 2 + string size wide.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
' displayString(characters, forgroundColor, backgroundColor, ++row, ++column)
|
|
' display2DFrame(backgroundColor, --row, --column, (row + 3), (++column + strsize(characters)))
|
|
|
|
PUB display3DBox(topColor, centerColor, bottomColor, startRow, startColumn, endRow, endColumn) '' 35 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Displays a 3D box on screen.
|
|
'' //
|
|
'' // TopColor - Top edge and side color byte (%RR_GG_BB_xx) to use.
|
|
'' // CenterColor - Center color byte (%RR_GG_BB_xx) to use.
|
|
'' // BottomColor - Bottom edge and side color byte (%RR_GG_BB_xx) to use.
|
|
'' // StartRow - The row to start drawing on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // StartColumn - The column to start drawing on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' // EndRow - The row to end drawing on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // EndColumn - The column to end drawing on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
display2DBox(centerColor, startRow, startColumn, endRow, endColumn)
|
|
display3DFrame(topColor, centerColor, bottomColor, startRow, startColumn, endRow, endColumn)
|
|
|
|
PUB display3DFrame(topColor, centerColor, bottomColor, startRow, startColumn, endRow, endColumn) '' 25 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Displays a 3D frame on screen.
|
|
'' //
|
|
'' // TopColor - Top edge and side color byte (%RR_GG_BB_xx) to use.
|
|
'' // CenterColor - Center color byte (%RR_GG_BB_xx) to use.
|
|
'' // BottomColor - Bottom edge and side color byte (%RR_GG_BB_xx) to use.
|
|
'' // StartRow - The row to start drawing on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // StartColumn - The column to start drawing on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' // EndRow - The row to end drawing on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // EndColumn - The column to end drawing on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
centerColor := computeTileColor(centerColor, bottomColor, topColor)
|
|
endRow := limitRow(endRow)
|
|
endColumn := limitColumn(endColumn)
|
|
startRow := computeLimit(startRow, endRow)
|
|
startColumn := computeLimit(startColumn, endColumn)
|
|
drawingStart(startRow, startColumn, endRow, endColumn)
|
|
|
|
startRow := computeIndex(startRow, startColumn)
|
|
endRow := computeIndex(endRow, startColumn)
|
|
endColumn -= startColumn
|
|
|
|
longfill(@chromaBuffer[startRow], centerColor, ++endColumn)
|
|
wordfill(@lumaBuffer[startRow], $83_00, endColumn)
|
|
longfill(@chromaBuffer[endRow], centerColor, endColumn)
|
|
wordfill(@lumaBuffer[endRow], $83_40, endColumn--)
|
|
|
|
repeat result from startRow to endRow step 40
|
|
lumaBuffer[result] := $82_80
|
|
chromaBuffer[result] := centerColor
|
|
lumaBuffer[result + endColumn] := $82_C0
|
|
chromaBuffer[result + endColumn] := centerColor
|
|
|
|
lumaBuffer[endRow] := $80_40
|
|
lumaBuffer[endRow + endColumn] := $82_40
|
|
lumaBuffer[startRow] := $80_00
|
|
lumaBuffer[startRow + endColumn] := $82_00
|
|
|
|
drawingStop
|
|
pub plot(color,row,column)
|
|
color := computeFillColor(color)
|
|
longfill(@chromaBuffer[(row*40)+column], color, 1)
|
|
|
|
PUB display2DBox(color, startRow, startColumn, endRow, endColumn) '' 23 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Displays a 2D box on screen.
|
|
'' //
|
|
'' // Color - A color byte (%RR_GG_BB_xx) to use.
|
|
'' // StartRow - The row to start drawing on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // StartColumn - The column to start drawing on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' // EndRow - The row to end drawing on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // EndColumn - The column to end drawing on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
color := computeFillColor(color)
|
|
endRow := limitRow(endRow)
|
|
endColumn := limitColumn(endColumn)
|
|
startRow := computeLimit(startRow, endRow)
|
|
startColumn := computeLimit(startColumn, endColumn)
|
|
drawingStart(startRow, startColumn, endRow, endColumn)
|
|
|
|
startRow := computeIndex(startRow, startColumn)
|
|
endRow := computeIndex(endRow, startColumn)
|
|
endColumn -= --startColumn
|
|
|
|
repeat result from startRow to endRow step 40
|
|
longfill(@chromaBuffer[result], color, endColumn)
|
|
wordfill(@lumabuffer[result],32,endcolumn) 'Ergänzung um BS-Speicher zu löschen -> für Tileabfragen
|
|
drawingStop
|
|
|
|
'PUB display2DFrame(color, startRow, startColumn, endRow, endColumn) '' 23 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Displays a 2D frame on screen.
|
|
'' //
|
|
'' // Color - A color byte (%RR_GG_BB_xx) to use.
|
|
'' // StartRow - The row to start drawing on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // StartColumn - The column to start drawing on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' // EndRow - The row to end drawing on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // EndColumn - The column to end drawing on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
' color := computeFillColor(color)
|
|
' endRow := limitRow(endRow)
|
|
' endColumn := limitColumn(endColumn)
|
|
' startRow := computeLimit(startRow, endRow)
|
|
' startColumn := computeLimit(startColumn, endColumn)
|
|
' drawingStart(startRow, startColumn, endRow, endColumn)
|
|
|
|
' startRow := computeIndex(startRow, startColumn)
|
|
' endRow := computeIndex(endRow, startColumn)
|
|
' endColumn -= startColumn
|
|
|
|
' longfill(@chromaBuffer[startRow], color, ++endColumn)
|
|
' longfill(@chromaBuffer[endRow], color, endColumn--)
|
|
' repeat result from startRow to endRow step 40
|
|
' chromaBuffer[result] := color
|
|
' chromaBuffer[result + endColumn] := color
|
|
|
|
' drawingStop
|
|
Pub Change_Backup(tilenr,f1,f2,f3)
|
|
puffer[9]:=tilenr
|
|
BufferAddress[9]:=computeTileColor(f1, f2, f3)
|
|
|
|
PUB dispBackup(startRow, startColumn,wordBufferAddress)', longBufferAddress) '' 24 Stack Longs
|
|
'original displayBackup(startRow, startColumn,endRow, endColumn, wordBufferAddress, longBufferAddress)
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Backups a section of the screen to the provided buffers.
|
|
'' //
|
|
'' // The word buffer contains the 16 bit addresses of the backedup tiles.
|
|
'' //
|
|
'' // The word buffer should be ((endRow - startRow + 1) * (endColumn - startColumn + 1)) words in size.
|
|
'' //
|
|
'' // The long buffer contains the 32 bit colors of the backedup tiles. (4 Colors Per Tile - 1 Bytes Per Color).
|
|
'' //
|
|
'' // The long buffer should be ((endRow - startRow + 1) * (endColumn - startColumn + 1)) longs in size.
|
|
'' //
|
|
'' // StartRow - The row to start on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // StartColumn - The column to start on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' // EndRow - The row to end on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // EndColumn - The column to end on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
puffer[wordBufferAddress]:= lumaBuffer[(startrow*40)+(startcolumn)]
|
|
BufferAddress[wordBufferAddress]:= chromaBuffer[(startrow*40)+startcolumn]
|
|
|
|
pub getblock(nummer)
|
|
return lumaBuffer[nummer]
|
|
|
|
PUB dispRestore(startRow, startColumn,wordBufferAddress)' '' 24 Stack Longs
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Restores a section of the screen from the provided buffers.
|
|
'' //
|
|
'' // The word buffer contains the 16 bit addresses of the restored tiles.
|
|
'' //
|
|
'' // The word buffer should be ((endRow - startRow + 1) * (endColumn - startColumn + 1)) words in size.
|
|
'' //
|
|
'' // The long buffer contains the 32 bit colors of the restored tiles. (4 Colors Per Tile - 1 Bytes Per Color).
|
|
'' //
|
|
'' // The long buffer should be ((endRow - startRow + 1) * (endColumn - startColumn + 1)) longs in size.
|
|
'' //
|
|
'' // StartRow - The row to start on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // StartColumn - The column to start on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' // EndRow - The row to end on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // EndColumn - The column to end on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
lumaBuffer[(startrow*40)+startcolumn]:=puffer[wordBufferAddress]
|
|
chromaBuffer[(startrow*40)+startcolumn]:=BufferAddress[wordBufferaddress]
|
|
|
|
pub Backup_luma(x,y):wert
|
|
wert:=lumaBuffer[(y*40)+x]
|
|
|
|
pub backup_chroma(x,y):wert
|
|
wert:=chromaBuffer[(y*40)+x]
|
|
|
|
pub restore_luma(x,y,wert)
|
|
lumaBuffer[(y*40)+x]:=wert
|
|
pub restore_chroma(x,y,wert)
|
|
chromaBuffer[(y*40)+x]:=wert
|
|
PUB displayBackup(startRow, startColumn,endRow, endColumn, wordBufferAddress, longBufferAddress)', longBufferAddress) '' 24 Stack Longs
|
|
'original displayBackup(startRow, startColumn,endRow, endColumn, wordBufferAddress, longBufferAddress)
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Backups a section of the screen to the provided buffers.
|
|
'' //
|
|
'' // The word buffer contains the 16 bit addresses of the backedup tiles.
|
|
'' //
|
|
'' // The word buffer should be ((endRow - startRow + 1) * (endColumn - startColumn + 1)) words in size.
|
|
'' //
|
|
'' // The long buffer contains the 32 bit colors of the backedup tiles. (4 Colors Per Tile - 1 Bytes Per Color).
|
|
'' //
|
|
'' // The long buffer should be ((endRow - startRow + 1) * (endColumn - startColumn + 1)) longs in size.
|
|
'' //
|
|
'' // StartRow - The row to start on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // StartColumn - The column to start on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' // EndRow - The row to end on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // EndColumn - The column to end on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
endRow := limitRow(endRow)
|
|
endColumn := limitColumn(endColumn)
|
|
startRow := computeLimit(startRow, endRow)
|
|
startColumn := computeLimit(startColumn, endColumn)
|
|
drawingStart(startRow, startColumn, endRow, endColumn)
|
|
|
|
startRow := computeIndex(startRow, startColumn)
|
|
endRow := computeIndex(endRow, startColumn)
|
|
endColumn -= --startColumn
|
|
|
|
repeat result from startRow to endRow step 40
|
|
wordmove(wordBufferAddress, @lumaBuffer[result], endColumn)
|
|
wordBufferAddress += (endColumn << 1)
|
|
longmove(longBufferAddress, @chromaBuffer[result], endColumn)
|
|
longBufferAddress += (endColumn << 2)
|
|
|
|
drawingStop
|
|
PUB displayRestore(startRow, startColumn,endRow, endColumn, wordBufferAddress, longBufferAddress)' '' 24 Stack Longs
|
|
'original displayRestore(startRow, startColumn,endRow, endColumn, wordBufferAddress, longBufferAddress)
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Restores a section of the screen from the provided buffers.
|
|
'' //
|
|
'' // The word buffer contains the 16 bit addresses of the restored tiles.
|
|
'' //
|
|
'' // The word buffer should be ((endRow - startRow + 1) * (endColumn - startColumn + 1)) words in size.
|
|
'' //
|
|
'' // The long buffer contains the 32 bit colors of the restored tiles. (4 Colors Per Tile - 1 Bytes Per Color).
|
|
'' //
|
|
'' // The long buffer should be ((endRow - startRow + 1) * (endColumn - startColumn + 1)) longs in size.
|
|
'' //
|
|
'' // StartRow - The row to start on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // StartColumn - The column to start on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' // EndRow - The row to end on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // EndColumn - The column to end on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
endRow := limitRow(endRow)
|
|
endColumn := limitColumn(endColumn)
|
|
startRow := computeLimit(startRow, endRow)
|
|
startColumn := computeLimit(startColumn, endColumn)
|
|
drawingStart(startRow, startColumn, endRow, endColumn)
|
|
|
|
startRow := computeIndex(startRow, startColumn)
|
|
endRow := computeIndex(endRow, startColumn)
|
|
endColumn -= --startColumn
|
|
|
|
repeat result from startRow to endRow step 40
|
|
wordmove(@lumaBuffer[result], wordBufferAddress, endColumn)
|
|
wordBufferAddress += (endColumn << 1)
|
|
longmove(@chromaBuffer[result], longBufferAddress, endColumn)
|
|
longBufferAddress += (endColumn << 2)
|
|
|
|
drawingStop
|
|
|
|
PUB scrollString(characters, characterRate, foregroundColor, backgroundColor, row, startColumn, endColumn) '' 34 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Scrolls a string of characters from right to left across a specified area. Will not display box characters.
|
|
'' //
|
|
'' // Characters - A string to display using the internal ROM font. Each character is 1 tile wide and 2 tiles tall.
|
|
'' // CharacterRate - The number of frames to wait before scrolling out the next character. 0=16.66ms, 1=33.33ms, 2=50ms, etc.
|
|
'' // ForegroundColor - The color to use for the foreground of the string.
|
|
'' // BackgroundColor - The color to use for the background of the string.
|
|
'' // Row - Row to scroll the string on, row 29 is not valid to use. Each row is 16 pixels tall. (0 - 29).
|
|
'' // StartColumn - Column to scroll the string to. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' // EndColumn - Column to scroll the string from. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
endColumn := limitColumn(endColumn)
|
|
startColumn := computeLimit(startColumn, endColumn)
|
|
repeat (strsize(characters) + (endColumn - startColumn) + 1)
|
|
|
|
result := " "
|
|
if(byte[characters])
|
|
result := byte[characters++]
|
|
|
|
displayWait(characterRate)
|
|
scrollCharacter(result, foregroundColor, backgroundColor, row, startColumn, endColumn)
|
|
|
|
PUB scrollCharacter(character, foregroundColor, backgroundColor, row, startColumn, endColumn) '' 24 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Scrolls a character from right to left across a specified area. Will not display box characters.
|
|
'' //
|
|
'' // Character - A character to display using the internal ROM font. Each character is 1 tile wide and 2 tiles tall.
|
|
'' // ForegroundColor - The color to use for the foreground of the character.
|
|
'' // BackgroundColor - The color to use for the background of the character.
|
|
'' // Row - Row to scroll the string on, row 29 is not valid to use. Each row is 16 pixels tall. (0 - 29).
|
|
'' // StartColumn - Column to scroll the string to. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' // EndColumn - Column to scroll the string from. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
endColumn := limitColumn(endColumn)
|
|
startColumn := computeLimit(startColumn, endColumn)
|
|
row := computeLimit(row, 28)
|
|
|
|
result := computeIndex(row, startColumn)
|
|
startColumn := (endColumn - startColumn)
|
|
drawingStart(row, startColumn, row + 1, endColumn)
|
|
|
|
repeat 2
|
|
wordmove(@lumaBuffer[result], @lumaBuffer[++result], startColumn)
|
|
longmove(@chromaBuffer[--result], @chromaBuffer[++result], startColumn)
|
|
result += 39
|
|
|
|
drawingStop
|
|
displayCharacter(character, foregroundColor, backgroundColor, row, endColumn)
|
|
|
|
PUB displayString(characters, foregroundColor, backgroundColor, row, column) '' 21 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Displays a string of characters starting at the specified column on the specified row. Will not display box characters.
|
|
'' //
|
|
'' // Characters - A string to display using the internal ROM font. Each character is 1 tile wide and 2 tiles tall.
|
|
'' // ForegroundColor - The color to use for the foreground of the string.
|
|
'' // BackgroundColor - The color to use for the background of the string.
|
|
'' // Row - Row to display the string on, row 29 is not valid to use. Each row is 16 pixels tall. (0 - 29).
|
|
'' // Column - Column to start displaying the string on. Each column is 16 pixels wide. (0 - 39).
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
column #>= 0
|
|
repeat while(byte[characters] and (column =< 39))
|
|
displayCharacter(byte[characters++], foregroundColor, backgroundColor, row, column++)
|
|
|
|
PUB displayCharacter(character, foregroundColor, backgroundColor, row, column) '' 13 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Displays a character at the specified column on the specified row. Will not display box characters.
|
|
'' //
|
|
'' // Character - A character to display using the internal ROM font. Each character is 1 tile wide and 2 tiles tall.
|
|
'' // ForegroundColor - The color to use for the foreground of the character.
|
|
'' // BackgroundColor - The color to use for the background of the character.
|
|
'' // Row - Row to display the string on, row 29 is not valid to use. Each row is 16 pixels tall. (0 - 29).
|
|
'' // Column - Column to start displaying the string on. Each column is 16 pixels wide. (0 - 39).
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
if((character =< 1) or ((8 =< character) and (character =< 13)) or (256 =< character))
|
|
character := " "
|
|
|
|
result := (character & 1)
|
|
backgroundColor.byte[1 + result] := foregroundColor
|
|
backgroundColor.byte[2 - result] := backgroundColor
|
|
backgroundColor.byte[3] := foregroundColor
|
|
character := (((character >> 1) << 7) + $80_00) '$8000 ist der Ort, wo der Propeller-Font steht
|
|
result := computeIndex(computeLimit(row, 28), limitColumn(column))
|
|
|
|
repeat while(lockset(lockNumber - 1))
|
|
|
|
repeat 2
|
|
lumaBuffer[result] := character
|
|
chromaBuffer[result] := backgroundColor
|
|
result += 40
|
|
character += $40
|
|
|
|
lockclr(lockNumber - 1)
|
|
|
|
|
|
PUB displayTile(address, primaryColor, secondaryColor, tertiaryColor, row, column) '' 15 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Displays a standard three colored tile.
|
|
'' //
|
|
'' // A tile should be formated in this way, example below:
|
|
'' //
|
|
'' // address long %%1111111111111112
|
|
'' // long %%1111111111111122
|
|
'' // long %%1111111111111232
|
|
'' // long %%1111111111112332
|
|
'' // long %%1111111111123332
|
|
'' // long %%1111111111233332
|
|
'' // long %%1111111112333332
|
|
'' // long %%1111111123333332
|
|
'' // long %%1111111233333332
|
|
'' // long %%1111112333333332
|
|
'' // long %%1111123333333332
|
|
'' // long %%1111222222223332
|
|
'' // long %%1111111111112332
|
|
'' // long %%1111111111111232
|
|
'' // long %%1111111111111122
|
|
'' // long %%1111111111111112
|
|
'' //
|
|
'' // The tile image should be reversed to display properly.
|
|
'' //
|
|
'' // The address of the first long is the address of the mouse tile.
|
|
'' //
|
|
'' // Each tile has has 16 longs and each long has 16 pixels. Each pixel has a value of 1 - 3 using quaternary encoding.
|
|
'' //
|
|
'' // A pixel of 0 maps to nothing and a pixel of 1, 2, or 3 maps to the color byte (%RR_GG_BB_xx).
|
|
'' //
|
|
'' // Address - The address of the tile to display.
|
|
'' // PrimaryColor - The color mapping to pixels that have a value of 1 in quaternary.
|
|
'' // SecondaryColor - The color mapping to pixels that have a value of 2 in quaternary.
|
|
'' // TertiaryColor - The color mapping to pixels that have a value of 3 in quaternary.
|
|
'' // Row - The row to display the tile on. Each row is 16 pixels tall so there are 30 rows numbered 0 - 29.
|
|
'' // Column - The column to display the tile on. Each column is 16 pixels wide so there are 40 columns numbered 0 - 39.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
result := computeIndex(limitRow(row), limitColumn(column))
|
|
repeat while(lockset(lockNumber - 1))
|
|
lumaBuffer[result] := address
|
|
chromaBuffer[result] := computeTileColor(primaryColor, secondaryColor, tertiaryColor)
|
|
lockclr(lockNumber - 1)
|
|
|
|
PUB displayCursor '' 3 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Returns the address of the standard mouse cursor tile.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
return @mousePointer
|
|
|
|
PUB mouseCursorTile(address) '' 4 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Changes the mouse cursor tile.
|
|
'' //
|
|
'' // A mouse cusor tile should be formated in this way, example below:
|
|
'' //
|
|
'' // address long %%0000000000000003
|
|
'' // long %%0000000000000033
|
|
'' // long %%0000000000000333
|
|
'' // long %%0000000000003333
|
|
'' // long %%0000000000033333
|
|
'' // long %%0000000000333333
|
|
'' // long %%0000000003333333
|
|
'' // long %%0000000033333333
|
|
'' // long %%0000000333333333
|
|
'' // long %%0000003333333333
|
|
'' // long %%0000033333333333
|
|
'' // long %%0000333333333333
|
|
'' // long %%0000000000003333
|
|
'' // long %%0000000000000333
|
|
'' // long %%0000000000000033
|
|
'' // long %%0000000000000003
|
|
'' //
|
|
'' // The tile image should be reversed to display properly.
|
|
'' //
|
|
'' // The address of the first long is the address of the mouse tile.
|
|
'' //
|
|
'' // Each tile has has 16 longs and each long has 16 pixels. Each pixel has a value of 0 - 3 using quaternary encoding.
|
|
'' //
|
|
'' // A pixel of 0 maps to nothing and a pixel of 1, 2, or 3 maps to the color byte (%RR_GG_BB_xx).
|
|
'' //
|
|
'' // Address - The address of the tile to display, null to disable.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mouseLuma := address
|
|
if address>0
|
|
longmove(@mousepointer,address,16) 'neuen Mauszeiger verwenden
|
|
PUB mouseCursorColor(color) '' 4 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Changes the mouse cursor color.
|
|
'' //
|
|
'' // Color - A color byte (%RR_GG_BB_xx) describing the mouse cursor color.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
mouseChroma := color
|
|
|
|
PUB mouseRowBounds(startRow, endRow) '' 8 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Returns true if the mouse is on or between the two provided rows and false if not.
|
|
'' //
|
|
'' // StartRow - The row to check to see if the mouse is on or after.
|
|
'' // EndRow - The row to check to see if the mouse is on or before.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
result := mouseTileRow
|
|
return ((startRow =< result) and (result =< endRow))
|
|
|
|
PUB mouseColumnBounds(startColumn, endColumn) '' 8 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Returns true if the mouse is on or between the two provided columns and false if not.
|
|
'' //
|
|
'' // StartColumn - The column to check to see if the mouse is on or after.
|
|
'' // EndColumn - The column to check to see if the mouse is on or before.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
result := mouseTileColumn
|
|
return ((startColumn =< result) and (result =< endColumn))
|
|
|
|
PUB mouseTileRow '' 3 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Return the current row the mouse is on.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
return (word[mouseYAddress] >> 4)
|
|
|
|
PUB mouseTileRowOffset '' 3 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Return pixel offset from the current row the mouse is on.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
return (word[mouseYAddress] & $F)
|
|
|
|
PUB mouseTileColumn '' 3 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Return the current column the mouse is on.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
return (word[mouseXAddress] >> 4)
|
|
|
|
PUB mouseTileColumnOffset '' 3 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Return pixel offset from the current column the mouse is on.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
return (word[mouseXAddress] & $F)
|
|
|
|
PUB displayState(state) '' 4 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Enables or disables the TMP Driver's video output - turning the monitor off or putting it into standby mode.
|
|
'' //
|
|
'' // State - True for active and false for inactive.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
displayIndicator := state
|
|
|
|
'PUB displayRate(rate) '' 8 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Returns true or false depending on the time elasped according to a specified rate.
|
|
'' //
|
|
'' // Rate - A display rate to return at. 0=0.234375Hz, 1=0.46875Hz, 2=0.9375Hz, 3=1.875Hz, 4=3.75Hz, 5=7.5Hz, 6=15Hz, 7=30Hz.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
' result or= (($80 >> computeLimit(rate, 7)) & syncIndicator)
|
|
|
|
PUB displayWait(frames) '' 4 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Waits for the display vertical refresh.
|
|
'' //
|
|
'' // Frames - Number of vertical refresh frames to wait for.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
repeat (frames #> 0)
|
|
result := syncIndicator
|
|
repeat until(result <> syncIndicator)
|
|
|
|
'PUB displayColor(redAmount, greenAmount, blueAmount) '' 6 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Builds a color byte (%RR_GG_BB_xx) from red, green, and blue componets.
|
|
'' //
|
|
'' // RedAmount - The amount of red to add to the color byte. Between 0 and 3.
|
|
'' // GreenAmount - The amount of green to add to the color byte. Between 0 and 3.
|
|
'' // BlueAmount - The amount of blue to add to the color byte. Between 0 and 3.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
' return ( (computeLimit(redAmount, 3) << 6) | (computeLimit(greenAmount, 3) << 4) | (computeLimit(blueAmount, 3) << 2) | $3)
|
|
|
|
PUB TMPEngineStart(pinGroup, axisXAddress, axisYAddress) '' 9 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Starts up the TMP driver running on a cog and checks out a lock for the driver.
|
|
'' //
|
|
'' // Returns true on success and false on failure.
|
|
'' //
|
|
'' // PinGroup - Pin group to use to drive the video circuit. Between 0 and 3.
|
|
'' // AxisXAddress - Address of the mouse x axis position variable. Must be a word address and not zero.
|
|
'' // AxisYAddress - Address of the mouse y axis position variable. Must be a word address and not zero.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
TMPEngineStop
|
|
|
|
pinGroup := ((pinGroup <# 3) #> 0)
|
|
directionState := ($FF << (8 * pinGroup))
|
|
videoState := ($30_00_00_FF | (pinGroup << 9))
|
|
pinGroup := constant((25_175_000 + 1_600) / 4)
|
|
frequencyState := 1
|
|
|
|
repeat 32
|
|
pinGroup <<= 1
|
|
frequencyState <-= 1
|
|
if(pinGroup => clkfreq)
|
|
pinGroup -= clkfreq
|
|
frequencyState += 1
|
|
|
|
mouseXAddress := axisXAddress
|
|
mouseYAddress := axisYAddress
|
|
chromaBufferAddress := @chromaBuffer
|
|
lumaBufferAddress := @lumaBuffer
|
|
printColorAddress := @printColor
|
|
printPositionAddress := @printPosition
|
|
printRateAddress := @printRate
|
|
mouseChromaAddress := @mouseChroma
|
|
mouseLumaAddress := @mouseLuma
|
|
displayIndicatorAddress := @displayIndicator
|
|
syncIndicatorAddress := @syncIndicator
|
|
|
|
lockNumber := locknew
|
|
cogNumber := cognew(@initialization, @mouseCache)
|
|
if((++lockNumber) and (++cogNumber) and (chipver == 1) and axisXAddress and axisYAddress)
|
|
return true
|
|
|
|
TMPEngineStop
|
|
|
|
PUB TMPEngineStop '' 3 Stack Longs
|
|
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
'' // Shuts down the TMP driver running on a cog and returns the lock used by the driver.
|
|
'' ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
if(cogNumber)
|
|
cogstop(-1 + cogNumber~)
|
|
|
|
if(lockNumber)
|
|
lockret(-1 + lockNumber~)
|
|
|
|
PRI limitRow(row) ' 4 Stack Longs
|
|
|
|
return ((row <# 29) #> 0)
|
|
|
|
PRI limitColumn(column) ' 4 Stack Longs
|
|
|
|
return ((column <# 39) #> 0)
|
|
|
|
PRI computeFillColor(color) ' 4 Stack Longs
|
|
|
|
repeat 3
|
|
color.byte[++result] := color
|
|
|
|
return color
|
|
|
|
Pub computeTileColor(primaryColor, secondaryColor, tertiaryColor) ' 6 Stack Longs
|
|
|
|
primaryColor.byte[1] := primaryColor
|
|
primaryColor.byte[2] := secondaryColor
|
|
primaryColor.byte[3] := tertiaryColor
|
|
return primaryColor
|
|
|
|
PRI computeLimit(value, limit) ' 5 Stack Longs
|
|
|
|
return ((value <# limit) #> 0)
|
|
|
|
PRI computeIndex(row, column) ' 5 Stack Longs
|
|
|
|
return ((row * 40) + column)
|
|
|
|
PRI drawingStart(startRow, startColumn, endRow, endColumn) ' 15 Stack Longs
|
|
|
|
repeat while(lockset(lockNumber - 1))
|
|
|
|
if(mouseRowBounds((startRow - 2), endRow) and mouseColumnBounds((startColumn - 2), endColumn))
|
|
mouseLumaBackup := mouseLuma~
|
|
|
|
displayWait(1)
|
|
|
|
PRI drawingStop ' 3 Stack Longs
|
|
|
|
if(mouseLumaBackup)
|
|
mouseLuma := mouseLumaBackup~
|
|
|
|
lockclr(lockNumber - 1)
|
|
|
|
DAT
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' TMP Driver
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
org
|
|
|
|
' //////////////////////Initialization/////////////////////////////////////////////////////////////////////////////////////////
|
|
'chromaBuffer
|
|
initialization mov vcfg, videoState ' Setup video hardware.
|
|
mov frqa, frequencyState '
|
|
movi ctra, #%0_00001_101 '
|
|
|
|
mov mouseAddCaches, par ' Setup mouse buffer.
|
|
mov mouseAddCaches + 1, par '
|
|
mov mouseAddCaches + 2, par '
|
|
mov mouseAddCaches + 3, par '
|
|
add mouseAddCaches + 1, #128 '
|
|
add mouseAddCaches + 2, #64 '
|
|
add mouseAddCaches + 3, #192 '
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Active Video
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
loop mov tilesCounter, #30 ' Set/Reset tiles fill counter.
|
|
|
|
tilesDisplay mov tileCounter, #16 ' Set/Reset tile fill counter.
|
|
mov activeCounter, #0 '
|
|
|
|
test tilesCounter, #1 wc ' Set/Reset invisible video.
|
|
if_c movd lumaCacheUpdate, #lumaCache '
|
|
if_c movd chromaCacheUpdate, #chromaCache '
|
|
if_nc movd lumaCacheUpdate, #lumaCache + 40 '
|
|
if_nc movd chromaCacheUpdate, #chromaCache + 40 '
|
|
|
|
tileDisplay mov vscl, visibleScale ' Set/Reset the video scale.
|
|
mov counter, #40 '
|
|
|
|
test tilesCounter, #1 wc ' Set/Reset visible video.
|
|
if_nc movs lumaUpdate, #lumaCache '
|
|
if_nc movd chromaUpdate, #chromaCache '
|
|
if_c movs lumaUpdate, #lumaCache + 40 '
|
|
if_c movd chromaUpdate, #chromaCache + 40 '
|
|
|
|
' //////////////////////Visible Video//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
lumaUpdate mov buffer, 0 ' Update display pixles.
|
|
add lumaUpdate, #1 '
|
|
|
|
add buffer, activeCounter ' Add in offset and get pixels.
|
|
rdlong buffer, buffer '
|
|
|
|
chromaUpdate waitvid 0, buffer ' Update display colors.
|
|
add chromaUpdate, destinationIncrement '
|
|
|
|
djnz counter, #lumaUpdate ' Repeat.
|
|
|
|
' //////////////////////Invisible Video////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mov vscl, invisibleScale ' Set/Reset the video scale.
|
|
add activeCounter, #4 '
|
|
|
|
waitvid HSyncColors, syncPixels ' Horizontal sync.
|
|
|
|
mov inactiveCounter, #3 ' Update the cache.
|
|
cmp tileCounter, #3 wc, wz '
|
|
if_z mov inactiveCounter, #1 '
|
|
if_nc call #cacheUpdate '
|
|
|
|
' //////////////////////Repeat/////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
djnz tileCounter, #tileDisplay ' Repeat.
|
|
djnz tilesCounter, #tilesDisplay '
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Inactive Video
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mov mousePC, #displayMouse ' Setup display and mouse PC.
|
|
|
|
' //////////////////////Update Cursor//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
rdword printTopPlace, printPositionAddress ' Update print cursor places.
|
|
mov printBottomPlace, printTopPlace '
|
|
add printBottomPlace, #160 '
|
|
|
|
rdlong printColorControl, printColorAddress ' Update print cursor settings.
|
|
rdbyte printRateControl, printRateAddress '
|
|
|
|
add refreshCounter, #1 ' Update sync indicator.
|
|
wrbyte refreshCounter, syncIndicatorAddress '
|
|
|
|
' //////////////////////Set/Reset Cache Pointers///////////////////////////////////////////////////////////////////////////////
|
|
|
|
mov displayCounter, #4 ' Reset loader.
|
|
movs loadCheck, #mouseAddresses '
|
|
movs loadPixels, #mouseAddCaches '
|
|
movs loadColors, #mouseAddColors '
|
|
|
|
movd lumaCacheUpdate, #lumaCache ' Setup to update the cache.
|
|
movd chromaCacheUpdate, #chromaCache '
|
|
mov lumaPointer, lumaBufferAddress '
|
|
mov chromaPointer, chromaBufferAddress '
|
|
|
|
' //////////////////////Front Porch////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mov counter, #11 ' Set loop counter.
|
|
|
|
frontPorch mov vscl, blankPixels ' Invisible lines.
|
|
waitvid HSyncColors, #0 '
|
|
|
|
jmpret displayPC, mousePC ' Do mouse stuff.
|
|
|
|
mov vscl, invisibleScale ' Horizontal sync.
|
|
waitvid HSyncColors, syncPixels '
|
|
|
|
jmpret displayPC, mousePC ' Do mouse stuff.
|
|
|
|
djnz counter, #frontPorch ' Repeat # times.
|
|
|
|
' //////////////////////Vertical Sync//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mov counter, #(2 + 2) ' Set loop counter.
|
|
|
|
verticalSync mov vscl, blankPixels ' Invisible lines.
|
|
waitvid VSyncColors, #0 '
|
|
|
|
mov inactiveCounter, #(17 - 9) ' Update the cache.
|
|
call #cacheUpdate '
|
|
|
|
mov vscl, invisibleScale ' Vertical sync.
|
|
waitvid VSyncColors, syncPixels '
|
|
|
|
mov inactiveCounter, #(3 - 1) ' Update the cache.
|
|
call #cacheUpdate '
|
|
|
|
djnz counter, #verticalSync ' Repeat # times.
|
|
|
|
' //////////////////////Back Porch/////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mov counter, #31 ' Set loop counter.
|
|
|
|
backPorch mov vscl, blankPixels ' Invisible lines.
|
|
waitvid HSyncColors, #0 '
|
|
|
|
jmpret displayPC, mousePC ' Do mouse stuff.
|
|
|
|
mov vscl, invisibleScale ' Horizontal sync.
|
|
waitvid HSyncColors, syncPixels '
|
|
|
|
jmpret displayPC, mousePC ' Do mouse stuff.
|
|
|
|
djnz counter, #backPorch ' Repeat # times.
|
|
|
|
' //////////////////////Update Display Settings////////////////////////////////////////////////////////////////////////////////
|
|
|
|
rdbyte buffer, displayIndicatorAddress wz ' Update display settings.
|
|
muxnz dira, directionState '
|
|
|
|
' //////////////////////Loop///////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
jmp #loop ' Loop.
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Cache Update
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
cacheUpdate rdword lumaCacheBuffer, lumaPointer ' Update luma cache.
|
|
|
|
loadCheck cmpsub lumaPointer, 0 wz, wc, nr ' Load up mouse overlays on hit or miss.
|
|
if_c cmpsub displayCounter, #1 wc '
|
|
loadPixels if_z_and_c mov lumaCacheBuffer, 0 '
|
|
loadColors if_z_and_c mov chromaCacheBuffer, 0 '
|
|
if_c add loadCheck, #1 '
|
|
if_c add loadPixels, #1 '
|
|
if_c add loadColors, #1 '
|
|
|
|
lumaCacheUpdate mov 0, lumaCacheBuffer ' Update luma pointers.
|
|
add lumaCacheUpdate, destinationIncrement '
|
|
add lumaPointer, #2 '
|
|
|
|
if_nz rdlong chromaCacheBuffer, chromaPointer ' Update chroma cache.
|
|
|
|
cmp chromaPointer, printTopPlace wz ' Check cursor places.
|
|
if_nz cmp chromaPointer, printBottomPlace wz '
|
|
if_z test refreshCounter, printRateControl wc '
|
|
if_z_and_c mov chromaCacheBuffer, printColorControl '
|
|
|
|
or chromaCacheBuffer, HVSyncColors ' Update chroma pointers.
|
|
chromaCacheUpdate mov 0, chromaCacheBuffer '
|
|
add chromaCacheUpdate, destinationIncrement '
|
|
add chromaPointer, #4 '
|
|
|
|
djnz inactiveCounter, #cacheUpdate ' Repeat.
|
|
|
|
cacheUpdate_ret ret ' Return.
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Display Mouse
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
displayMouse rdword mouseRowOffset, mouseYAddress ' Compute mouse Y pixel.
|
|
max mouseRowOffset, #479 '
|
|
|
|
rdword mouseColumnOffset, mouseXAddress ' Compute mouse X pixel.
|
|
max mouseColumnOffset, sixHundredAndThirtyNine '
|
|
|
|
mov mouseBuffer, mouseRowOffset ' Compute mouse row.
|
|
shr mouseBuffer, #4 '
|
|
|
|
mov mouseCounter, mouseColumnOffset ' Compute mouse column.
|
|
shr mouseCounter, #4 '
|
|
|
|
and mouseRowOffset, #$F ' Compute pixel offsets.
|
|
and mouseColumnOffset, #$F '
|
|
|
|
rdbyte mouseColors, mouseChromaAddress ' Get mouse color.
|
|
|
|
mov mouseAddresses, #0 ' Clear triggers.
|
|
mov mouseAddresses + 1, #0 '
|
|
mov mouseAddresses + 2, #0 '
|
|
mov mouseAddresses + 3, #0 '
|
|
|
|
rdword mousePixels, mouseLumaAddress wz ' Get mouse pixel.
|
|
if_z jmp #displayMouseRet '
|
|
|
|
mov mouseAddresses, mouseBuffer ' Compute left upper mouse address in luma.
|
|
mov buffer, mouseBuffer '
|
|
shl mouseAddresses, #5 '
|
|
shl buffer, #3 '
|
|
add mouseAddresses, mouseCounter '
|
|
add mouseAddresses, buffer '
|
|
shl mouseAddresses, #1 '
|
|
add mouseAddresses, lumaBufferAddress '
|
|
|
|
cmp mouseCounter, #39 wc ' Compute right upper mouse address in luma.
|
|
if_c mov mouseAddresses + 1, mouseAddresses '
|
|
if_c add mouseAddresses + 1, #2 '
|
|
|
|
cmp mouseBuffer, #29 wc ' Compute left lower mouse address in luma.
|
|
if_c mov mouseAddresses + 2, mouseAddresses '
|
|
if_c add mouseAddresses + 2, #80 '
|
|
|
|
if_c cmp mouseCounter, #39 wc ' Compute right lower mouse address in luma.
|
|
if_c mov mouseAddresses + 3, mouseAddresses '
|
|
if_c add mouseAddresses + 3, #82 '
|
|
|
|
' //////////////////////Cache Pixel Pointers and Colors////////////////////////////////////////////////////////////////////////
|
|
|
|
movs storeBackup, #mouseAddresses ' Reset.
|
|
movd storeColors, #mouseAddColors '
|
|
movd storePixels, #mouseAddPixels '
|
|
movs storePixels, #mouseAddresses '
|
|
|
|
mov mouseCounter, #4 ' Setup counter.
|
|
|
|
storeBackup mov buffer, 0 wz ' Cache colors and pixels.
|
|
if_nz sub buffer, lumaBufferAddress '
|
|
if_nz shl buffer, #1 '
|
|
if_nz add buffer, chromaBufferAddress '
|
|
storeColors if_nz rdlong 0, buffer '
|
|
storePixels if_nz rdword 0, 0 '
|
|
|
|
add storeBackup, #1 ' Point to next.
|
|
add storeColors, destinationIncrement '
|
|
add storePixels, destinationIncrement '
|
|
add storePixels, #1 '
|
|
|
|
djnz mouseCounter, #storeBackup ' Repeat.
|
|
|
|
' //////////////////////Draw Background////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mov mouseBuffer, mouseAddColors ' Draw left upper pixels and colors.
|
|
mov mousePixelsGet, mouseAddPixels '
|
|
mov mousePixelsPut, mouseAddCaches '
|
|
movd drawBackgroundLoad, #mouseAddColors '
|
|
call #drawBackground '
|
|
|
|
mov mouseBuffer, mouseAddColors + 1 ' Draw right upper pixels and colors.
|
|
mov mousePixelsGet, mouseAddPixels + 1 '
|
|
mov mousePixelsPut, mouseAddCaches + 1 '
|
|
movd drawBackgroundLoad, #mouseAddColors + 1 '
|
|
call #drawBackground '
|
|
|
|
mov mouseBuffer, mouseAddColors + 2 ' Draw left lower pixels and colors.
|
|
mov mousePixelsGet, mouseAddPixels + 2 '
|
|
mov mousePixelsPut, mouseAddCaches + 2 '
|
|
movd drawBackgroundLoad, #mouseAddColors + 2 '
|
|
call #drawBackground '
|
|
|
|
mov mouseBuffer, mouseAddColors + 3 ' Draw right lower pixels and colors.
|
|
mov mousePixelsGet, mouseAddPixels + 3 '
|
|
mov mousePixelsPut, mouseAddCaches + 3 '
|
|
movd drawBackgroundLoad, #mouseAddColors + 3 '
|
|
call #drawBackground '
|
|
|
|
' //////////////////////Draw Foreground////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mov mouseCounter, #16 ' Setup counter.
|
|
|
|
mov mouseLeftPointer, mouseAddCaches ' Setup loading addresses.
|
|
mov mouseRightPointer, mouseAddCaches + 1 '
|
|
|
|
shl mouseRowOffset, #2 ' Setup loading offsets.
|
|
add mouseLeftPointer, mouseRowOffset '
|
|
add mouseRightPointer, mouseRowOffset '
|
|
|
|
drawForegroundLoop rdlong mouseLeftPixels, mousePixels ' Get mouse pixels.
|
|
add mousePixels, #4 '
|
|
|
|
mov buffer, mouseLeftPixels ' Promote %01 to %11.
|
|
or buffer, pixelAMask '
|
|
and buffer, pixelNAMask '
|
|
shl buffer, #1 '
|
|
or mouseLeftPixels, buffer '
|
|
|
|
mov buffer, mouseLeftPixels ' Promote %10 to %11.
|
|
or buffer, pixelNAMask '
|
|
and buffer, pixelAMask '
|
|
shr buffer, #1 '
|
|
or mouseLeftPixels, buffer '
|
|
|
|
mov mouseBuffer, mouseColumnOffset ' Compute column pixel offset.
|
|
shl mouseBuffer, #1 '
|
|
|
|
neg buffer, #1 ' Compute column pixel mask.
|
|
shr buffer, mouseBuffer '
|
|
|
|
mov mouseRightPixels, mouseLeftPixels ' Backup shift pixels.
|
|
andn mouseRightPixels, buffer '
|
|
|
|
shl mouseLeftPixels, mouseBuffer ' Build left pixels and right pixels.
|
|
rol mouseRightPixels, mouseBuffer '
|
|
|
|
rdlong buffer, mouseLeftPointer ' Load left pixels.
|
|
andn buffer, mouseLeftPixels '
|
|
wrlong buffer, mouseLeftPointer '
|
|
add mouseLeftPointer, #4 '
|
|
|
|
rdlong buffer, mouseRightPointer ' Load right pixels.
|
|
andn buffer, mouseRightPixels '
|
|
wrlong buffer, mouseRightPointer '
|
|
add mouseRightPointer, #4 '
|
|
|
|
jmpret mousePC, displayPC '
|
|
|
|
djnz mouseCounter, #drawForegroundLoop ' Repeat.
|
|
|
|
' //////////////////////Return/////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
displayMouseRet jmpret mousePC, displayPC ' Setup to return to display PC.
|
|
jmp displayPC '
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Draw Background
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
drawBackground mov buffer, mouseBuffer ' Check if color is... ABABCDCD - lower part.
|
|
mov mouseCounter, mouseBuffer '
|
|
and mouseCounter, #$FF '
|
|
shr buffer, #8 '
|
|
and buffer, #$FF '
|
|
cmp buffer, mouseCounter wz '
|
|
|
|
if_z mov buffer, mouseBuffer ' Check if color is... ABABCDCD - upper part.
|
|
if_z mov mouseCounter, mouseBuffer '
|
|
if_z shr mouseCounter, #24 '
|
|
if_z shr buffer, #16 '
|
|
if_z and buffer, #$FF '
|
|
if_z cmp buffer, mouseCounter wz '
|
|
|
|
muxz drawBackgroundPixels, #1 ' Change pixel affector.
|
|
|
|
if_z shl mouseBuffer, #8 ' Edit color.
|
|
|
|
mov buffer, mouseBuffer ' Check if color is of the form ABCDABCD.
|
|
mov mouseCounter, mouseBuffer '
|
|
shl buffer, #16 '
|
|
shr buffer, #16 '
|
|
shr mouseCounter, #16 '
|
|
cmp mouseCounter, buffer wz '
|
|
|
|
muxz drawBackgroundPixels, #2 ' Change pixel affector.
|
|
|
|
andn mouseBuffer, #$FF ' Edit color.
|
|
or mouseBuffer, mouseColors '
|
|
drawBackgroundLoad mov 0, mouseBuffer '
|
|
|
|
mov mouseCounter, #16 ' Setup counter.
|
|
|
|
drawBackgroundLoop rdlong mouseBuffer, mousePixelsGet ' Get source pixels.
|
|
add mousePixelsGet, #4 '
|
|
|
|
test drawBackgroundPixels, #1 wc ' Change pixels for interleaved characters.
|
|
if_c shr mouseBuffer, #1 '
|
|
drawBackgroundPixels test drawBackgroundPixels, #3 wz '
|
|
if_nz or mouseBuffer, pixelAMask '
|
|
|
|
if_z mov buffer, mouseBuffer ' Promote pixels %00 to %01.
|
|
if_z xor buffer, pixelXORMask '
|
|
if_z and buffer, pixelAMask '
|
|
if_z shr buffer, #1 '
|
|
if_z or mouseBuffer, buffer '
|
|
|
|
wrlong mouseBuffer, mousePixelsPut ' Put modified source pixels.
|
|
add mousePixelsPut, #4 '
|
|
|
|
test mouseCounter, #$3 wz ' Do display stuff every 4 cycles.
|
|
if_z jmpret mousePC, displayPC '
|
|
|
|
djnz mouseCounter, #drawBackgroundLoop ' Repeat.
|
|
|
|
drawBackground_ret ret ' Return.
|
|
|
|
|
|
fit 496
|
|
Dat
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
' Data
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
destinationIncrement long $2_00 ' Destination incrementor.
|
|
sixHundredAndThirtyNine long 639 ' Six hundred and thirty nine.
|
|
|
|
visibleScale long (1 << 12) + 16 ' Visible pixel scale for scan line.
|
|
invisibleScale long (16 << 12) + 160 ' Invisible pixel scale for horizontal sync.
|
|
|
|
blankPixels long 640 ' Blank scanline pixel length.
|
|
syncPixels long $00_00_3F_FC ' FP, HS, & BP Pixels.
|
|
HSyncColors long $01_01_03_03 ' Horizontal sync color mask.
|
|
VSyncColors long $00_00_02_02 ' Vertical sync color mask.
|
|
HVSyncColors long $03_03_03_03 ' Horizontal and vertical sync colors.
|
|
pixelAMask long $AA_AA_AA_AA ' To select every 2nd pixel.
|
|
pixelNAMask long $55_55_55_55 ' To modify every 2nd pixel.
|
|
pixelXORMask long $FF_FF_FF_FF ' To invert every 2nd pixel.
|
|
|
|
' //////////////////////Configuration Settings/////////////////////////////////////////////////////////////////////////////////
|
|
|
|
directionState long 0 ' Direction state configuration.
|
|
videoState long 0 ' Video state configuration.
|
|
frequencyState long 0 ' Frequency state configuration.
|
|
|
|
' //////////////////////Addresses//////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mouseXAddress long 0
|
|
mouseYAddress long 0
|
|
chromaBufferAddress long 0
|
|
lumaBufferAddress long 0
|
|
printColorAddress long 0
|
|
printPositionAddress long 0
|
|
printRateAddress long 0
|
|
mouseChromaAddress long 0
|
|
mouseLumaAddress long 0
|
|
displayIndicatorAddress long 0
|
|
syncIndicatorAddress long 0
|
|
|
|
' //////////////////////Cache Variables////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mouseAddCaches res 4
|
|
mouseAddresses res 4
|
|
mouseAddPixels res 4
|
|
mouseAddColors res 4
|
|
|
|
' //////////////////////Run Time Variables/////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
counter res 1
|
|
buffer res 1
|
|
displayPC res 1
|
|
mousePC res 1
|
|
refreshCounter res 1
|
|
displayCounter res 1
|
|
|
|
' //////////////////////Display Variables//////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
tileCounter res 1
|
|
tilesCounter res 1
|
|
|
|
activeCounter res 1
|
|
inactiveCounter res 1
|
|
|
|
lumaPointer res 1
|
|
chromaPointer res 1
|
|
|
|
lumaCacheBuffer res 1
|
|
chromaCacheBuffer res 1
|
|
|
|
lumaCache res 80
|
|
chromaCache res 80
|
|
|
|
' //////////////////////Print Variables////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
printTopPlace res 1
|
|
printBottomPlace res 1
|
|
|
|
printRateControl res 1
|
|
printColorControl res 1
|
|
|
|
' //////////////////////Mouse Variables////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mouseRowOffset res 1
|
|
mouseColumnOffset res 1
|
|
|
|
mousePixels res 1
|
|
mouseColors res 1
|
|
|
|
mouseBuffer res 1
|
|
mouseCounter res 1
|
|
|
|
mousePixelsGet res 1
|
|
mousePixelsPut res 1
|
|
|
|
mouseLeftPointer res 1
|
|
mouseRightPointer res 1
|
|
|
|
mouseLeftPixels res 1
|
|
mouseRightPixels res 1
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
' fit 496
|
|
|
|
DAT
|
|
|
|
' //////////////////////Variable Array/////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mouseCache long 0[64] ' Mouse overlay display buffer.
|
|
'chromaBuffer_tail long 0[1_200-((@chromaBuffer_tail- @chromaBuffer)/4)] 'Trick von Kuroneko um Speicher zu sparen
|
|
|
|
chromaBuffer long 0[1_200] ' Display chroma buffer.
|
|
lumaBuffer word 0[1_200] ' Display luma buffer.
|
|
printColor long 0 ' Print cursor color control.
|
|
printPosition word 0 ' Print cursor position control.
|
|
printRate byte 0 ' Print curor rate control.
|
|
mouseChroma byte 0 ' Mouse color control.
|
|
mouseLuma word 0 ' Mouse pixel control.
|
|
mouseLumaBackup word 0 ' Mouse pixel control backup.
|
|
displayIndicator byte 1 ' Video output control.
|
|
syncIndicator byte 0 ' Video update control.
|
|
cogNumber byte 0 ' Cog ID.
|
|
lockNumber byte 0 ' Lock ID.
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
DAT
|
|
|
|
' //////////////////////Mouse Pointer//////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
mousePointer long %%0000000000000001
|
|
long %%0000000000000011
|
|
long %%0000000000000121
|
|
long %%0000000000001221
|
|
long %%0000000000012321
|
|
long %%0000000000123321
|
|
long %%0000000001233321
|
|
long %%0000000012333321
|
|
long %%0000000123333321
|
|
long %%0000001233333321
|
|
long %%0000012222222221
|
|
long %%0000111111221221
|
|
long %%0000000001221221
|
|
long %%0000000012210121
|
|
long %%0000000012100011
|
|
long %%0000000111100001
|
|
|
|
' /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
{{
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// TERMS OF USE: MIT License
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation
|
|
// files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy,
|
|
// modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the
|
|
// Software is furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
|
|
// Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
|
|
// WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
|
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
}}
|