mirror of
https://github.com/fadden/6502bench.git
synced 2024-07-31 07:29:00 +00:00
e622afd929
Adopted the naming conventions from the "Hitch-Hacker's Guide" doc. Updated some comments. No change in behavior.
358 lines
15 KiB
C#
358 lines
15 KiB
C#
/*
|
|
* Copyright 2021 faddenSoft
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
using System;
|
|
using System.Collections.ObjectModel;
|
|
|
|
using PluginCommon;
|
|
|
|
namespace RuntimeData.Atari {
|
|
/// <summary>
|
|
/// Visualizer for Atari Digital Vector Generator commands (Asteroids, etc).
|
|
///
|
|
/// Currently ignores beam brightness, except as on/off.
|
|
///
|
|
/// References:
|
|
/// https://wiki.philpem.me.uk/_media/elec/vecgen/vecgen.pdf
|
|
///
|
|
/// https://github.com/mamedev/mame/blob/master/src/mame/video/avgdvg.cpp is the
|
|
/// definitive description, but it's harder to parse than the above (it's emulating
|
|
/// the hardware at a lower level).
|
|
/// </summary>
|
|
public class VisDVG : MarshalByRefObject, IPlugin, IPlugin_Visualizer_v2 {
|
|
private readonly bool VERBOSE = false;
|
|
|
|
// IPlugin
|
|
public string Identifier {
|
|
get { return "Atari DVG Visualizer"; }
|
|
}
|
|
private IApplication mAppRef;
|
|
private byte[] mFileData;
|
|
private AddressTranslate mAddrTrans;
|
|
|
|
// Visualization identifiers; DO NOT change or projects that use them will break.
|
|
private const string VIS_GEN_DVG = "atari-dvg";
|
|
|
|
private const string P_OFFSET = "offset";
|
|
private const string P_BASE_ADDR = "baseAddr";
|
|
private const string P_IGNORE_LABS = "ignoreLabs";
|
|
|
|
// Visualization descriptors.
|
|
private VisDescr[] mDescriptors = new VisDescr[] {
|
|
new VisDescr(VIS_GEN_DVG, "Atari DVG Commands", VisDescr.VisType.Wireframe,
|
|
new VisParamDescr[] {
|
|
new VisParamDescr("File offset (hex)",
|
|
P_OFFSET, typeof(int), 0, 0x00ffffff, VisParamDescr.SpecialMode.Offset, 0),
|
|
new VisParamDescr("Base address",
|
|
P_BASE_ADDR, typeof(int), 0x0000, 0xffff, 0, 0x4000),
|
|
new VisParamDescr("Ignore LABS move",
|
|
P_IGNORE_LABS, typeof(bool), false, true, 0, false),
|
|
|
|
VisWireframe.Param_IsRecentered("Centered", true),
|
|
}),
|
|
};
|
|
|
|
|
|
// IPlugin
|
|
public void Prepare(IApplication appRef, byte[] fileData, AddressTranslate addrTrans) {
|
|
mAppRef = appRef;
|
|
mFileData = fileData;
|
|
mAddrTrans = addrTrans;
|
|
}
|
|
|
|
// IPlugin
|
|
public void Unprepare() {
|
|
mAppRef = null;
|
|
mFileData = null;
|
|
mAddrTrans = null;
|
|
}
|
|
|
|
// IPlugin_Visualizer
|
|
public VisDescr[] GetVisGenDescrs() {
|
|
if (mFileData == null) {
|
|
return null;
|
|
}
|
|
return mDescriptors;
|
|
}
|
|
|
|
// IPlugin_Visualizer
|
|
public IVisualization2d Generate2d(VisDescr descr,
|
|
ReadOnlyDictionary<string, object> parms) {
|
|
mAppRef.ReportError("2d not supported");
|
|
return null;
|
|
}
|
|
|
|
// IPlugin_Visualizer_v2
|
|
public IVisualizationWireframe GenerateWireframe(VisDescr descr,
|
|
ReadOnlyDictionary<string, object> parms) {
|
|
switch (descr.Ident) {
|
|
case VIS_GEN_DVG:
|
|
return GenerateWireframe(parms);
|
|
default:
|
|
mAppRef.ReportError("Unknown ident " + descr.Ident);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private enum Opcode {
|
|
Unknown = 0, VCTR, LABS, HALT, JSRL, RTSL, JMPL, SVEC
|
|
}
|
|
|
|
private IVisualizationWireframe GenerateWireframe(ReadOnlyDictionary<string, object> parms) {
|
|
int offset = Util.GetFromObjDict(parms, P_OFFSET, 0);
|
|
int baseAddr = Util.GetFromObjDict(parms, P_BASE_ADDR, 0);
|
|
bool ignoreLabs = Util.GetFromObjDict(parms, P_IGNORE_LABS, false);
|
|
|
|
if (offset < 0 || offset >= mFileData.Length) {
|
|
// should be caught by editor
|
|
mAppRef.ReportError("Invalid parameter");
|
|
return null;
|
|
}
|
|
|
|
VisWireframe vw = new VisWireframe();
|
|
vw.Is2d = true;
|
|
|
|
try {
|
|
int[] stack = new int[4];
|
|
int stackPtr = 0;
|
|
|
|
double beamX = 0;
|
|
double beamY = 0;
|
|
int scaleFactor = 0; // tiny
|
|
bool done = false;
|
|
int centerVertex = vw.AddVertex(0, 0, 0);
|
|
int curVertex = centerVertex;
|
|
|
|
while (!done && offset < mFileData.Length) {
|
|
ushort code0 = (ushort)Util.GetWord(mFileData, offset, 2, false);
|
|
offset += 2;
|
|
Opcode opc = GetOpcode(code0);
|
|
|
|
switch (opc) {
|
|
case Opcode.VCTR: { // SSSS -mYY YYYY YYYY | BBBB -mXX XXXX XXXX
|
|
ushort code1 = (ushort)Util.GetWord(mFileData, offset, 2, false);
|
|
offset += 2;
|
|
|
|
int yval = sign11(code0 & 0x07ff);
|
|
int xval = sign11(code1 & 0x07ff);
|
|
int localsc = code0 >> 12; // local scale
|
|
int bb = code1 >> 12; // brightness
|
|
|
|
double scale = CalcScaleMult(scaleFactor + localsc);
|
|
double dx = xval * scale;
|
|
double dy = yval * scale;
|
|
|
|
beamX += dx;
|
|
beamY += dy;
|
|
if (bb == 0) {
|
|
// move only
|
|
curVertex = vw.AddVertex((float)beamX, (float)beamY, 0);
|
|
} else if (xval == 0 && yval == 0) {
|
|
// plot point
|
|
vw.AddPoint(curVertex);
|
|
//mAppRef.DebugLog("PLOT v" + curVertex + ": "
|
|
// + beamX + "," + beamY);
|
|
} else {
|
|
// draw line from previous vertex
|
|
int newVertex = vw.AddVertex((float)beamX, (float)beamY, 0);
|
|
vw.AddEdge(curVertex, newVertex);
|
|
curVertex = newVertex;
|
|
}
|
|
|
|
if (VERBOSE) {
|
|
mAppRef.DebugLog("VCTR scale=" + localsc + " x=" + dx +
|
|
" y=" + dy + " b=" + bb + " --> dx=" + dx +
|
|
" dy=" + dy);
|
|
}
|
|
}
|
|
break;
|
|
case Opcode.LABS: { // 1010 00yy yyyy yyyy | SSSS 00xx xxxx xxxx
|
|
ushort code1 = (ushort)Util.GetWord(mFileData, offset, 2, false);
|
|
offset += 2;
|
|
|
|
int yc = code0 & 0x07ff;
|
|
int xc = code1 & 0x07ff;
|
|
int scale = code1 >> 12;
|
|
|
|
if (!ignoreLabs) {
|
|
// Some things do a big screen movement before they start
|
|
// drawing, which throws off the auto-scaling. The output
|
|
// looks better if we ignore the initial movement.
|
|
beamX = xc;
|
|
beamY = yc;
|
|
}
|
|
// Sign-extend the scale factor. (It's usually 0 or 1 in ROM.)
|
|
byte left = (byte)(scale << 4);
|
|
scaleFactor = (sbyte)left >> 4;
|
|
|
|
if (VERBOSE) {
|
|
mAppRef.DebugLog("LABS scale=" + scale + " x=" + xc +
|
|
" y=" + yc);
|
|
}
|
|
}
|
|
break;
|
|
case Opcode.HALT: // 1011 0000 0000 0000
|
|
if (stackPtr != 0) {
|
|
mAppRef.DebugLog("NOTE: encountered HALT with nonzero stack");
|
|
}
|
|
done = true;
|
|
break;
|
|
case Opcode.JSRL: { // 1100 aaaa aaaa aaaa
|
|
int vaddr = code0 & 0x0fff;
|
|
if (stackPtr == stack.Length) {
|
|
mAppRef.ReportError("Stack overflow at +" +
|
|
offset.ToString("x6"));
|
|
return null;
|
|
}
|
|
stack[stackPtr++] = offset;
|
|
if (!Branch(vaddr, baseAddr, ref offset)) {
|
|
return null;
|
|
}
|
|
}
|
|
break;
|
|
case Opcode.JMPL: { // 1110 aaaa aaaa aaaa
|
|
int vaddr = code0 & 0x0fff;
|
|
if (!Branch(vaddr, baseAddr, ref offset)) {
|
|
return null;
|
|
}
|
|
}
|
|
break;
|
|
case Opcode.RTSL: // 1101 0000 0000 0000
|
|
if (stackPtr == 0) {
|
|
done = true;
|
|
} else {
|
|
offset = stack[--stackPtr];
|
|
}
|
|
break;
|
|
case Opcode.SVEC: { // 1111 smYY BBBB SmXX
|
|
int yval = sign3((code0 >> 8) & 0x07);
|
|
int xval = sign3(code0 & 0x07);
|
|
int localsc = ((code0 >> 11) & 0x01) | ((code0 >> 2) & 0x02);
|
|
// SVEC scale is VEC scale + 2
|
|
double scale = CalcScaleMult(scaleFactor + localsc + 2);
|
|
int bb = (code0 >> 4) & 0x0f;
|
|
|
|
// The dx/dy values need to be x256 to make them work right.
|
|
// This is not mentioned in any document I've found, but it's
|
|
// required if e.g. you want the hexagon to match up with the 'C'
|
|
// in the Asteroids copyright message.
|
|
double dx = (xval << 8) * scale;
|
|
double dy = (yval << 8) * scale;
|
|
beamX += dx;
|
|
beamY += dy;
|
|
|
|
if (bb == 0) {
|
|
// move only
|
|
curVertex = vw.AddVertex((float)beamX, (float)beamY, 0);
|
|
} else if (xval == 0 && yval == 0) {
|
|
// plot point
|
|
vw.AddPoint(curVertex);
|
|
//mAppRef.DebugLog("SPLOT v" + curVertex + ": "
|
|
// + beamX + "," + beamY);
|
|
} else {
|
|
// draw line from previous vertex
|
|
int newVertex = vw.AddVertex((float)beamX, (float)beamY, 0);
|
|
vw.AddEdge(curVertex, newVertex);
|
|
curVertex = newVertex;
|
|
}
|
|
if (VERBOSE) {
|
|
mAppRef.DebugLog("SVEC scale=" + localsc + " x=" + dx +
|
|
" y=" + dy + " b=" + bb + " --> dx=" + dx +
|
|
" dy=" + dy);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
mAppRef.ReportError("Unhandled code $" + code0.ToString("x4"));
|
|
return null;
|
|
}
|
|
}
|
|
|
|
} catch (IndexOutOfRangeException) {
|
|
// assume it was our file data access that caused the failure
|
|
mAppRef.ReportError("Ran off end of file");
|
|
return null;
|
|
}
|
|
|
|
string msg;
|
|
if (!vw.Validate(out msg)) {
|
|
mAppRef.ReportError("Data error: " + msg);
|
|
return null;
|
|
}
|
|
|
|
return vw;
|
|
}
|
|
|
|
private static Opcode GetOpcode(ushort code) {
|
|
switch (code & 0xf000) {
|
|
case 0xa000: return Opcode.LABS;
|
|
case 0xb000: return Opcode.HALT;
|
|
case 0xc000: return Opcode.JSRL;
|
|
case 0xd000: return Opcode.RTSL;
|
|
case 0xe000: return Opcode.JMPL;
|
|
case 0xf000: return Opcode.SVEC;
|
|
default: return Opcode.VCTR; // 0x0nnn - 0x9nnn
|
|
}
|
|
}
|
|
|
|
// Convert scale factor (0-9) to a multiplier.
|
|
private static double CalcScaleMult(int scaleFactor) {
|
|
// 0 is N/512, 9 is N/1.
|
|
if (scaleFactor < 0) {
|
|
scaleFactor = 0;
|
|
} else if (scaleFactor > 9) {
|
|
scaleFactor = 9;
|
|
}
|
|
return 1.0 / (1 << (9 - scaleFactor));
|
|
}
|
|
|
|
// Set the sign for a 2-bit value with a sign flag in the 3rd bit.
|
|
private static int sign3(int val) {
|
|
if ((val & 0x0004) == 0) {
|
|
return val;
|
|
} else {
|
|
return -(val & 0x03);
|
|
}
|
|
}
|
|
|
|
// Set the sign for a 10-bit value with a sign flag in the 11th bit.
|
|
private static int sign11(int val) {
|
|
if ((val & 0x0400) == 0) {
|
|
return val;
|
|
} else {
|
|
return -(val & 0x03ff);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Converts a JSRL/JMPL operand to a file offset.
|
|
/// </summary>
|
|
/// <param name="vaddr">DVG address operand.</param>
|
|
/// <param name="baseAddr">Base address of vector memory.</param>
|
|
/// <param name="offset">File offset of instruction.</param>
|
|
/// <returns>False if the target address is outside the file bounds.</returns>
|
|
private bool Branch(int vaddr, int baseAddr, ref int offset) {
|
|
int fileAddr = baseAddr + vaddr * 2;
|
|
int fileOffset = mAddrTrans.AddressToOffset(offset, fileAddr);
|
|
if (fileOffset < 0) {
|
|
mAppRef.ReportError("JMPL/JSRL to " + vaddr.ToString("x4") + " invalid");
|
|
return false;
|
|
}
|
|
offset = fileOffset;
|
|
return true;
|
|
}
|
|
}
|
|
}
|