b804964514
Both VT11 and VS60 properly autoconfigure on the PDP11. PDP11 now runs Lunar Lander on all SDL supported platforms. Reworked refresh logic to not require internal delays in the display library
3813 lines
155 KiB
C
3813 lines
155 KiB
C
/*
|
||
* $Id: vt11.c,v 1.28 2005/08/06 21:09:04 phil Exp $
|
||
* Simulator Independent VT11/VS60 Graphic Display Processor Simulation
|
||
* Phil Budne <phil@ultimate.com>
|
||
* September 13, 2003
|
||
* Substantially revised by Douglas A. Gwyn; last edited 05 Aug 2005
|
||
*
|
||
* from EK-VT11-TM-001, September 1974
|
||
* and EK-VT48-TM-001, November 1976
|
||
* with help from Al Kossow's "VT11 instruction set" posting of 21 Feb 93
|
||
* and VT48 Engineering Specification Rev B
|
||
* and VS60 diagnostic test listings, provided by Alan Frisbie
|
||
*/
|
||
|
||
/*
|
||
* Copyright (c) 2003-2004, Philip L. Budne and Douglas A. Gwyn
|
||
*
|
||
* 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 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.
|
||
*
|
||
* Except as contained in this notice, the names of the authors shall
|
||
* not be used in advertising or otherwise to promote the sale, use or
|
||
* other dealings in this Software without prior written authorization
|
||
* from the authors.
|
||
*/
|
||
|
||
/*
|
||
* The VT11 is a calligraphic display-file device used in the GT4x series
|
||
* of workstations (PDP-11/04,34,40 based).
|
||
*
|
||
* The VS60 is an improved, extended, upward-compatible version of the
|
||
* VT11, used in the GT62 workstation (PDP-11/34 based). It supports
|
||
* dual consoles (CRTs with light pens), multiple phosphor colors, 3D
|
||
* depth cueing, and circle/arc generator as options. We do not know
|
||
* whether any of these options were ever implemented or delivered.
|
||
* Apparently a later option substituted a digitizing-tablet correlator
|
||
* for the light pen. The VS60 has a 4-level silo (graphic data pipeline)
|
||
* which for reasons of simplicity is not implemented in this simulation;
|
||
* the only visible effect is that DZVSC diagnostic tests 110 & 111 will
|
||
* report failure.
|
||
*
|
||
* The VSV11/VS11 is a color raster display-file device (with joystick
|
||
* instead of light pen) with instructions similar to the VT11's but
|
||
* different enough that a separate emulation should be created by
|
||
* editing a copy of this source file rather than trying to hack it into
|
||
* this one. Very likely, the display (phosphor decay) simulation will
|
||
* also require revision to handle multiple colors.
|
||
*
|
||
* There were further models in this series, but they appear to have
|
||
* little if any compatibility with the VT11.
|
||
*
|
||
* Much later, DEC produced a display system it called the VS60S, but
|
||
* that doesn't seem to bear any relationship to the original VS60.
|
||
*
|
||
* A PDP-11 system has at most one display controller attached.
|
||
* In principle, a VT11 or VS60 can also be used on a VAX Unibus.
|
||
*
|
||
* STATUS:
|
||
*
|
||
* Clipping is not implemented properly for arcs.
|
||
*
|
||
* This simulation passes all four MAINDEC VS60 diagnostics and the
|
||
* DEC/X11 VS60 system exerciser, with the following exceptions:
|
||
*
|
||
* MD-11-DZVSA-A, VS60 instruction test part I, test 161:
|
||
* Failure to time-out an access to a "nonexistent" bus address, when the
|
||
* system is configured with so much memory that the probed address
|
||
* actually responds; this is a deficiency in the diagnostic itself.
|
||
*
|
||
* MD-11-DZVSB-A, VS60 instruction test part II:
|
||
* No exceptions.
|
||
*
|
||
* MD-11-DZVSC-B, VS60 instruction test part III, tests 107,110,111:
|
||
* Memory address test fails under SIMH, due to SIMH not implementing
|
||
* KT11 "maintenance mode", in which the final destination address (only)
|
||
* is relocated. When SIMH is patched to fix this, the test still fails
|
||
* due to a bug in the diagnostic itself, namely a call to DPCONV1 which
|
||
* tests a condition code that is supposed to pertain to R0 but which
|
||
* hasn't been set up. Swapping the two instructions before the call to
|
||
* DPCONV1 corrects this, and then this test passes.
|
||
* Graphic silo content tests fail, since the silo pipeline is not
|
||
* simulated; there are no plans to fix this, since it serves no other
|
||
* purpose in this simulation and would adversely affect performance.
|
||
*
|
||
* MD-11-DZVSD-B, VS60 visual display test, frame 13:
|
||
* "O" character sizes are slightly off, due to optimization for raster
|
||
* display rather than true stroking; there are no plans to change this.
|
||
*
|
||
* MD-11-DZVSE-A0, XXDP VS60 visual display exerciser:
|
||
* No visible exceptions. Light-pen interrupts might not be handled
|
||
* right, since they're reported as errors and cause display restart.
|
||
* (XXX Need to obtain source listing to check this.)
|
||
*/
|
||
|
||
#ifdef DEBUG_VT11
|
||
#include <stdio.h>
|
||
#endif
|
||
#include <string.h> /* memset */
|
||
#ifndef NO_CONIC_OPT
|
||
#include <math.h> /* atan2, cos, sin, sqrt */
|
||
#endif
|
||
|
||
#include "xy.h" /* XY plot interface */
|
||
#include "vt11.h"
|
||
|
||
#define BITMASK(n) (1<<(n)) /* PDP-11 bit numbering */
|
||
|
||
/* mask for a field */
|
||
#define FIELDMASK(START,END) ((1<<((START)-(END)+1))-1)
|
||
|
||
/* extract a field */
|
||
#define GETFIELD(W,START,END) (((W)>>(END)) & FIELDMASK(START,END))
|
||
|
||
/* extract a 1-bit field */
|
||
#define TESTBIT(W,B) (((W) & BITMASK(B)) != 0)
|
||
|
||
static void *vt11_dptr;
|
||
static int vt11_dbit;
|
||
|
||
#ifdef DEBUG_VT11
|
||
|
||
#include <stdio.h>
|
||
|
||
#define DEVICE void
|
||
|
||
#define DBG_CALL 1
|
||
int vt11_debug;
|
||
|
||
extern void _sim_debug (int dbits, DEVICE* dptr, const char* fmt, ...);
|
||
|
||
#define DEBUGF(...) do {if (vt11_debug & DBG_CALL) { _sim_debug (vt11_dbit, vt11_dptr, ## __VA_ARGS__); };} while (0)
|
||
|
||
#else
|
||
|
||
#define DEBUGF(...)
|
||
|
||
#endif
|
||
|
||
/*
|
||
* Note about coordinate signedness and wrapping:
|
||
*
|
||
* The documentation for these devices says confusing things about coordinate
|
||
* wrapping and signedness. The VT11 maintains 12-bit coordinate registers
|
||
* (wrapping 4096 -> 0), while the VS60 maintains 14-bit coordinate registers.
|
||
* Coordinate arithmetic (such as adding a vector "delta" to the current
|
||
* position) that overflows merely drops the extra bits; this can be treated
|
||
* as use of twos-complement representation for the position registers, whereas
|
||
* the VS60 offset registers and the display file itself use a signed-magnitude
|
||
* representation. (Except that JMP/JSR-relative delta uses twos-complement!)
|
||
* This simulation tracks position using at least 32 bits including sign; this
|
||
* can overflow only for a pathological display file.
|
||
*
|
||
* Note about scaling and offsets:
|
||
*
|
||
* The VS60 supports character and vector scaling and position offsets. The
|
||
* X, Y, and Z position register values always include scaling and offsets.
|
||
* It is not clear from the manual whether or not there are two "guard bits",
|
||
* which would better track the virtual position when using a scale factor of
|
||
* 3/4, 1/2, or 1/4. Most likely, there are no guard bits (this has been
|
||
* confirmed by diagnostic DZVSB test 31). This simulation maintains position
|
||
* values and offsets both multiplied by PSCALEF, which should be 4 to obtain
|
||
* maximum drawing precision, or 1 to mimic the actual non-guard-bit display
|
||
* hardware. These internal coordinates are "normalized" (converted to correct
|
||
* virtual CRT coordinates) before being reported via the position/offset
|
||
* registers. The normalized Z position register value's 2 lowest bits are
|
||
* always 0.
|
||
* Example of why this matters: Set vector scale 1/2; draw successive vectors
|
||
* with delta X = 1, 1, and -2. With guard bits, the final and original X
|
||
* positions are the same; without guard bits, the final X position is one
|
||
* unit to the left of the original position. This effect accumulates over a
|
||
* long sequence of vectors, leading to quite visible distortion of the image.
|
||
*
|
||
* Light-pen and edge-interrupt positions always have "on-screen" values.
|
||
*/
|
||
|
||
#ifndef PSCALEF
|
||
#if 0 /* XXX enable only during development, to catch any oversights */
|
||
#define PSCALEF 4 /* position scale factor 4 for maximum precision */
|
||
#else
|
||
#define PSCALEF 1 /* position scale factor 1 for accurate simulation */
|
||
#endif
|
||
#endif
|
||
|
||
#define PSCALE(x) ((x) * PSCALEF)
|
||
#define PNORM(x) ((x) / PSCALEF)
|
||
/* virtual_CRT_coordinate = PNORM(scaled_value) */
|
||
|
||
/* VS60 scales points/vectors and characters separately */
|
||
#define VSCALE(x) ((PSCALE(vector_scale * (int32)(x)) + ((x)>=0 ? 1 : -1)) / 4)
|
||
#define CSCALE(x) ((PSCALE(char_scale * (int32)(x)) + ((x)>=0 ? 1 : -1)) / 4)
|
||
/* (The "+ ((x)>=0 ? 1 : -1)" above is needed to pass the diagnostics.) */
|
||
|
||
#define ABS(x) ((x) >= 0 ? (x) : -(x))
|
||
#define TWOSCOMP(x) ((x) >= 0 ? (x) : ~(-(x)-1))
|
||
|
||
enum display_type vt11_display = DISPLAY_TYPE; /* DIS_VR{14,17,48} */
|
||
int vt11_scale = PIX_SCALE; /* RES_{FULL,HALF,QUARTER,EIGHTH} */
|
||
unsigned char vt11_init = 0; /* set after display_init() called */
|
||
#define INIT { if (!vt11_init) { display_init(vt11_display, vt11_scale, vt11_dptr); \
|
||
vt11_init = 1; vt11_reset(vt11_dptr, vt11_dbit); } }
|
||
|
||
/* state visible to host */
|
||
|
||
/* The register and field names are those used in the VS60 manual (minus the
|
||
trailing "flag", "code", "status", or "select"); the VT11 manual uses
|
||
somewhat different names. */
|
||
|
||
/*
|
||
* Display Program Counter
|
||
* Read/Write (reading returns the *relocated* DPC bits [15:0])
|
||
* DPC address 15:1
|
||
* resume 0
|
||
*/
|
||
#define DPC stack[8]._dpc /* Display PC (always even) */
|
||
static uint16 bdb = 0; /* Buffered Data Bits register;
|
||
see comment in vt11_get_dpc() */
|
||
|
||
/*
|
||
* Mode Parameter Register
|
||
* Read Only, except that writing to it beeps the LK40 keyboard's bell
|
||
* internal stop flag 15
|
||
* graphic mode code 14:11
|
||
* intensity level 10:8
|
||
* LP con. 0 hit flag 7
|
||
* shift out status 6
|
||
* edge indicator 5
|
||
* italics status 4
|
||
* blink status 3
|
||
* edge flag status 2 (VS60 only)
|
||
* line type register status 1:0
|
||
*/
|
||
static unsigned char internal_stop = 0; /* 1 bit: stop display */
|
||
static unsigned char mode_field = 0; /* copy of control instr. bits 14-11 */
|
||
#define graphic_mode stack[8]._mode /* 4 bits: sets type for graphic data */
|
||
enum mode { CHAR=0, SVECTOR, LVECTOR, POINT, GRAPHX, GRAPHY, RELPOINT, /* all */
|
||
BSVECT, CIRCLE, ABSVECTOR /* VS60 only */
|
||
};
|
||
|
||
#define intensity stack[8]._intens /* 3 bits: 0 => dim .. 7 => bright */
|
||
static unsigned char lp0_hit = 0; /* 1 bit: light pen #0 detected hit */
|
||
static unsigned char so_flag = 0; /* 1 bit: illegal char. in SO mode */
|
||
static unsigned char edge_indic = 0; /* 1 bit: crossing visible area edge */
|
||
#define italics stack[8]._italics /* 1 bit: use italic font */
|
||
#define blink_ena stack[8]._blink /* 1 bit: blink graphic item */
|
||
static unsigned char edge_flag = 0; /* 1 bit: edge intr if enabled (VS60) */
|
||
#define line_type stack[8]._ltype /* 2 bits: style for drawing vectors */
|
||
enum linetype { SOLID=0, LONG_DASH, SHORT_DASH, DOT_DASH };
|
||
|
||
/*
|
||
* Graphplot Increment and X Position Register
|
||
* Read Only
|
||
* graphplot increment register value 15:10
|
||
* X position register value 9:0
|
||
*/
|
||
static unsigned char graphplot_step = 0;/* (scaled) graphplot step increment */
|
||
static int32 xpos = 0; /* X position register * PSCALEF */
|
||
/* note: offset has been applied! */
|
||
static int lp_xpos; /* (normalized) */
|
||
static int edge_xpos; /* (normalized) */
|
||
|
||
/*
|
||
* Character Code and Y Position Register
|
||
* Read Only
|
||
* character register contents 15:10
|
||
* Y position register value 9:0
|
||
*/
|
||
static unsigned char char_buf = 0; /* (only lowest 6 bits reported) */
|
||
static int32 ypos = 0; /* Y position register * PSCALEF */
|
||
/* note: offset has been applied! */
|
||
static int lp_ypos; /* (normalized) */
|
||
static int edge_ypos; /* (normalized) */
|
||
|
||
/*
|
||
* Relocate Register (VS60 only)
|
||
* Read/Write
|
||
* spare 15:12
|
||
* relocate register value[17:6] 11:0
|
||
*/
|
||
static uint32 reloc = 0; /* relocation, aligned with DPC */
|
||
|
||
/*
|
||
* Status Parameter Register (VS60 only)
|
||
* Read Only, except for bit 7 (1 => external stop request)
|
||
* display busy status 15
|
||
* stack overflow status 13
|
||
* stack underflow status 12
|
||
* time out status 11
|
||
* char. rotate status 10
|
||
* char. scale index 9:8
|
||
* external stop flag 7
|
||
* menu status 6
|
||
* relocated DPC bits [17:16] 5:4
|
||
* vector scale 3:0
|
||
*/
|
||
#define busy (!(stopped || lphit_irq || lpsw_irq || edge_irq || char_irq \
|
||
|| stack_over || stack_under || time_out || name_irq))
|
||
/* 1 bit: display initiated | resumed */
|
||
static unsigned char stack_over = 0; /* 1 bit: "push" with full stack */
|
||
static unsigned char stack_under = 0; /* 1 bit: "pop" with empty stack */
|
||
static unsigned char time_out = 0; /* 1 bit: timeout has occurred */
|
||
#define char_rotate stack[8]._crotate /* 1 bit: rotate chars 90 degrees CCW */
|
||
#define cs_index stack[8]._csi /* character scale index 0..3 */
|
||
static unsigned char ext_stop = 0; /* 1 bit: stop display */
|
||
#define menu stack[8]._menu /* 1 bit: VS60 graphics in menu area */
|
||
#define vector_scale stack[8]._vscale /* non-character scale factor * 4 */
|
||
|
||
/*
|
||
* X Offset Register (VS60 only)
|
||
* Read/Write
|
||
* upper X position bits 15:12 (read)
|
||
* sign of X dynamic offset 13 (write)
|
||
* X dynamic offset 11:0
|
||
*/
|
||
static unsigned char s_xoff = 0; /* sign bit for xoff (needed for -0) */
|
||
static int32 xoff = 0; /* X offset register * PSCALEF */
|
||
|
||
/*
|
||
* Y Offset Register (VS60 only)
|
||
* Read/Write
|
||
* upper Y position bits 15:12 (read)
|
||
* sign of Y dynamic offset 13 (write)
|
||
* Y dynamic offset 11:0
|
||
*/
|
||
static unsigned char s_yoff = 0; /* sign bit for yoff (needed for -0) */
|
||
static int32 yoff = 0; /* Y offset register * PSCALEF */
|
||
|
||
/*
|
||
* Associative Name Register (VS60 only)
|
||
* Write Only
|
||
* search code change enable 14
|
||
* search code 13:12
|
||
* name change enable 11
|
||
* associative name 10:0
|
||
*/
|
||
static unsigned char search = 0; /* 00=> no search, no interrupt
|
||
01 => intr. on 11-bit compare
|
||
10 => intr. on high-8-bit compare
|
||
11 => intr. on high-4-bit compare */
|
||
static unsigned assoc_name = 0; /* compare value */
|
||
|
||
/*
|
||
* Slave Console/Color Register (VS60 only)
|
||
* Read/Write *
|
||
* inten enable con. 0 15
|
||
* light pen hit flag con. 0 14 *
|
||
* LP switch on flag con. 0 13 *
|
||
* LP switch off flag con. 0 12 *
|
||
* LP flag intr. enable con. 0 11
|
||
* LP switch flag intr. enable con. 0 10
|
||
* inten enable con. 1 9
|
||
* light pen hit flag con. 1 8 *
|
||
* LP switch on flag con. 1 7 *
|
||
* LP switch off flag con. 1 6 *
|
||
* LP flag intr. enable con. 1 5
|
||
* LP switch flag intr. enable con. 1 4
|
||
* color 3:2
|
||
*
|
||
* * indicates that maintenance switch 3 must be set to write these bits;
|
||
* the other bits are not writable at all
|
||
*/
|
||
#define int0_scope stack[8]._inten0 /* enable con 0 for all graphic data */
|
||
/* lp0_hit has already been defined, under Mode Parameter Register */
|
||
static unsigned char lp0_down = 0; /* 1 bit: LP #0 switch was depressed */
|
||
static unsigned char lp0_up = 0; /* 1 bit: LP #0 switch was released */
|
||
#define lp0_intr_ena stack[8]._lp0intr /* generate interrupt on LP #0 hit */
|
||
#define lp0_sw_intr_ena stack[8]._lp0swintr /* generate intr. on LP #0 sw chg */
|
||
#define int1_scope stack[8]._inten1 /* enable con 1 for all graphic data */
|
||
/* following 2 flags only mutable via writing this register w/ MS3 set: */
|
||
static unsigned char lp1_hit = 0; /* 1 bit: light pen #1 detected hit */
|
||
static unsigned char lp1_down = 0; /* 1 bit: LP #1 switch was depressed */
|
||
static unsigned char lp1_up = 0; /* 1 bit: LP #1 switch was released */
|
||
#define lp1_intr_ena stack[8]._lp1intr /* generate interrupt on LP #1 hit */
|
||
#define lp1_sw_intr_ena stack[8]._lp1swintr /* generate intr. on LP #1 sw chg */
|
||
|
||
enum scolor { GREEN=0, YELLOW, ORANGE, RED };
|
||
#define color stack[8]._color /* 2 bits: VS60 color option */
|
||
|
||
/*
|
||
* Name Register (VS60 only)
|
||
* Read Only
|
||
* name/assoc name match flag 15
|
||
* search code 13:12
|
||
* name 10:0
|
||
*/
|
||
static unsigned char name_irq = 0; /* 1 bit: name matches associative nm */
|
||
/* (always interrupts on name match!) */
|
||
/* search previously defined, under Associative Name Register */
|
||
#define name stack[8]._name /* current name from display file */
|
||
|
||
/*
|
||
* Stack Data Register (VS60 only)
|
||
* Read Only
|
||
* stack data 15:0 (as selected by Stk. Addr./Maint. Reg.)
|
||
*
|
||
* On the actual hardware there are 2 32-bit words per each of 8 stack levels.
|
||
* At the PDP-11 these appear to be 4 16-bit words ("stack bytes") per level.
|
||
*/
|
||
/* It is important to note that setting the stack level via SAR doesn't change
|
||
the parameters currently in effect; only JSR/POPR does that. To speed up
|
||
JSR/POPR, the current state is implemented as an extra stack frame, so that
|
||
push/pop is done by copying a block rather than lots of individual variables.
|
||
There are thus 9 stack elements, 8 stack entries [0..7] and the current state
|
||
[8]. Mimicking the actual hardware, the stack level *decreases* upon JSR.
|
||
*/
|
||
|
||
static struct frame
|
||
{
|
||
vt11word _dpc; /* Display Program Counter (even) */
|
||
unsigned _name; /* (11-bit) name from display file */
|
||
enum mode _mode; /* 4 bits: sets type for graphic data */
|
||
unsigned char _vscale; /* non-character scale factor * 4 */
|
||
unsigned char _csi; /* character scale index 0..3 */
|
||
unsigned char _cscale; /* character scale factor * 4 */
|
||
unsigned char _crotate; /* rotate chars 90 degrees CCW */
|
||
unsigned char _intens; /* intensity: 0 => dim .. 7 => bright */
|
||
enum linetype _ltype; /* line type (long dash, etc.) */
|
||
unsigned char _blink; /* blink enable */
|
||
unsigned char _italics; /* italicize characters */
|
||
unsigned char _so; /* currently in shift-out mode */
|
||
unsigned char _menu; /* VS60 graphics in menu area */
|
||
unsigned char _cesc; /* perform POPR on char. term. match */
|
||
unsigned char _edgeintr; /* generate intr. on edge transition */
|
||
unsigned char _lp1swintr; /* generate intr. on LP #1 switch chg */
|
||
unsigned char _lp0swintr; /* generate intr. on LP #0 switch chg */
|
||
unsigned char _lp1intr; /* generate interrupt on LP #1 hit */
|
||
unsigned char _inten1; /* blank cons. 1 for all graphic data */
|
||
unsigned char _lp0intr; /* generate interrupt on LP #0 hit */
|
||
unsigned char _inten0; /* blank cons. 0 for all graphic data */
|
||
unsigned char _bright; /* visually indicate hit on entity */
|
||
unsigned char _stopintr; /* generate interrupt on intern. stop */
|
||
enum scolor _color; /* scope display color (option) */
|
||
unsigned char _zdata; /* flag: display file has Z coords */
|
||
unsigned char _depth; /* flag: display Z using depth cue */
|
||
} stack[9] = { { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
|
||
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
|
||
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
|
||
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
|
||
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
|
||
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
|
||
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
|
||
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
|
||
{ 0, 0, CHAR, 4, 1, 4, 0, 4, SOLID, 0, 0, 0, 0,
|
||
0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 },
|
||
};
|
||
|
||
#define char_scale stack[8]._cscale /* character scale factor * 4 */
|
||
/* _cscale must track _csi! */
|
||
static const unsigned char csi2csf[4] = { 2, 4, 6, 8 }; /* maps cs_index to " */
|
||
#define shift_out stack[8]._so /* flag: using shift-out char. set */
|
||
#define char_escape stack[8]._cesc /* perform POPR on char. term. match */
|
||
#define edge_intr_ena stack[8]._edgeintr /* generate intr. on edge transit */
|
||
#define lp_intensify stack[8]._bright /* if VT11, 20us bright spot;
|
||
if VS60, brighten the entity */
|
||
#define stop_intr_ena stack[8]._stopintr /* generate intr. on internal stop */
|
||
#define file_z_data stack[8]._zdata /* flag: display file has Z coords */
|
||
#define depth_cue_proc stack[8]._depth /* flag: display Z using depth cue */
|
||
|
||
/*
|
||
* Character String Terminate Register (VS60 only)
|
||
* Read/Write
|
||
* char. term. reg. enable 7
|
||
* character terminate code 6:0
|
||
*/
|
||
static int char_term = 0; /* char. processing POPRs after this */
|
||
|
||
/*
|
||
* Stack Address/Maintenance Register (VS60 only)
|
||
* Read/Write
|
||
* maint. sw. 4 15
|
||
* maint. sw. 3 14
|
||
* maint. sw. 2 13
|
||
* maint. sw. 1 12
|
||
* offset mode status 10
|
||
* jump to subr. ?rel. status 9 (diagnostic requires this be JSR abs.!)
|
||
* word 2 status 8
|
||
* word 1 status 7
|
||
* word 0 status 6
|
||
* stack reset status 5
|
||
* stack level select 4:2 (manual has this messed up)
|
||
* stack halfword select 1:0 (manual has this messed up)
|
||
*/
|
||
static unsigned char maint4 = 0; /* 1 bit: maintenance switch #4 */
|
||
static unsigned char maint3 = 0; /* 1 bit: maintenance switch #3 */
|
||
static unsigned char maint2 = 0; /* 1 bit: maintenance switch #2 */
|
||
static unsigned char maint1 = 0; /* 1 bit: maintenance switch #1 */
|
||
static unsigned char offset = 0; /* 1 bit: last data loaded offsets */
|
||
static unsigned char jsr = 0; /* 1 bit: last control was JSR ?rel. */
|
||
static int word_number = -2; /* tracks multiple data words */
|
||
#define CONTROL_MODE() (word_number == -1) /* true when in control mode */
|
||
#define DATA_MODE() (word_number >= 0) /* true when in data mode */
|
||
static struct frame *sp = &stack[8]; /* -> selected stack frame, or TOS */
|
||
#define STACK_EMPTY (sp == &stack[8]) /* "TOS" */
|
||
#define STACK_FULL (sp == &stack[0]) /* "BOS" */
|
||
static unsigned char stack_sel = 8<<2; /* 8 levels, 4 PDP-11 words per level */
|
||
/* stack_sel must track sp and TOS! */
|
||
|
||
/*
|
||
* Z Position Register, Depth Cue Option (VS60 only)
|
||
* Read/Write
|
||
* Z position register value[13:2] 11:0
|
||
*/
|
||
static int32 zpos = 0; /* (Z "position" reg. * 4) * PSCALEF */
|
||
/* note: offset has been applied! */
|
||
static int32 lp_zpos; /* (scaled) */
|
||
static int32 edge_zpos; /* (scaled) */
|
||
|
||
/*
|
||
* Z Offset Register, Depth Cue Option (VS60 only)
|
||
* Read/Write
|
||
* sign of X dynamic offset 15 (read) (VT48 manual has this confused)
|
||
* sign of Y dynamic offset 14 (read) (VT48 manual has this confused)
|
||
* sign of Z dynamic offset 13
|
||
* Z dynamic offset 11:0
|
||
*/
|
||
static unsigned char s_zoff = 0; /* sign bit for zoff (needed for -0) */
|
||
static int32 zoff = 0; /* Z offset register * PSCALEF */
|
||
|
||
/*
|
||
* Invisible state:
|
||
*/
|
||
static unsigned char char_irq = 0; /* intr. on illegal char in SO mode */
|
||
static unsigned char lphit_irq = 0; /* intr. on light-pen hit */
|
||
static unsigned char lpsw_irq = 0; /* intr. on tip-switch state change */
|
||
static unsigned char edge_irq = 0; /* intr. on edge transition */
|
||
|
||
static unsigned char lp0_sw_state = 0; /* last known LP tip-switch state */
|
||
static unsigned char blink_off = 0; /* set when blinking graphics is dark */
|
||
static unsigned char finish_jmpa = 0; /* reminder to fetch JMPA address */
|
||
static unsigned char finish_jsra = 0; /* reminder to fetch JSRA address */
|
||
|
||
static unsigned char more_vect = 0; /* remembers LP hit in middle of vec. */
|
||
static unsigned char more_arc = 0; /* remembers LP hit in middle of arc */
|
||
static int32 save_x0, save_y0, save_z0, save_x1, save_y1, save_z1;
|
||
/* CRT coords for rest of vector */
|
||
|
||
static unsigned char lp_suppress = 0; /* edge columns of char. (VT11 only) */
|
||
static unsigned char stroking = 0; /* set when drawing VS60 char strokes */
|
||
static unsigned char skip_start = 0; /* set between vis. char./arc strokes */
|
||
|
||
static unsigned char stopped = 1; /* display processor frozen */
|
||
static unsigned char sync_period = 0; /* frame sync period (msec) */
|
||
static unsigned char refresh_rate = 0; /* 2 bits:
|
||
00 => continuous display refresh
|
||
01 => 30 fps (60 fps if VT11)
|
||
10 => 40 fps (VS60)
|
||
11 => external sync (VS60) */
|
||
|
||
#if 0 /* this is accurate in simulated "real" time */
|
||
#define BLINK_COUNT 266 /* 266 milliseconds */
|
||
#else /* this looks better in actual real time (adjust for your host speed) */
|
||
#define BLINK_COUNT 67 /* 67 milliseconds */
|
||
#endif
|
||
|
||
unsigned char vt11_csp_w = VT11_CSP_W; /* horizontal character spacing */
|
||
unsigned char vt11_csp_h = VT11_CSP_H; /* vertical character spacing */
|
||
/* VS60 spacing depends on char scale; above are right for char scale x1 */
|
||
|
||
/* VS60 has a menu area to the right of the "main working surface" */
|
||
#define MENU_OFFSET (1024 + VR48_GUTTER) /* left edge of menu on CRT */
|
||
#define VR48_WIDTH (MENU_OFFSET + 128) /* X beyond this is not illuminated */
|
||
|
||
static int reduce; /* CRT units per actual pixel */
|
||
static int x_edge; /* 1023 or VR48_WIDTH-1, depending */
|
||
static int y_edge; /* 767 or 1023, depending on display */
|
||
#define ONCRT(x,y) ((x) >= 0 && (x) <= x_edge && (y) >= 0 && (y) <= y_edge)
|
||
|
||
/*
|
||
* Clipping-specific stuff.
|
||
* When a vector crosses the edge of the viewing window, the "edge flag" is set
|
||
* and the "edge indicator" indicates whether the first point on the visible
|
||
* segment is clipped. Apparently the VT11 does not draw the visible segment,
|
||
* but the VS60 will draw the segment (after a resume from an edge interrupt,
|
||
* if the interrupt was enabled). The VS60 will also post a second interrupt
|
||
* corresponding to the end of the visible segment, after setting the edge flag
|
||
* (again) and setting the edge indicator according to whether the last point
|
||
* on the visible segment was clipped.
|
||
* Note: a light-pen hit is possible on a drawn clipped segment.
|
||
*/
|
||
static int clip_vect = 0; /* set when clipped coords saved; bit-coded:
|
||
1 => entry clipped
|
||
2 => exit clipped */
|
||
static int clip_i; /* saved "intensify" bit */
|
||
static int32 clip_x0, clip_y0, clip_z0; /* CRT coords for entry point */
|
||
static int32 clip_x1, clip_y1, clip_z1; /* CRT coords for exit point */
|
||
|
||
/*
|
||
* Uncertain whether VS60 edge transitions in menu area are flagged and whether
|
||
* clipping takes menu width into account. Three possibilities:
|
||
*/
|
||
#define CLIPYMAX y_edge
|
||
#if 0 /* menu area never clipped (seems wrong) */
|
||
#define CLIPXMAX 1023
|
||
#define ONSCREEN(x,y) (menu || ((x) >= 0 && (x) <= CLIPXMAX \
|
||
&& (y) >= 0 && (y) <= CLIPYMAX))
|
||
#elif 0 /* menu area correctly clipped (unlikely) */
|
||
#define CLIPXMAX (menu ? 127 : 1023)
|
||
#define ONSCREEN(x,y) ((x) >= 0 && (x) <= CLIPXMAX \
|
||
&& (y) >= 0 && (y) <= CLIPYMAX)
|
||
#else /* menu area clipped same as main area */
|
||
#define CLIPXMAX 1023
|
||
#define ONSCREEN(x,y) ((x) >= 0 && (x) <= CLIPXMAX \
|
||
&& (y) >= 0 && (y) <= CLIPYMAX)
|
||
#endif
|
||
|
||
static void lineTwoStep(int32, int32, int32, int32, int32, int32);
|
||
/* forward reference */
|
||
|
||
/*
|
||
* calls to read/write VT11/VS60 CSRs
|
||
*
|
||
* Presumably the host looks at our state less often than we do(!)
|
||
* so we keep it in a form convenient to us, rather than as bit fields
|
||
* packed into "registers". The simulated VT48 register contents are
|
||
* converted to/from our internal variables by the following functions.
|
||
*/
|
||
|
||
int32
|
||
vt11_get_dpc(void)
|
||
{ INIT
|
||
/*
|
||
* The VT48 manual says that Maintenance Switch 1 causes the Buffered
|
||
* Data Bits register to be "entered into the DPC" so it can be
|
||
* examined by reading the DPC address, but details of when and how
|
||
* often that happens are not provided. Examination of the diagnostic
|
||
* test listings shows that relocation is applied and that only the DPC
|
||
* is involved when this switch is set.
|
||
*/
|
||
return ((maint1 ? bdb : DPC) + reloc) & 0177777;
|
||
}
|
||
|
||
void
|
||
vt11_set_dpc(uint16 d)
|
||
{ INIT
|
||
bdb = d; /* save all bits in case maint1 used */
|
||
DEBUGF("set DPC 0%06o\r\n", (unsigned)d);
|
||
/* Stack level is unaffected, except that stack_sel==037 goes to 040; this
|
||
fudge is necessary to pass DZVSC test 3, which misleadingly calls it
|
||
setting top-of-stack upon START (vt11_set_dpc(even)). If one instead
|
||
were to set TOS upon START, then several DZVSC diagnostics would fail! */
|
||
if (VS60 && !STACK_EMPTY && GETFIELD(stack_sel,1,0) == 3) {
|
||
stack_sel = GETFIELD(stack_sel,4,2) + 1; /* 1..8 */
|
||
sp = &stack[stack_sel]; /* [1..8] */
|
||
stack_sel <<= 2;
|
||
}
|
||
if (!TESTBIT(d,0)) { /* START */
|
||
DPC = d; /* load DPC */
|
||
sync_period = 0;
|
||
ext_stop = 0;
|
||
/* the following seem reasonable, but might be wrong */
|
||
finish_jmpa = finish_jsra = jsr = 0;
|
||
word_number = -2;
|
||
clip_vect = 0; /* discard clipped vector data */
|
||
#if 0 /* probably accurate mimicry, but ugly behavior */
|
||
if (edge_irq) {
|
||
xpos = PSCALE(edge_x);
|
||
ypos = PSCALE(edge_y);
|
||
}
|
||
#endif
|
||
} else { /* RESUME (after intr); DPC unchanged */
|
||
/* if resuming from LP hit interrupt, finish drawing rest of vector */
|
||
if (more_vect) {
|
||
unsigned char save_ena = lp0_intr_ena;
|
||
lp0_intr_ena = 0; /* one hit per vector is plenty */
|
||
lphit_irq = 0; /* or else lineTwoStep aborts again! */
|
||
/* line_counter is intact; draw rest of visible vector */
|
||
lineTwoStep(save_x0, save_y0, save_z0, save_x1, save_y1, save_z1);
|
||
lp0_intr_ena = save_ena;
|
||
}
|
||
if (more_arc) { /* remainder of chord was just drawn */
|
||
unsigned char save_ena = lp0_intr_ena;
|
||
lp0_intr_ena = 0; /* one hit per arc is plenty */
|
||
lphit_irq = 0; /* or else lineTwoStep aborts again! */
|
||
/* line_counter is intact; draw rest of visible arc */
|
||
/*XXX not yet implemented [conic{23}(<saved params>) needed]*/
|
||
lp0_intr_ena = save_ena;
|
||
}
|
||
if (!maint2) /* kludge to satify diagnostic test */
|
||
ext_stop = 0;
|
||
}
|
||
stopped = internal_stop = time_out = stack_over = stack_under = 0;
|
||
more_vect = more_arc = stroking = skip_start = 0;
|
||
so_flag = edge_indic = edge_flag = lp0_hit = lp1_hit = lp_suppress = 0;
|
||
lp0_down = lp0_up = lp1_down = lp1_up = 0;
|
||
char_irq = lphit_irq = lpsw_irq = edge_irq = name_irq = 0;
|
||
/* next vt11_cycle() will perform a fetch */
|
||
}
|
||
|
||
int32
|
||
vt11_get_mpr(void)
|
||
{
|
||
int32 ret;
|
||
INIT
|
||
ret = (internal_stop<<15) | (mode_field<<11) | (intensity<<8) |
|
||
(lp0_hit<<7) | (so_flag<<6) | (edge_indic<<5) | (italics<<4) |
|
||
(blink_ena<<3) | line_type;
|
||
|
||
if (VS60)
|
||
ret |= edge_flag<<2;
|
||
|
||
return ret;
|
||
}
|
||
|
||
void
|
||
vt11_set_mpr(uint16 d)
|
||
{ INIT
|
||
/* beeps the "bell" on the LK40 keyboard */
|
||
#if 0 /* probably doesn't hurt to do it for the VS60 also */
|
||
if (VT11) /* according to the VS60 specs */
|
||
#endif
|
||
display_beep();
|
||
}
|
||
|
||
int32
|
||
vt11_get_xpr(void)
|
||
{
|
||
int32 pos;
|
||
INIT
|
||
pos = lphit_irq ? lp_xpos : edge_irq ? edge_xpos : PNORM(xpos);
|
||
return (graphplot_step << 10) | GETFIELD(TWOSCOMP(pos),9,0);
|
||
}
|
||
|
||
void
|
||
vt11_set_xpr(uint16 d)
|
||
{ INIT
|
||
DEBUGF("set XPR: no effect\r\n");
|
||
}
|
||
|
||
int32
|
||
vt11_get_ypr(void)
|
||
{
|
||
int32 pos;
|
||
INIT
|
||
pos = lphit_irq ? lp_ypos : edge_irq ? edge_ypos : PNORM(ypos);
|
||
return (GETFIELD(char_buf,5,0) << 10) | GETFIELD(TWOSCOMP(pos),9,0);
|
||
}
|
||
|
||
void
|
||
vt11_set_ypr(uint16 d)
|
||
{ INIT
|
||
DEBUGF("set YPR: no effect\r\n");
|
||
}
|
||
|
||
/* All the remaining registers pertain to the VS60 only. */
|
||
|
||
int32
|
||
vt11_get_rr(void)
|
||
{ INIT
|
||
return reloc >> 6;
|
||
}
|
||
|
||
void
|
||
vt11_set_rr(uint16 d)
|
||
{ INIT
|
||
reloc = (uint32)GETFIELD(d,11,0) << 6;
|
||
}
|
||
|
||
int32
|
||
vt11_get_spr(void)
|
||
{ INIT
|
||
return (busy<<15) | (stack_over<<13) | (stack_under<<12) | (time_out<<11) |
|
||
(char_rotate<<10) | (cs_index<<8) | (ext_stop<<7) |
|
||
(menu<<6) | (((DPC + reloc) & 0600000L) >> 12) | vector_scale;
|
||
}
|
||
|
||
void
|
||
vt11_set_spr(uint16 d)
|
||
{ INIT
|
||
ext_stop = TESTBIT(d,7); /* stop occurs at end of next display cycle */
|
||
|
||
if (ext_stop /* not maskable */) {
|
||
stopped = 1; /* (asynchronous with display cycle) */
|
||
vt_stop_intr(); /* post stop interrupt to host */
|
||
}
|
||
}
|
||
|
||
int32
|
||
vt11_get_xor(void)
|
||
{
|
||
int32 off, pos;
|
||
INIT
|
||
off = PNORM(xoff);
|
||
pos = lphit_irq ? lp_xpos : edge_irq ? edge_xpos : PNORM(xpos);
|
||
return (GETFIELD(TWOSCOMP(pos),13,10)<<12) | GETFIELD(ABS(off),11,0);
|
||
}
|
||
|
||
void
|
||
vt11_set_xor(uint16 d)
|
||
{ INIT
|
||
xoff = PSCALE(GETFIELD(d,11,0));
|
||
s_xoff = TESTBIT(d,13);
|
||
if (s_xoff)
|
||
xoff = -xoff;
|
||
}
|
||
|
||
int32
|
||
vt11_get_yor(void)
|
||
{
|
||
int32 off, pos;
|
||
INIT
|
||
off = PNORM(yoff);
|
||
pos = lphit_irq ? lp_ypos : edge_irq ? edge_ypos : PNORM(ypos);
|
||
return (GETFIELD(TWOSCOMP(pos),13,10)<<12) | GETFIELD(ABS(off),11,0);
|
||
}
|
||
|
||
void
|
||
vt11_set_yor(uint16 d)
|
||
{ INIT
|
||
yoff = PSCALE(GETFIELD(d,11,0));
|
||
s_yoff = TESTBIT(d,13);
|
||
if (s_yoff)
|
||
yoff = -yoff;
|
||
}
|
||
|
||
int32
|
||
vt11_get_anr(void)
|
||
{ INIT
|
||
DEBUGF("get ANR: no effect\r\n");
|
||
return (search << 12) | assoc_name; /* [garbage] */
|
||
}
|
||
|
||
void
|
||
vt11_set_anr(uint16 d)
|
||
{ INIT
|
||
if (TESTBIT(d,14))
|
||
search = GETFIELD(d,13,12);
|
||
if (TESTBIT(d,11))
|
||
assoc_name = GETFIELD(d,10,0);
|
||
}
|
||
|
||
int32
|
||
vt11_get_scr(void)
|
||
{ INIT
|
||
return (int0_scope<<15) | (lp0_hit<<14) | (lp0_down<<13) | (lp0_up<<12) |
|
||
(lp0_intr_ena<<11) | (lp0_sw_intr_ena<<10) | (int1_scope<<9) |
|
||
(lp1_hit<<8) | (lp1_down<<7) | (lp1_up<<6) | (lp1_intr_ena<<5) |
|
||
(lp1_sw_intr_ena<<4) | (color << 2);
|
||
}
|
||
|
||
void
|
||
vt11_set_scr(uint16 d)
|
||
{ INIT
|
||
if (maint3) {
|
||
if (TESTBIT(d,14) && lp0_intr_ena) {
|
||
if (!lphit_irq) { /* ensure correct position registers reported */
|
||
lp_xpos = PNORM(xpos);
|
||
lp_ypos = PNORM(ypos);
|
||
lp_zpos = PNORM(zpos);
|
||
}
|
||
lp0_hit = lphit_irq = 1;
|
||
}
|
||
if (TESTBIT(d,13)) {
|
||
lp0_down = 1; /* the manual seems to have this backward */
|
||
if (lp0_sw_intr_ena)
|
||
lpsw_irq = 1;
|
||
}
|
||
if (TESTBIT(d,12)) {
|
||
lp0_up = 1; /* the manual seems to have this backward */
|
||
if (lp0_sw_intr_ena)
|
||
lpsw_irq = 1;
|
||
}
|
||
if (TESTBIT(d,8) && lp1_intr_ena) {
|
||
if (!lphit_irq) { /* ensure correct position registers reported */
|
||
lp_xpos = PNORM(xpos);
|
||
lp_ypos = PNORM(ypos);
|
||
lp_zpos = PNORM(zpos);
|
||
}
|
||
lp1_hit = lphit_irq = 1;
|
||
}
|
||
if (TESTBIT(d,7)) {
|
||
lp1_down = 1;
|
||
if (lp1_sw_intr_ena)
|
||
lpsw_irq = 1;
|
||
}
|
||
if (TESTBIT(d,6)) {
|
||
lp1_up = 1;
|
||
if (lp1_sw_intr_ena)
|
||
lpsw_irq = 1;
|
||
}
|
||
if (lpsw_irq || lphit_irq /* && DATA_MODE() */)
|
||
vt_lpen_intr();
|
||
}
|
||
}
|
||
|
||
int32
|
||
vt11_get_nr(void)
|
||
{ INIT
|
||
return (name_irq<<15) | (search<<12) | name;
|
||
}
|
||
|
||
void
|
||
vt11_set_nr(uint16 d)
|
||
{ INIT
|
||
DEBUGF("set NR: no effect\r\n");
|
||
}
|
||
|
||
int32
|
||
vt11_get_sdr(void)
|
||
{
|
||
struct frame *p;
|
||
INIT
|
||
p = &stack[GETFIELD(stack_sel,4,2)]; /* [0..7], 8 (TOS) => 0 */
|
||
switch (GETFIELD(stack_sel,1,0)) { /* 16-bit "byte" within frame */
|
||
case 0:
|
||
return p->_dpc; /* DPC bit#0 is always 0 */
|
||
|
||
case 1:
|
||
return (p->_name << 4) | p->_mode;
|
||
|
||
case 2:
|
||
return (p->_italics << 15) | (p->_vscale << 11) | (p->_csi << 9) |
|
||
(p->_crotate << 7) | (p->_intens << 4) | ((int)p->_color << 2) |
|
||
p->_ltype;
|
||
|
||
case 3:
|
||
return (p->_blink << 15) | (p->_so << 14) | (p->_menu << 13) |
|
||
(p->_cesc << 12) | (p->_edgeintr << 11) | (p->_zdata << 10) |
|
||
(p->_depth << 8) | (p->_lp1swintr << 7) |
|
||
(p->_lp0swintr << 6) | (p->_lp1intr << 5) | (p->_inten1 << 4) |
|
||
(p->_lp0intr << 3) | (p->_inten0 << 2) | ((!p->_bright) << 1) |
|
||
p->_stopintr;
|
||
}
|
||
/*NOTREACHED*/
|
||
return 0;
|
||
}
|
||
|
||
void
|
||
vt11_set_sdr(uint16 d)
|
||
{ INIT
|
||
DEBUGF("set SDR: no effect\r\n");
|
||
}
|
||
|
||
int32
|
||
vt11_get_str(void)
|
||
{ INIT
|
||
return char_term;
|
||
}
|
||
|
||
void
|
||
vt11_set_str(uint16 d)
|
||
{ INIT
|
||
if (TESTBIT(d,7))
|
||
char_term = GETFIELD(d,6,0);
|
||
}
|
||
|
||
int32
|
||
vt11_get_sar(void)
|
||
{
|
||
int32 ret;
|
||
INIT
|
||
ret = (maint4<<15) | (maint3<<14) | (maint2<<13) | (maint1<<12) |
|
||
(offset<<10) | (jsr<<9) | stack_sel /*includes bit 5=TOS [level 8]*/;
|
||
switch (word_number) {
|
||
case -1: /* control mode reported as word 0,
|
||
according to VT48 ES */
|
||
case 0:
|
||
ret |= 1<<6;
|
||
break;
|
||
case 1:
|
||
ret |= 1<<7;
|
||
break;
|
||
case 2:
|
||
ret |= 1<<8;
|
||
break;
|
||
/* others (including -1) not reportable */
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
void
|
||
vt11_set_sar(uint16 d)
|
||
{ INIT
|
||
maint4 = TESTBIT(d,15); /* 1 => synch. processing pipeline */
|
||
maint3 = TESTBIT(d,14); /* 1 => copy delta,tangent to x,y pos */
|
||
maint2 = TESTBIT(d,13); /* 1 => set single-step mode */
|
||
maint1 = TESTBIT(d,12); /* 1 => vt11_get_dpc will return bdb */
|
||
if (TESTBIT(d,5)) {
|
||
sp = &stack[8]; /* reset stack pointer to TOS */
|
||
stack_sel = (8<<2) /* TOS amounts to level 8 */
|
||
| TESTBIT(stack_sel,0); /* preserve PDP-11 word sel. */
|
||
} else {
|
||
stack_sel = GETFIELD(d,4,0);
|
||
sp = &stack[GETFIELD(stack_sel,4,2)]; /* [0..7] */
|
||
}
|
||
}
|
||
|
||
/* registers used with the VS60 depth cueing option */
|
||
|
||
/*
|
||
* Since there is no support for hardware 3D rotation or viewing transform, the
|
||
* only effect of the Z coordinate is to modulate beam intensity along a vector
|
||
* to give the illusion that greater Z coordinates are closer (brighter).
|
||
* This is known as "depth cueing" and is implemented in dintens().
|
||
*/
|
||
|
||
int32
|
||
vt11_get_zpr(void)
|
||
{
|
||
int32 pos;
|
||
INIT
|
||
pos = lphit_irq ? lp_zpos : edge_irq ? edge_zpos : PNORM(zpos);
|
||
return GETFIELD(TWOSCOMP(pos),13,2);
|
||
}
|
||
|
||
void
|
||
vt11_set_zpr(uint16 d)
|
||
{ INIT
|
||
DEBUGF("set ZPR: no effect\r\n");
|
||
}
|
||
|
||
int32
|
||
vt11_get_zor(void)
|
||
{
|
||
int32 off, ret;
|
||
INIT
|
||
off = PNORM(zoff);
|
||
ret = GETFIELD(ABS(off),11,0);
|
||
if (s_xoff) /* (VT48 manual has this confused) */
|
||
ret |= 1<<15;
|
||
if (s_yoff) /* (VT48 manual has this confused) */
|
||
ret |= 1<<14;
|
||
if (s_zoff)
|
||
ret |= 1<<13;
|
||
return ret;
|
||
}
|
||
|
||
void
|
||
vt11_set_zor(uint16 d)
|
||
{ INIT
|
||
zoff = PSCALE(GETFIELD(d,11,0));
|
||
s_zoff = TESTBIT(d,13);
|
||
if (s_zoff)
|
||
zoff = -zoff;
|
||
}
|
||
|
||
void
|
||
vt11_reset(void *dev, int debug)
|
||
{
|
||
if (dev) {
|
||
vt11_dptr = dev;
|
||
vt11_dbit = debug;
|
||
}
|
||
|
||
/* make sure display code has been initialized */
|
||
if (!vt11_init) /* (SIMH invokes before display type is set) */
|
||
return; /* wait until last moment */
|
||
|
||
if (VS60) {
|
||
/* VS60 character spacing depends on char scale; these are for x1 */
|
||
vt11_csp_w = 14; /* override VT11 options */
|
||
vt11_csp_h = 24;
|
||
} /* else assume already set up for desired VT11 behavior */
|
||
|
||
x_edge = display_xpoints() - 1;
|
||
y_edge = display_ypoints() - 1;
|
||
reduce = display_scale();
|
||
|
||
/* reset VT11/VT48 to initial default internal state: */
|
||
|
||
/* clear interrupts, BDB, etc. */
|
||
vt11_set_dpc(0);
|
||
/* some of the following should probably be moved to vt11_set_dpc([even]) */
|
||
stopped = int0_scope = 1; /* idle, console 0 enabled */
|
||
lp0_sw_state = display_lp_sw; /* sync with mouse button #1 */
|
||
shift_out = int1_scope = stop_intr_ena = blink_off = 0;
|
||
italics = blink_ena = char_rotate = menu = search = offset = 0;
|
||
lp0_sw_intr_ena = lp1_sw_intr_ena = lp0_intr_ena = lp1_intr_ena = 0;
|
||
file_z_data = edge_intr_ena = depth_cue_proc = char_escape = 0;
|
||
maint1 = maint2 = maint3 = maint4 = 0;
|
||
refresh_rate = 0;
|
||
char_buf = char_term = 0;
|
||
assoc_name = name = 0;
|
||
reloc = 0;
|
||
xpos = ypos = zpos = xoff = yoff = zoff = 0;
|
||
s_xoff = s_yoff = s_zoff = 0;
|
||
graphplot_step = 0;
|
||
mode_field = 0;
|
||
graphic_mode = CHAR;
|
||
line_type = SOLID;
|
||
color = GREEN;
|
||
lp_intensify = 1;
|
||
cs_index = 1;
|
||
char_scale = vector_scale = 4;
|
||
intensity = 4;
|
||
sp = &stack[8];
|
||
stack_sel = 8<<2; /* PDP-11 word selector also cleared */
|
||
|
||
/* following necessary in case the stack is inspected via stack data reg. */
|
||
{ int i;
|
||
for (i = 0; i < 8; ++i)
|
||
memset(&stack[i], 0, sizeof(struct frame));
|
||
}
|
||
}
|
||
|
||
/* VS60 display subroutine support (see stack layout for SDR, above) */
|
||
|
||
static void
|
||
push()
|
||
{
|
||
stack_over = STACK_FULL; /* BOS? */
|
||
if (!stack_over) {
|
||
--sp;
|
||
*sp = stack[8]; /* copy current parameters */
|
||
/* (including *old* DPC) */
|
||
stack_sel -= 1<<2;
|
||
/* XXX should stack_sel stack-byte bits be cleared? */
|
||
}
|
||
/* else will generate interrupt soon after return */
|
||
}
|
||
|
||
static void
|
||
pop(int restore)
|
||
{
|
||
stack_under = STACK_EMPTY; /* TOS? */
|
||
if (!stack_under) {
|
||
stack[8] = *sp; /* restore parameters (including DPC) */
|
||
++sp;
|
||
stack_sel += 1<<2;
|
||
/* XXX should stack_sel stack-byte bits be cleared? maybe for TOS? */
|
||
}
|
||
/* else will generate interrupt soon after return */
|
||
}
|
||
|
||
/* compute depth-cued display intensity from current display-file intensity */
|
||
|
||
int
|
||
dintens(int32 z)
|
||
{
|
||
int i = intensity;
|
||
|
||
if (depth_cue_proc) { /* apply depth cue */
|
||
i += i * z / 1024; /* XXX is z scaled properly? */
|
||
if (i > 7)
|
||
i = 7;
|
||
else if (i < 0)
|
||
i = 0;
|
||
}
|
||
i += DISPLAY_INT_MAX - 7;
|
||
return i >= DISPLAY_INT_MIN ? i : DISPLAY_INT_MIN;
|
||
}
|
||
|
||
/*
|
||
* Note: It would be more efficient to work directly with display intensity
|
||
* levels than with Z coordinates, since the vast majority of dintens()
|
||
* computations result in the same display intensity level as the previous
|
||
* such computation. However, compared to the rest of the processing per
|
||
* pixel, this computation doesn't seem too expensive, so optimization isn't
|
||
* necessary.
|
||
*/
|
||
|
||
/* illuminate pixel in raster image */
|
||
|
||
static void
|
||
illum3(int32 x, int32 y, int32 z)
|
||
/* virtual CRT units (offset and normalized) */
|
||
{
|
||
int i; /* display intensity level */
|
||
|
||
/* don't update position registers! */
|
||
|
||
/* coords might be outside viewable area, e.g. clipped italic character */
|
||
if (!ONCRT(x, y) || !int0_scope)
|
||
return;
|
||
|
||
if (blink_ena && blink_off) /* blinking & in dark phase */
|
||
return;
|
||
|
||
i = dintens(z);
|
||
|
||
if (display_point((int)x, (int)y, i, 0) /* XXX VS60 might switch color */
|
||
/* VT11, per maintenance spec, has threshold 6 for CHAR, 4 for others */
|
||
/* but the classic Lunar Lander uses 3 for its menu and thrust bar! */
|
||
/* I seem to recall that both thresholds were 4 for the VS60 (VR48). */
|
||
#if 0
|
||
&& (i >= (DISPLAY_INT_MAX-1) /* (using i applies depth cueing) */
|
||
|| (graphic_mode != CHAR && i >= (DISPLAY_INT_MAX-3)))
|
||
#else
|
||
/* The following imposes thresholds of 3 for all graphic objects. */
|
||
&& (i >= (DISPLAY_INT_MAX-4)) /* (using i applies depth cueing) */
|
||
#endif
|
||
&& !lp_suppress) {
|
||
lp0_hit = 1;
|
||
if (lp0_intr_ena)
|
||
lphit_irq = 1; /* will lead to an interrupt */
|
||
/*
|
||
* Save LP hit coordinates so CPU can look at them; the virtual position
|
||
* registers cannot be reported on LP interrupt, since they track the
|
||
* (pre-clipping) end of the vector that was being drawn.
|
||
*/
|
||
lp_xpos = x;
|
||
if (menu)
|
||
lp_xpos -= MENU_OFFSET;
|
||
lp_ypos = y;
|
||
lp_zpos = z;
|
||
if (lp_intensify) /* [technically shouldn't exceed max] */
|
||
display_point((int)x, (int)y, DISPLAY_INT_MAX, 0);
|
||
/* XXX appropriate for VT11; what about VS60? chars? */
|
||
}
|
||
}
|
||
|
||
#define illum2(x,y) illum3(x, y, PNORM(zpos)) /* may be depth cued */
|
||
/* the extra overhead if not depth cueing is not much */
|
||
|
||
static void
|
||
point3(int i, int32 x1, int32 y1, int32 z1, int detect_edge)
|
||
/* VSCALEd, offset coordinates (z1 * 4) */
|
||
{
|
||
int32 x0 = PNORM(xpos), y0 = PNORM(ypos);
|
||
|
||
if (detect_edge) {
|
||
edge_indic = ONSCREEN(x0, y0); /* first test */
|
||
edge_flag = !ONSCREEN(x0, y0); /* first test */
|
||
} else {
|
||
edge_indic = 0;
|
||
edge_flag = 0;
|
||
}
|
||
xpos = x1;
|
||
ypos = y1;
|
||
zpos = z1;
|
||
x1 = PNORM(xpos);
|
||
y1 = PNORM(ypos);
|
||
z1 = PNORM(zpos);
|
||
if (detect_edge) {
|
||
edge_indic &= !ONSCREEN(x1, y1); /* second test */
|
||
edge_flag &= ONSCREEN(x1, y1); /* second test */
|
||
edge_flag |= edge_indic;
|
||
if (edge_flag) {
|
||
if (edge_intr_ena) {
|
||
edge_xpos = x1;
|
||
edge_ypos = y1;
|
||
edge_zpos = z1;
|
||
edge_irq = 1;
|
||
#if 0 /* XXX uncertain whether point is displayed during edge intr. */
|
||
return; /* point not displayed */
|
||
#endif
|
||
} else
|
||
edge_flag = 0;
|
||
}
|
||
}
|
||
if (i && ONSCREEN(x1, y1)) {
|
||
if (menu)
|
||
illum3(x1 + MENU_OFFSET, y1, z1);
|
||
else
|
||
illum3(x1, y1, z1);
|
||
}
|
||
}
|
||
|
||
#define point2(i,x,y,e) point3(i, x, y, zpos, e)
|
||
/* the extra overhead if not depth cueing is not much */
|
||
|
||
/* 4 bit counter, fed from div 2 clock (to compensate for raster algorithm) */
|
||
/* XXX check display against example photos to see if div 2 is right */
|
||
static unsigned char line_counter;
|
||
#define LC1 02
|
||
#define LC2 04
|
||
#define LC3 010
|
||
#define LC4 020
|
||
|
||
/* point on a line (apply line style) */
|
||
static void
|
||
lpoint(int32 x, int32 y, int32 z)
|
||
/* X, Y are in window-system screen pixel units */
|
||
/* Z is in virtual CRT units (offset and normalized) */
|
||
{
|
||
int i, on = (line_type == SOLID) || stroking; /* on for sure */
|
||
|
||
if (!on) { /* see if in visible portion of cycle */
|
||
for (i = 0; i < reduce; ++i) {
|
||
switch (line_type) {
|
||
case LONG_DASH:
|
||
if (line_counter & LC4)
|
||
on = 1;
|
||
break;
|
||
case SHORT_DASH:
|
||
if (line_counter & LC3)
|
||
on = 1;
|
||
break;
|
||
case DOT_DASH:
|
||
/* LC(2:1)H * LC3L + LC4L */
|
||
if (((line_counter & (LC1|LC2)) == (LC1|LC2)
|
||
&& !(line_counter & LC3)) || !(line_counter & LC4))
|
||
on = 1;
|
||
break;
|
||
case SOLID:
|
||
break;
|
||
}
|
||
|
||
--line_counter;
|
||
}
|
||
}
|
||
|
||
if (on)
|
||
/* convert back from actual screen pixels to emulated CRT coordinates */
|
||
/* note: Z coordinate is already in virtual CRT units */
|
||
illum3(x * reduce, y * reduce, z);
|
||
}
|
||
|
||
/*
|
||
* 2-step algorithm, developed by Xiaolin Wu
|
||
* from http://graphics.lcs.mit.edu/~mcmillan/comp136/Lecture6/Lines.html
|
||
*
|
||
* The two-step algorithm takes the interesting approach of treating
|
||
* line drawing as a automaton, or finite state machine. If one looks
|
||
* at the possible configurations that the next two pixels of a line,
|
||
* it is easy to see that only a finite set of possiblities exist.
|
||
* If line styles weren't involved, the line could be drawn symmetrically
|
||
* from both ends toward the midpoint.
|
||
* Rasterization is done using actual screen pixel units, not emulated device
|
||
* coordinates!
|
||
*
|
||
* The Z coordinate just goes along for the ride. It is computed thusly:
|
||
* Let N = # steps in major direction (X or Y)
|
||
* i = step number
|
||
* dZ = Z1 - Z0
|
||
* Then Zi = floor(Z0 + dZ*(i+0.5)/N) 0.5 centers steps
|
||
* Zi = floor((2*N*Z0 + dZ + 2*i*dZ) / (2*N))
|
||
* The numerator at step i is
|
||
* Znum(i) = Znum(i-1) + 2*dZ
|
||
* with Znum(0) = 2*N*Z0 + dZ
|
||
*/
|
||
|
||
static void
|
||
lineTwoStep(int32 x0, int32 y0, int32 z0, int32 x1, int32 y1, int32 z1)
|
||
/* virtual CRT units (offset and normalized) */
|
||
{
|
||
int32 dx, dy, dz;
|
||
int stepx, stepy;
|
||
|
||
/* when clipping is implemented, coords should always be on-screen */
|
||
|
||
/* convert from emulated CRT units to actual screen pixels */
|
||
x0 /= reduce;
|
||
y0 /= reduce;
|
||
x1 /= reduce;
|
||
y1 /= reduce;
|
||
/* note: Z coords remain in virtual CRT units */
|
||
|
||
dx = x1 - x0;
|
||
dy = y1 - y0;
|
||
dz = z1 - z0;
|
||
|
||
/* XXX there could be fast special cases for "basic vectors" */
|
||
|
||
if (dx >= 0)
|
||
stepx = 1;
|
||
else {
|
||
dx = -dx;
|
||
stepx = -1;
|
||
}
|
||
if (dy >= 0)
|
||
stepy = 1;
|
||
else {
|
||
dy = -dy;
|
||
stepy = -1;
|
||
}
|
||
|
||
#define TPOINT do { znum += dz; /* 2 * original_dz */ \
|
||
z0 = znum / twoN; /* truncates */ \
|
||
if (lphit_irq && !stroking) goto hit; \
|
||
/* XXX longjmp from hit detector may be more efficient */ \
|
||
lpoint(x0, y0, z0); \
|
||
} while (0)
|
||
|
||
if (!skip_start) /* not for continuing stroke when VS60 char. or arc */
|
||
lpoint(x0, y0, z0); /* (could have used TPOINT) */
|
||
|
||
if (dx == 0 && dy == 0) /* following algorithm won't work */
|
||
return; /* just the one dot */
|
||
/* XXX not accurate for vector in Z direction */
|
||
|
||
if (dx > dy) {
|
||
int32 length = (dx - 1) / 2;
|
||
int extras = (dx - 1) & 1;
|
||
int32 incr2 = (dy * 4) - (dx * 2);
|
||
long twoN = 2 * dx, znum = twoN * z0 + dz;
|
||
dz *= 2;
|
||
if (incr2 < 0) {
|
||
int32 c = dy * 2;
|
||
int32 incr1 = c * 2;
|
||
int32 d = incr1 - dx;
|
||
int32 i;
|
||
for (i = 0; i < length; i++) {
|
||
x0 += stepx;
|
||
if (d < 0) { /* Pattern: */
|
||
TPOINT; /* x o o */
|
||
x0 += stepx;
|
||
TPOINT;
|
||
d += incr1;
|
||
}
|
||
else {
|
||
if (d < c) { /* Pattern: */
|
||
TPOINT; /* o */
|
||
y0 += stepy; /* x o */
|
||
} else { /* Pattern: */
|
||
y0 += stepy; /* o o */
|
||
TPOINT; /* x */
|
||
}
|
||
x0 += stepx;
|
||
TPOINT;
|
||
d += incr2;
|
||
}
|
||
}
|
||
if (extras > 0) {
|
||
x0 += stepx;
|
||
if (d >= c)
|
||
y0 += stepy;
|
||
TPOINT;
|
||
}
|
||
|
||
} else {
|
||
int32 c = (dy - dx) * 2; /* negative */
|
||
int32 incr1 = c * 2; /* negative */
|
||
int32 d = incr1 + dx;
|
||
int32 i;
|
||
for (i = 0; i < length; i++) {
|
||
x0 += stepx;
|
||
if (d > 0) { /* Pattern: */
|
||
y0 += stepy; /* o */
|
||
TPOINT; /* o */
|
||
x0 += stepx; /* x */
|
||
y0 += stepy;
|
||
TPOINT;
|
||
d += incr1;
|
||
} else {
|
||
if (d < c) { /* Pattern: */
|
||
TPOINT; /* o */
|
||
y0 += stepy; /* x o */
|
||
} else { /* Pattern: */
|
||
y0 += stepy; /* o o */
|
||
TPOINT; /* x */
|
||
}
|
||
x0 += stepx;
|
||
TPOINT;
|
||
d += incr2;
|
||
}
|
||
}
|
||
if (extras > 0) {
|
||
x0 += stepx;
|
||
if (d >= c)
|
||
y0 += stepy;
|
||
TPOINT;
|
||
}
|
||
}
|
||
|
||
} else { /* dy >= dx */
|
||
int32 length = (dy - 1) / 2;
|
||
int extras = (dy - 1) & 1;
|
||
int32 incr2 = (dx * 4) - (dy * 2);
|
||
long twoN = 2 * dy, znum = twoN * z0 + dz;
|
||
dz *= 2;
|
||
if (incr2 < 0) {
|
||
int32 c = dx * 2;
|
||
int32 incr1 = c * 2;
|
||
int32 d = incr1 - dy;
|
||
int32 i;
|
||
for (i = 0; i < length; i++) {
|
||
y0 += stepy;
|
||
if (d < 0) { /* Pattern: */
|
||
TPOINT; /* o */
|
||
y0 += stepy; /* o */
|
||
TPOINT; /* x */
|
||
d += incr1;
|
||
} else {
|
||
if (d < c) { /* Pattern: */
|
||
TPOINT; /* o */
|
||
x0 += stepx; /* o */
|
||
/* x */
|
||
} else { /* Pattern: */
|
||
x0 += stepx; /* o */
|
||
TPOINT; /* o */
|
||
/* x */
|
||
}
|
||
y0 += stepy;
|
||
TPOINT;
|
||
d += incr2;
|
||
}
|
||
}
|
||
if (extras > 0) {
|
||
y0 += stepy;
|
||
if (d >= c)
|
||
x0 += stepx;
|
||
TPOINT;
|
||
}
|
||
|
||
} else {
|
||
int32 c = (dx - dy) * 2; /* nonpositive */
|
||
int32 incr1 = c * 2; /* nonpositive */
|
||
int32 d = incr1 + dy;
|
||
int32 i;
|
||
for (i = 0; i < length; i++) {
|
||
y0 += stepy;
|
||
if (d > 0) { /* Pattern: */
|
||
x0 += stepx;
|
||
TPOINT; /* o */
|
||
y0 += stepy; /* o */
|
||
x0 += stepx; /* x */
|
||
TPOINT;
|
||
d += incr1;
|
||
} else {
|
||
if (d < c) { /* Pattern: */
|
||
TPOINT; /* o */
|
||
x0 += stepx; /* o */
|
||
/* x */
|
||
} else { /* Pattern: */
|
||
x0 += stepx; /* o */
|
||
TPOINT; /* o */
|
||
/* x */
|
||
}
|
||
y0 += stepy;
|
||
TPOINT;
|
||
d += incr2;
|
||
}
|
||
}
|
||
if (extras > 0) {
|
||
y0 += stepy;
|
||
if (d >= c)
|
||
x0 += stepx;
|
||
TPOINT;
|
||
}
|
||
}
|
||
}
|
||
lpoint(x1, y1, z1); /* not TPOINT (0-length vector on resume) */
|
||
return;
|
||
|
||
/* here if LP hit interrupt during rendering */
|
||
hit:
|
||
more_vect = 1;
|
||
save_x0 = x0 * reduce;
|
||
save_y0 = y0 * reduce;
|
||
save_z0 = z0;
|
||
save_x1 = x1 * reduce;
|
||
save_y1 = y1 * reduce;
|
||
save_z1 = z1;
|
||
/* line_counter is static and thus will be intact upon resume */
|
||
} /* lineTwoStep */
|
||
|
||
/*
|
||
* Clip segment to only that portion, if any, visible within the window.
|
||
* Returns: -1 visible and not clipped
|
||
* 0 invisible
|
||
* 1,2,3 visible and clipped (clipped coords stashed);
|
||
* bit-coded: 1 => entry clipped, 2=> exit clipped
|
||
*
|
||
* The Z coordinate just goes along for the ride.
|
||
*/
|
||
int
|
||
clip3(int32 x0, int32 y0, int32 z0, int32 x1, int32 y1, int32 z1)
|
||
{
|
||
int code0, code1; /* Cohen-Sutherland endpoint codes */
|
||
/* remaining variables are used in modified Liang-Barsky algorithm: */
|
||
int32 rdx, rdy, rdz; /* x0-x1, y0-y1, z0-z1 */
|
||
int32 tn; /* Edge parameter: numerator */
|
||
int32 tPEn, tPEd, tPLn, tPLd; /* Enter/Leave params: numer, denom */
|
||
int clipped; /* potential clip_vect value */
|
||
|
||
/*
|
||
* Use the first parts of the Cohen-Sutherland algorithm to detect
|
||
* all IN-to-IN cases and OUT-to-OUT along the same side, each of
|
||
* which is trivially handled without needing any clipping actions.
|
||
|
||
* The idea is that the extended window edges divide the plane into
|
||
* 9 regions; the segment endpoints are assigned bit-codes that
|
||
* indicate which of the 3 X sections and which of the 3 Y sections
|
||
* each point lies in; then simple tests on the codes can detect
|
||
* the desired "trivial" cases, which are the most common.
|
||
*/
|
||
|
||
/* assign X/Y region codes to the endpoints */
|
||
|
||
if (y0 > CLIPYMAX)
|
||
code0 = 1;
|
||
else if (y0 < 0)
|
||
code0 = 2;
|
||
else
|
||
code0 = 0;
|
||
|
||
if (x0 > CLIPXMAX)
|
||
code0 |= 4;
|
||
else if (x0 < 0)
|
||
code0 |= 8;
|
||
|
||
if (y1 > CLIPYMAX)
|
||
code1 = 1;
|
||
else if ( y1 < 0 )
|
||
code1 = 2;
|
||
else
|
||
code1 = 0;
|
||
|
||
if (x1 > CLIPXMAX)
|
||
code1 |= 4;
|
||
else if ( x1 < 0 )
|
||
code1 |= 8;
|
||
|
||
if (code0 == code1) { /* endpoints lie in same region */
|
||
if (code0 == 0) /* ON to ON; trivially visible */
|
||
return -1;
|
||
else /* OFF to OFF and trivially invisible */
|
||
return 0;
|
||
}
|
||
|
||
/* Endpoints are now known to lie in different regions. */
|
||
|
||
if ((code0 & code1) != 0) /* OFF to OFF and trivially invisible */
|
||
return 0;
|
||
|
||
/* Handle horizontal and vertical cases separately,
|
||
both for speed and to simplify later computations. */
|
||
|
||
rdx = x0 - x1;
|
||
rdy = y0 - y1;
|
||
rdz = z0 - z1;
|
||
|
||
if (rdx == 0) { /* vertical; has a visible portion! */
|
||
clipped = 0;
|
||
/* Using the direction allows us to save one test. */
|
||
if (rdy < 0) { /* directed upward */
|
||
if (y1 > CLIPYMAX) {
|
||
clipped = 2;
|
||
y1 = CLIPYMAX; /* clip */
|
||
z1 = z0 + rdz * (y1 - y0) / rdy;
|
||
}
|
||
if (y0 < 0) {
|
||
clipped |= 1;
|
||
z0 -= rdz * y0 / rdy;
|
||
y0 = 0; /* clip */
|
||
}
|
||
} else { /* directed downward */
|
||
if (y0 > CLIPYMAX) {
|
||
clipped = 1;
|
||
y0 = CLIPYMAX; /* clip */
|
||
z0 = z1 + rdz * (y0 - y1) / rdy;
|
||
}
|
||
if (y1 < 0) {
|
||
clipped |= 2;
|
||
z1 -= rdz * y1 / rdy;
|
||
y1 = 0; /* clip */
|
||
}
|
||
}
|
||
goto stash;
|
||
}
|
||
|
||
if (rdy == 0) { /* horizontal; has a visible portion! */
|
||
clipped = 0;
|
||
/* Using the direction allows us to save one test. */
|
||
if (rdx < 0) { /* directed rightward */
|
||
if (x1 > CLIPXMAX) {
|
||
clipped |= 2;
|
||
x1 = CLIPXMAX; /* clip */
|
||
z1 = z0 + rdz * (x1 - x0) / rdx;
|
||
}
|
||
if (x0 < 0) {
|
||
clipped = 1;
|
||
z0 -= rdz * x0 / rdx;
|
||
x0 = 0; /* clip */
|
||
}
|
||
} else { /* directed leftward */
|
||
if (x0 > CLIPXMAX) {
|
||
clipped = 1;
|
||
x0 = CLIPXMAX; /* clip */
|
||
z0 = z1 + rdz * (x0 - x1) / rdx;
|
||
}
|
||
if (x1 < 0) {
|
||
clipped |= 2;
|
||
z1 -= rdz * x1 / rdx;
|
||
x1 = 0; /* clip */
|
||
}
|
||
}
|
||
goto stash;
|
||
}
|
||
|
||
/*
|
||
* Hardest cases: use modified Liang-Barsky algorithm.
|
||
*
|
||
* Not only is this computation supposedly faster than Cohen-
|
||
* Sutherland clipping, but also the original direction is
|
||
* preserved, which is necessary to accurately emulate the
|
||
* VT48 behavior (association of coordinates with interrupts).
|
||
*/
|
||
|
||
/*
|
||
* t is a line parameter: P(t) = P0 + t * (P1 - P0).
|
||
* N is an outward normal vector.
|
||
* L, R, B, T denote edges (left, right, bottom, top).
|
||
* PE denotes "potentially entering", PL "potentially leaving".
|
||
* n, d denote numerator, denominator (avoids floating point).
|
||
*/
|
||
|
||
/*
|
||
* We know at this point that the endpoints lie in different
|
||
* regions and that there must be at least one PE or PL crossing
|
||
* at some value of t in [0,1]. Indeed, there will be *both* PE
|
||
* and PL crossings *unless* one endpoint is IN the window.
|
||
*
|
||
* As a result of the previous filtering, denominators are never 0.
|
||
*/
|
||
|
||
tPEn = -1; /* tPE = -1, lower than any candidate */
|
||
tPEd = 1;
|
||
tPLn = 2; /* tPL = 2, higher than any candidate */
|
||
tPLd = 1;
|
||
|
||
/*
|
||
* Left: tL = NL . (PL - P0) / NL . (P1 - P0)
|
||
* NL = (-1,0)
|
||
* PL = (0,y)
|
||
* =>
|
||
* tL = x0 / rdx
|
||
*
|
||
* if ( tL >= 0 & tL <= 1 )
|
||
* if ( NL . (P1 - P0) < 0 & tL > tPE )
|
||
* tPE := tL
|
||
* if ( NL . (P1 - P0) > 0 & tL < tPL )
|
||
* tPL := tL
|
||
* =>
|
||
* if ( rdx < 0 )
|
||
* if ( rdx <= x0 & x0 <= 0 )
|
||
* if ( tPEd > 0 )
|
||
* if ( x0 * tPEd < tPEn * rdx )
|
||
* tPE := tL
|
||
* else
|
||
* if ( x0 * tPEd > tPEn * rdx )
|
||
* tPE := tL
|
||
* else
|
||
* if ( 0 <= x0 & x0 <= rdx )
|
||
* if ( tPLd > 0 )
|
||
* if ( x0 * tPLd < tPLn * rdx )
|
||
* tPL := tL
|
||
* else
|
||
* if ( x0 * tPLd > tPLn * rdx )
|
||
* tPL := tL
|
||
*/
|
||
|
||
if (rdx < 0) {
|
||
if (x0 <= 0 && x0 >= rdx) {
|
||
if (tPEd > 0) {
|
||
if (x0 * (long)tPEd < (long)tPEn * rdx)
|
||
tPEn = x0, tPEd = rdx;
|
||
} else /* tPEd < 0 */
|
||
if (x0 * (long)tPEd > (long)tPEn * rdx)
|
||
tPEn = x0, tPEd = rdx;
|
||
}
|
||
} else /* rdx > 0 */
|
||
if (x0 >= 0 && x0 <= rdx) {
|
||
if (tPLd > 0) {
|
||
if (x0 * (long)tPLd < (long)tPLn * rdx)
|
||
tPLn = x0, tPLd = rdx;
|
||
} else /* tPLd < 0 */
|
||
if (x0 * (long)tPLd > (long)tPLn * rdx)
|
||
tPLn = x0, tPLd = rdx;
|
||
}
|
||
|
||
/*
|
||
* Right: tR = NR . (PR - P0) / NR . (P1 - P0)
|
||
* NR = (1,0)
|
||
* PR = (XMAX,y)
|
||
* =>
|
||
* tR = (x0 - XMAX) / rdx
|
||
*
|
||
* if ( tR >= 0 & tR <= 1 )
|
||
* if ( NR . (P1 - P0) < 0 & tR > tPE )
|
||
* tPE := tR
|
||
* if ( NR . (P1 - P0) > 0 & tR < tPL )
|
||
* tPL := tR
|
||
* =>
|
||
* if ( rdx < 0 )
|
||
* if ( rdx <= TRn & TRn <= 0 )
|
||
* if ( tPLd > 0 )
|
||
* if ( TRn * tPLd > tPLn * rdx )
|
||
* tPL := tR
|
||
* else
|
||
* if ( TRn * tPLd < tPLn * rdx )
|
||
* tPL := tR
|
||
* else
|
||
* if ( 0 <= TRn & TRn <= rdx )
|
||
* if ( tPEd > 0 )
|
||
* if ( TRn * tPEd > tPEn * rdx )
|
||
* tPE := tR
|
||
* else
|
||
* if ( TRn * tPEd < tPEn * rdx )
|
||
* tPE := tR
|
||
*/
|
||
|
||
tn = x0 - CLIPXMAX;
|
||
|
||
if (rdx < 0) {
|
||
if (tn <= 0 && tn >= rdx) {
|
||
if (tPLd > 0) {
|
||
if (tn * (long)tPLd > (long)tPLn * rdx)
|
||
tPLn = tn, tPLd = rdx;
|
||
} else /* tPLd < 0 */
|
||
if (tn * (long)tPLd < (long)tPLn * rdx)
|
||
tPLn = tn, tPLd = rdx;
|
||
}
|
||
} else /* rdx > 0 */
|
||
if (tn >= 0 && tn <= rdx) {
|
||
if (tPEd > 0) {
|
||
if (tn * (long)tPEd > (long)tPEn * rdx)
|
||
tPEn = tn, tPEd = rdx;
|
||
} else /* tPEd < 0 */
|
||
if (tn * (long)tPEd < (long)tPEn * rdx)
|
||
tPEn = tn, tPEd = rdx;
|
||
}
|
||
|
||
/*
|
||
* Bottom: tB = NB . (PB - P0) / NB . (P1 - P0)
|
||
* NB = (0,-1)
|
||
* PB = (x,0)
|
||
* =>
|
||
* tB = y0 / rdy
|
||
*
|
||
* if ( tB >= 0 & tB <= 1 )
|
||
* if ( NB . (P1 - P0) < 0 & tB > tPE )
|
||
* tPE := tB
|
||
* if ( NB . (P1 - P0) > 0 & tB < tPL )
|
||
* tPL := tB
|
||
* =>
|
||
* if ( rdy < 0 )
|
||
* if ( rdy <= y0 & y0 <= 0 )
|
||
* if ( tPEd > 0 )
|
||
* if ( y0 * tPEd < tPEn * rdy )
|
||
* tPE := tB
|
||
* else
|
||
* if ( y0 * tPEd > tPEn * rdy )
|
||
* tPE := tB
|
||
* else
|
||
* if ( 0 <= y0 & y0 <= rdy )
|
||
* if ( tPLd > 0 )
|
||
* if ( y0 * tPLd < tPLn * rdy )
|
||
* tPL := tB
|
||
* else
|
||
* if ( y0 * tPLd > tPLn * rdy )
|
||
* tPL := tB
|
||
*/
|
||
|
||
if (rdy < 0) {
|
||
if (y0 <= 0 && y0 >= rdy) {
|
||
if (tPEd > 0) {
|
||
if (y0 * (long)tPEd < (long)tPEn * rdy)
|
||
tPEn = y0, tPEd = rdy;
|
||
} else /* tPEd < 0 */
|
||
if (y0 * (long)tPEd > (long)tPEn * rdy)
|
||
tPEn = y0, tPEd = rdy;
|
||
}
|
||
} else /* rdy > 0 */
|
||
if (y0 >= 0 && y0 <= rdy) {
|
||
if (tPLd > 0) {
|
||
if (y0 * (long)tPLd < (long)tPLn * rdy)
|
||
tPLn = y0, tPLd = rdy;
|
||
} else /* tPLd < 0 */
|
||
if (y0 * (long)tPLd > (long)tPLn * rdy)
|
||
tPLn = y0, tPLd = rdy;
|
||
}
|
||
|
||
/*
|
||
* Top: tT = NT . (PT - P0) / NT . (P1 - P0)
|
||
* NT = (0,1)
|
||
* PT = (x,YMAX)
|
||
* =>
|
||
* tT = (y0 - YMAX) / rdy
|
||
*
|
||
* if ( tT >= 0 & tT <= 1 )
|
||
* if ( NT . (P1 - P0) < 0 & tT > tPE )
|
||
* tPE := tT
|
||
* if ( NT . (P1 - P0) > 0 & tT < tPL )
|
||
* tPL := tT
|
||
* =>
|
||
* if ( rdy < 0 )
|
||
* if ( rdy <= TRn & TRn <= 0 )
|
||
* if ( tPLd > 0 )
|
||
* if ( TRn * tPLd > tPLn * rdy )
|
||
* tPL := tT
|
||
* else
|
||
* if ( TRn * tPLd < tPLn * rdy )
|
||
* tPL := tT
|
||
* else
|
||
* if ( 0 <= TRn & TRn <= rdy )
|
||
* if ( tPEd > 0 )
|
||
* if ( TRn * tPEd > tPEn * rdy )
|
||
* tPE := tT
|
||
* else
|
||
* if ( TRn * tPEd < tPEn * rdy )
|
||
* tPE := tT
|
||
*/
|
||
|
||
tn = y0 - CLIPYMAX;
|
||
|
||
if (rdy < 0) {
|
||
if (tn <= 0 && tn >= rdy) {
|
||
if (tPLd > 0) {
|
||
if (tn * (long)tPLd > (long)tPLn * rdy)
|
||
tPLn = tn, tPLd = rdy;
|
||
} else /* tPLd < 0 */
|
||
if (tn * (long)tPLd < (long)tPLn * rdy)
|
||
tPLn = tn, tPLd = rdy;
|
||
}
|
||
} else /* rdy > 0 */
|
||
if (tn >= 0 && tn <= rdy) {
|
||
if (tPEd > 0) {
|
||
if (tn * (long)tPEd > (long)tPEn * rdy)
|
||
tPEn = tn, tPEd = rdy;
|
||
} else /* tPEd < 0 */
|
||
if (tn * (long)tPEd < (long)tPEn * rdy)
|
||
tPEn = tn, tPEd = rdy;
|
||
|
||
}
|
||
/*
|
||
* if ( tPL < tPE )
|
||
* invisible
|
||
* =>
|
||
* if ( tPLd > 0 && tPEd < 0 || tPLd < 0 && tPEd > 0 )
|
||
* if ( tPLn * tPEd > tPEn * tPLd )
|
||
* invis
|
||
* else
|
||
* if ( tPLn * tPEd < tPEn * tPLd )
|
||
* invis
|
||
*/
|
||
|
||
if (((tPLd > 0) && (tPEd < 0)) || ((tPLd < 0) && (tPEd > 0))) {
|
||
if (tPLn * (long)tPEd > (long)tPEn * tPLd)
|
||
return 0; /* invisible */
|
||
} else
|
||
if (tPLn * (long)tPEd < (long)tPEn * tPLd)
|
||
return 0; /* invisible */
|
||
|
||
/*
|
||
* if ( tPE < 0 ) tPE := 0 [code0 is 0]
|
||
* if ( tPL > 1 ) tPL := 1 [code1 is 0]
|
||
* draw from P(tPE) to P(tPL)
|
||
*
|
||
* P(t) = P0 + t * (P1 - P0)
|
||
* =>
|
||
* xE = x0 - tE * rdx, yE = y0 - tE * rdy
|
||
* xL = x0 - tL * rdx, yL = y0 - tL * rdy
|
||
*/
|
||
|
||
/* note: update P1 first since it uses original P0 coords */
|
||
|
||
if (code1 == 0)
|
||
clipped = 0;
|
||
else {
|
||
clipped = 2;
|
||
/* XXX might not be rounded the same as on the VT48: */
|
||
x1 = x0 - rdx * tPLn / tPLd;
|
||
y1 = y0 - rdy * tPLn / tPLd;
|
||
z1 = z0 - rdz * tPLn / tPLd;
|
||
}
|
||
|
||
if (code0 != 0) {
|
||
clipped |= 1;
|
||
/* XXX might not be rounded the same as on the VT48: */
|
||
x0 -= rdx * tPEn / tPEd;
|
||
y0 -= rdy * tPEn / tPEd;
|
||
z0 -= rdz * tPEn / tPEd;
|
||
}
|
||
|
||
/* Stash clipped coords and set global "vector was clipped" flag. */
|
||
|
||
stash:
|
||
clip_x0 = x0;
|
||
clip_y0 = y0;
|
||
clip_x1 = x1;
|
||
clip_y1 = y1;
|
||
clip_z0 = z0;
|
||
clip_z1 = z1;
|
||
return clipped;
|
||
}
|
||
|
||
/* draw a relative vector, depth-cued when appropriate */
|
||
|
||
static void
|
||
vector3(int i, int32 dx, int32 dy, int32 dz) /* unscaled display-file units */
|
||
{
|
||
int32 x0, y0, z0, x1, y1, z1;
|
||
|
||
dx = stroking ? CSCALE(dx) : VSCALE(dx); /* apply scale factor (VS60) */
|
||
dy = stroking ? CSCALE(dy) : VSCALE(dy);
|
||
dz = VSCALE(dz * 4);
|
||
x0 = PNORM(xpos); /* (includes offset) */
|
||
y0 = PNORM(ypos);
|
||
z0 = PNORM(zpos);
|
||
xpos += dx;
|
||
ypos += dy;
|
||
zpos += dz;
|
||
x1 = PNORM(xpos);
|
||
y1 = PNORM(ypos);
|
||
z1 = PNORM(zpos);
|
||
dx = x1 - x0;
|
||
dy = y1 - y0;
|
||
dz = z1 - z0;
|
||
|
||
if (stroking) { /* drawing a VS60 character */
|
||
DEBUGF(("offset, normalized stroke i%d (%ld,%ld) to (%ld,%ld)\r\n",
|
||
i, (long)x0,(long)y0, (long)x1,(long)y1));
|
||
|
||
if (dx == 0 && dy == 0) { /* just display a point */
|
||
if (i) {
|
||
if (menu)
|
||
illum3(x0 + MENU_OFFSET, y0, z0);
|
||
else
|
||
illum3(x0, y0, z0); /* illum3() checks ONCRT, int0_scope */
|
||
}
|
||
return;
|
||
}
|
||
} else {
|
||
DEBUGF((
|
||
"offset, normalized vector i%d (%ld,%ld,%ld) to (%ld,%ld,%ld)\r\n",
|
||
i, (long)x0, (long)y0, (long)z0, (long)x1, (long)y1, (long)z1));
|
||
|
||
line_counter = 037; /* reset line-style counter */
|
||
|
||
/* Maintenance Switch 3 => store delta length,tangent in xpos,ypos */
|
||
if (maint3) {
|
||
int32 adx = ABS(dx), ady = ABS(dy);
|
||
if (adx == ady) {
|
||
xpos = 07777; /* ~ 1.0 */
|
||
ypos = adx; /* or ady */
|
||
} else if (adx > ady) {
|
||
xpos = adx;
|
||
ypos = 010000L * ady / adx + 1; /* truncates */
|
||
} else /* (adx < ady) */ {
|
||
xpos = 010000L * adx / ady + 1; /* truncates */
|
||
ypos = ady; /* according to DZVSC test 100 */
|
||
}
|
||
DEBUGF("delta=0%o, tangent=0%o\r\n", xpos, ypos);
|
||
xpos = PSCALE(xpos); /* compensates for eventual PNORM */
|
||
ypos = PSCALE(ypos); /* compensates for eventual PNORM */
|
||
}
|
||
|
||
/* clip to viewport ("working surface") if necessary */
|
||
|
||
/*
|
||
* Note about edge conditions and interrupts:
|
||
*
|
||
* The VT48 documentation isn't very clear about this, but the expected
|
||
* behavior has been determined from one of the VS60 diagnostics. The
|
||
* "edge flag" flip-flop (bit) corresponds directly to an edge interrupt
|
||
* (controlled by the "edge interrupt enable" bit in a Load Status BB
|
||
* instruction) and is set precisely twice for *each* vector that is
|
||
* clipped in *any* way (on->off, off->off, off->on), assuming that
|
||
* after each interrupt is caught a RESUME (set DPC with odd value) is
|
||
* issued. The X,Y position registers at the time of the first edge
|
||
* interrupt for a clipped vector give the starting position of the
|
||
* *visible* segment; the position registers at the time of the second
|
||
* edge interrupt for a clipped vector give the ending position of the
|
||
* *visible* segment. The "edge indicator" flip-flop (bit) at the time
|
||
* of an edge interrupt is set if and only if the vector has been
|
||
* clipped at that position. Thus for on-to-off, the edge indicator is
|
||
* set for just the second edge interrupt; for off-to-off, the edge
|
||
* indicator is set for both edge interrupts; for off-to-on, the edge
|
||
* indicator is set for just the first interrupt. Resuming after a
|
||
* vector has gone off-screen updates the position registers to the
|
||
* location (off-screen) specified in the display file. Edge interrupts
|
||
* share an interrupt vector with other "surface" interrupts such as
|
||
* light-pen hits.
|
||
*
|
||
* It appears from diagnostic DZVSD that the menu area might not be
|
||
* clipped.
|
||
*
|
||
* Note that the VT11 cannot generate edge interrupts, and its edge
|
||
* indicator provides less information than on the VS60.
|
||
*/
|
||
|
||
switch (clip_vect = clip3(x0, y0, z0, x1, y1, z1)) {
|
||
case 1: /* clipped only on entry */
|
||
case 3: /* clipped on entry and exit */
|
||
edge_indic = 1; /* indicate clipped going in */
|
||
/* XXX might not be correct for VT11 */
|
||
case 2: /* clipped only on exit */
|
||
edge_flag = edge_intr_ena; /* indicate vector-clip interrupt */
|
||
if (edge_flag) {
|
||
edge_xpos = clip_x0;
|
||
edge_ypos = clip_y0;
|
||
edge_zpos = clip_z0;
|
||
edge_irq = 1;
|
||
}
|
||
clip_i = i;
|
||
return; /* may be drawn later by vt_cycle() */
|
||
case 0: /* invisible */
|
||
return;
|
||
default:
|
||
DEBUGF("clip() bad return: %d\n", clip_vect);
|
||
case -1: /* visible, not clipped */
|
||
clip_vect = 0;
|
||
break; /* draw immediately */
|
||
}
|
||
}
|
||
|
||
if (dx == 0 && dy == 0 && dz == 0)
|
||
return; /* hardware skips null vector */
|
||
|
||
/* for character strokes, resort to scissoring:
|
||
illum3() illuminates only pixels that lie in the visible display area */
|
||
|
||
/* draw OK even when Maintenance Switch 3 is set */
|
||
/* (but updated position registers must not be used to draw vector) */
|
||
if (i && int0_scope && !clip_vect) {/* clipped vector drawn by vt_cycle() */
|
||
if (menu)
|
||
lineTwoStep(x0 + MENU_OFFSET, y0, z0, x1 + MENU_OFFSET, y1, z1);
|
||
else
|
||
lineTwoStep(x0, y0, z0, x1, y1, z1);
|
||
}
|
||
|
||
/*
|
||
* In case of LP hit, recompute coords using "tangent register", because:
|
||
* (1) distinct virtual CRT points can be mapped into the same pixel
|
||
* (2) raster computation might not match that of the actual VT48
|
||
*/
|
||
|
||
if (lp0_hit) {
|
||
long tangent;
|
||
int32 adx = ABS(dx), ady = ABS(dy);
|
||
if (adx >= ady) {
|
||
tangent = 010000L * dy / dx; /* signed */
|
||
lp_ypos = y0 + tangent * (lp_xpos - x0) / 010000L;
|
||
tangent = 010000L * dz / dx;
|
||
lp_zpos = z0 + tangent * (lp_xpos - x0) / 010000L;
|
||
} else {
|
||
tangent = 010000L * dx / dy; /* signed */
|
||
lp_xpos = x0 + tangent * (lp_ypos - y0) / 010000L;
|
||
tangent = 010000L * dz / dy;
|
||
lp_zpos = z0 + tangent * (lp_ypos - y0) / 010000L;
|
||
}
|
||
DEBUGF(("adjusted LP coords (0%o,0%o,0%o)\r\n",
|
||
lp_xpos, lp_ypos, lp_zpos));
|
||
/* xpos,ypos,zpos still pertain to the original endpoint
|
||
(assuming that Maintenance Switch 3 isn't set) */
|
||
}
|
||
}
|
||
|
||
#define vector2(i,dx,dy) vector3(i,dx,dy,0)
|
||
/* the extra overhead for Z computation is not much */
|
||
|
||
/* basic vector (multiple of 45 degrees; directions numbered CCW, #0 => +X) */
|
||
static void
|
||
basic_vector(int i, int dir, int len) /* unscaled display-file units */
|
||
{
|
||
int32 dx, dy;
|
||
|
||
/* Alternatively, could be rasterized specially for each case; then
|
||
the general vector2() function could detect these special cases and
|
||
invoke this function to handle them, instead of the other way around. */
|
||
|
||
switch (dir) {
|
||
case 0:
|
||
dx = len;
|
||
dy = 0;
|
||
break;
|
||
case 1:
|
||
dx = len;
|
||
dy = len;
|
||
break;
|
||
case 2:
|
||
dx = 0;
|
||
dy = len;
|
||
break;
|
||
case 3:
|
||
dx = -len;
|
||
dy = len;
|
||
break;
|
||
case 4:
|
||
dx = -len;
|
||
dy = 0;
|
||
break;
|
||
case 5:
|
||
dx = -len;
|
||
dy = -len;
|
||
break;
|
||
case 6:
|
||
dx = 0;
|
||
dy = -len;
|
||
break;
|
||
case 7:
|
||
dx = len;
|
||
dy = -len;
|
||
break;
|
||
default: /* "can't happen" */
|
||
DEBUGF("BUG: basic vector: illegal direction %d\r\n", dir);
|
||
return;
|
||
}
|
||
DEBUGF("basic ");
|
||
vector2(i, dx, dy);
|
||
}
|
||
|
||
/*
|
||
* support for VS60 circle/arc option
|
||
*
|
||
* Since the literature that I have access to does not handle the case where
|
||
* starting and ending radii differ, I invented a solution that should be
|
||
* "good enough" for now: an approximation of an Archimedean spiral is drawn
|
||
* as connected individual chords, with the line-type counter applied (without
|
||
* being reset) over the entire curve.
|
||
*
|
||
* It is not known whether the direction is supposed to be clockwise or
|
||
* counterclockwise (the latter is assumed in the following code); it is
|
||
* assumed that if the starting and ending directions from the center point
|
||
* are identical, that a full circle is being specified.
|
||
*
|
||
* Although throughout the display simulation substantial effort has been
|
||
* invested to avoid using floating point, this preliminary implementation
|
||
* of the circle/arc generator does use floating point. Presumably this
|
||
* is avoidable, but the algorithmic details would need to be worked out.
|
||
* If use of floating point is a problem, #define NO_CONIC_OPT when compiling.
|
||
*
|
||
* The Z coordinate is linearly interpolated.
|
||
*/
|
||
|
||
static void
|
||
conic3(int i, int32 dcx, int32 dcy, int32 dcz, int32 dex, int32 dey, int32 dez)
|
||
/* unscaled display-file units */
|
||
{
|
||
#ifdef NO_CONIC_OPT
|
||
/* just draw vector to endpoint (like real VS60 with option missing) */
|
||
vector3(i, dex, dey, dez);
|
||
#else
|
||
int32 xs, ys, zs, xc, yc, zc, xe, ye, ze, x, y, z, nseg, seg;
|
||
double rs, re, dr, as, da, zo, dz;
|
||
int ons, one; /* ONSCREEN(xs,ys), ONSCREEN(xe,ye) */
|
||
static double two_pi = -1.0; /* will be set (once only) to 2*Pi */
|
||
static double k; /* will be set to 2-sqrt(4-(Pi/4)^2) */
|
||
|
||
if (two_pi < 0.0) { /* (initial entry only) */
|
||
k = atan2(1.0, 1.0);
|
||
two_pi = 8.0 * k;
|
||
k = 2.0 - sqrt(4.0 - k*k);
|
||
}
|
||
dcx = VSCALE(dcx); /* apply vector scale factor */
|
||
dcy = VSCALE(dcy);
|
||
dcz = VSCALE(dcz * 4);
|
||
dex = VSCALE(dex);
|
||
dey = VSCALE(dey);
|
||
dez = VSCALE(dez * 4);
|
||
xs = PNORM(xpos); /* starting pos. (includes offset) */
|
||
ys = PNORM(ypos);
|
||
zs = PNORM(zpos);
|
||
xc = PNORM(xpos + dcx); /* center pos. (includes offset) */
|
||
yc = PNORM(ypos + dcy);
|
||
zc = PNORM(zpos + dcz);
|
||
xe = PNORM(xpos + dex); /* ending pos. (includes offset) */
|
||
ye = PNORM(ypos + dey);
|
||
ze = PNORM(zpos + dez);
|
||
/* determine vector from center to finish */
|
||
dex -= dcx; /* PSCALEd */
|
||
dey -= dcy;
|
||
dez -= dcz;
|
||
|
||
DEBUGF((
|
||
"offset, normalized arc i%d s(%ld,%ld,%ld) c(%ld,%ld,%ld) e(%ld,%ld,%ld)\r\n",
|
||
i, (long)xs,(long)ys,(long)zs, (long)xc,(long)yc,(long)zc,
|
||
(long)xe,(long)ye,(long)ze));
|
||
|
||
/* XXX not known whether Maintenance Switch 3 has any effect for arcs */
|
||
|
||
/* clip to viewport ("working surface") if necessary */
|
||
|
||
/* XXX not implemented yet [could check each chord individually] */
|
||
|
||
/* check for edge conditions (XXX change when conic clipping implemented) */
|
||
/* XXX this test is very crude; should be much more complex */
|
||
ons = ONSCREEN(xs, ys);
|
||
one = ONSCREEN(xe, ye);
|
||
edge_indic = ons && !one;
|
||
edge_flag = edge_indic || (!ons && one);
|
||
if (edge_flag) {
|
||
if (edge_intr_ena) { /* need to clip to viewport */
|
||
/* XXX edge positions aren't right; need proper clipping */
|
||
edge_xpos = xe;
|
||
edge_ypos = ye;
|
||
edge_zpos = ze;
|
||
edge_irq = 1;
|
||
goto done;
|
||
} else
|
||
edge_flag = 0;
|
||
}
|
||
|
||
/* XXX for now, resort to scissoring:
|
||
illuminates only pixels that lie in the visible display area */
|
||
|
||
if (dcx == 0 && dcy == 0 && dcz == 0 && dex == 0 && dey == 0 && dez == 0)
|
||
goto done; /* skip null curve */
|
||
|
||
/* determine starting, ending radii and their maximum */
|
||
rs = PNORM(sqrt((double)dcx*dcx + (double)dcy*dcy)); /* (f.p.) */
|
||
re = PNORM(sqrt((double)dex*dex + (double)dey*dey));
|
||
dr = rs >= re ? rs : re;
|
||
|
||
/* determine starting direction from center, and included angle */
|
||
as = dcx == 0 && dcy == 0 ? 0.0 : atan2((double)-dcy, (double)-dcx);
|
||
da = (dex == 0 && dey == 0 ? 0.0 : atan2((double)dey, (double)dex)) - as;
|
||
while (da <= 0.0) /* exactly 0.0 implies full cycle */
|
||
da += two_pi;
|
||
|
||
/* determine number of chords to use;
|
||
make deviation from true curve no more than approximately one pixel */
|
||
dr = reduce / dr;
|
||
if (dr > k)
|
||
dr = k;
|
||
nseg = (int32)(da / sqrt(4.0*dr - dr*dr) + 1.0);
|
||
if (nseg < 1) /* "can't happen" */
|
||
nseg = 1;
|
||
else if (nseg > 360)
|
||
nseg = 360; /* arbitrarily chosen upper limit */
|
||
|
||
/* determine angular, radial, and Z step sizes */
|
||
dr = (re - rs) / nseg;
|
||
da /= nseg;
|
||
dz = (double)(ze - zs) / nseg;
|
||
|
||
if (menu) {
|
||
xs += MENU_OFFSET;
|
||
xc += MENU_OFFSET;
|
||
xe += MENU_OFFSET;
|
||
}
|
||
|
||
line_counter = 037; /* reset line-style counter */
|
||
|
||
/* draw successive chords */
|
||
zo = zs;
|
||
for (seg = 0; ++seg < nseg; ) {
|
||
rs += dr;
|
||
as += da;
|
||
re = rs * cos(as);
|
||
x = xc + (re >= 0 ? (int32)(re + 0.5) : -(int32)(-re + 0.5));
|
||
re = rs * sin(as);
|
||
y = yc + (re >= 0 ? (int32)(re + 0.5) : -(int32)(-re + 0.5));
|
||
z = (int32)(zo + seg * dz); /* truncates */
|
||
lineTwoStep(xs, ys, zs, x, y, z); /* (continuing line style) */
|
||
skip_start = 1; /* don't double-illuminate junctions */
|
||
xs = x;
|
||
ys = y;
|
||
zs = z;
|
||
if (lphit_irq)
|
||
goto done; /* light-pen hit interrupted drawing */
|
||
}
|
||
lineTwoStep(xs, ys, zs, xe, ye, ze);/* draw final chord to exact endpoint */
|
||
|
||
done:
|
||
skip_start = 0; /* important! */
|
||
xpos += dcx + dex; /* update virtual beam position */
|
||
ypos += dcy + dey;
|
||
zpos += dcz + dez;
|
||
if (lp0_hit) {
|
||
DEBUGF(("LP hit on arc at (0%o,0%o,0%o)\r\n",
|
||
lp_xpos, lp_ypos, lp_zpos));
|
||
if (lphit_irq) {
|
||
/* XXX save parameters for drawing remaining chords */
|
||
}
|
||
}
|
||
#endif
|
||
}
|
||
|
||
#define conic2(i,dcx,dcy,dex,dey) conic3(i,dcx,dcy,0,dex,dey,0)
|
||
/* the extra overhead for Z computation is not much */
|
||
|
||
/*
|
||
* VT11 character font;
|
||
* 6x8 matrix, not serpentine encoded, decenders supported as in real VT11
|
||
*/
|
||
|
||
static const unsigned char dots[0200][6] = {
|
||
{ 0x8f, 0x50, 0x20, 0x10, 0x08, 0x07 }, /* 000 lambda */
|
||
{ 0x1e, 0x21, 0x22, 0x14, 0x0c, 0x13 }, /* 001 alpha */
|
||
{ 0x00, 0x18, 0x24, 0xff, 0x24, 0x18 }, /* 002 phi */
|
||
{ 0x83, 0xc5, 0xa9, 0x91, 0x81, 0xc3 }, /* 003 SIGMA */
|
||
{ 0x00, 0x46, 0xa9, 0x91, 0x89, 0x06 }, /* 004 delta */
|
||
{ 0x03, 0x05, 0x09, 0x11, 0x21, 0x7f }, /* 005 DELTA */
|
||
{ 0x00, 0x20, 0x20, 0x3f, 0x01, 0x01 }, /* 006 iota */
|
||
{ 0x46, 0x29, 0x11, 0x2e, 0x40, 0x80 }, /* 007 gamma */
|
||
{ 0x7f, 0x80, 0x80, 0x80, 0x80, 0x7f }, /* 010 intersect */
|
||
{ 0x40, 0x3c, 0x04, 0xff, 0x04, 0x78 }, /* 011 psi */
|
||
{ 0x00, 0x10, 0x10, 0x54, 0x10, 0x10 }, /* 012 divide by */
|
||
{ 0x00, 0x60, 0x90, 0x90, 0x60, 0x00 }, /* 013 degree */
|
||
{ 0x00, 0x01, 0x00, 0x10, 0x00, 0x01 }, /* 014 therefore */
|
||
{ 0x01, 0x02, 0x3c, 0x02, 0x02, 0x3c }, /* 015 mu */
|
||
{ 0x11, 0x7f, 0x91, 0x81, 0x41, 0x03 }, /* 016 pound sterling */
|
||
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 017 SHIFT IN */
|
||
{ 0x20, 0x40, 0x7f, 0x40, 0x7f, 0x40 }, /* 020 pi */
|
||
{ 0x00, 0xff, 0x00, 0x00, 0xff, 0x00 }, /* 021 parallel */
|
||
{ 0x1d, 0x23, 0x40, 0x42, 0x25, 0x19 }, /* 022 OMEGA */
|
||
{ 0x1c, 0x22, 0x61, 0x51, 0x4e, 0x40 }, /* 023 sigma */
|
||
{ 0x20, 0x40, 0x40, 0x7f, 0x40, 0x40 }, /* 024 UPSILON */
|
||
{ 0x00, 0x1c, 0x2a, 0x49, 0x49, 0x00 }, /* 025 epsilon */
|
||
{ 0x10, 0x38, 0x54, 0x10, 0x10, 0x10 }, /* 026 left arrow */
|
||
{ 0x10, 0x10, 0x10, 0x54, 0x38, 0x10 }, /* 027 right arrow */
|
||
{ 0x00, 0x20, 0x40, 0xfe, 0x40, 0x20 }, /* 030 up arrow */
|
||
{ 0x00, 0x04, 0x02, 0x7f, 0x02, 0x04 }, /* 031 down arrow */
|
||
{ 0x00, 0xff, 0x80, 0x80, 0x80, 0x80 }, /* 032 GAMMA */
|
||
{ 0x00, 0x01, 0x01, 0xff, 0x01, 0x01 }, /* 033 perpendicular */
|
||
{ 0x2a, 0x2c, 0x28, 0x38, 0x68, 0xa8 }, /* 034 unequal */
|
||
{ 0x24, 0x48, 0x48, 0x24, 0x24, 0x48 }, /* 035 approx equal */
|
||
{ 0x00, 0x20, 0x10, 0x08, 0x10, 0x20 }, /* 036 vel */
|
||
{ 0xff, 0x81, 0x81, 0x81, 0x81, 0xff }, /* 037 box */
|
||
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 040 space */
|
||
{ 0x00, 0x00, 0x00, 0xfd, 0x00, 0x00 }, /* 041 ! */
|
||
{ 0x00, 0xe0, 0x00, 0x00, 0xe0, 0x00 }, /* 042 " */
|
||
{ 0x00, 0x24, 0xff, 0x24, 0xff, 0x24 }, /* 043 # */
|
||
{ 0x22, 0x52, 0xff, 0x52, 0x4c, 0x00 }, /* 044 $ */
|
||
{ 0x42, 0xa4, 0x48, 0x12, 0x25, 0x42 }, /* 045 % */
|
||
{ 0x66, 0x99, 0x99, 0x66, 0x0a, 0x11 }, /* 046 & */
|
||
{ 0x00, 0x00, 0x20, 0x40, 0x80, 0x00 }, /* 047 ' */
|
||
{ 0x00, 0x00, 0x3c, 0x42, 0x81, 0x00 }, /* 050 ( */
|
||
{ 0x00, 0x00, 0x81, 0x42, 0x3c, 0x00 }, /* 051 ) */
|
||
{ 0x00, 0x44, 0x28, 0xf0, 0x28, 0x44 }, /* 052 * */
|
||
{ 0x00, 0x10, 0x10, 0x7c, 0x10, 0x10 }, /* 053 + */
|
||
{ 0x00, 0x01, 0x06, 0x00, 0x00, 0x00 }, /* 054 , */
|
||
{ 0x00, 0x10, 0x10, 0x10, 0x10, 0x10 }, /* 055 - */
|
||
{ 0x00, 0x00, 0x06, 0x06, 0x00, 0x00 }, /* 056 . */
|
||
{ 0x02, 0x04, 0x08, 0x10, 0x20, 0x40 }, /* 057 / */
|
||
{ 0x7e, 0x85, 0x89, 0x91, 0xa1, 0x7e }, /* 060 0 */
|
||
{ 0x00, 0x41, 0xff, 0x01, 0x00, 0x00 }, /* 061 1 */
|
||
{ 0x47, 0x89, 0x91, 0x91, 0x91, 0x61 }, /* 062 2 */
|
||
{ 0x42, 0x81, 0x91, 0xb1, 0xd1, 0x8e }, /* 063 3 */
|
||
{ 0x0c, 0x14, 0x24, 0x44, 0xff, 0x04 }, /* 064 4 */
|
||
{ 0xf2, 0x91, 0x91, 0x91, 0x91, 0x8e }, /* 065 5 */
|
||
{ 0x3c, 0x46, 0x89, 0x89, 0x89, 0x46 }, /* 066 6 */
|
||
{ 0x40, 0x87, 0x88, 0x90, 0xa0, 0xc0 }, /* 067 7 */
|
||
{ 0x6e, 0x91, 0x91, 0x91, 0x91, 0x6e }, /* 070 8 */
|
||
{ 0x62, 0x91, 0x91, 0x91, 0x62, 0x3c }, /* 071 9 */
|
||
{ 0x00, 0x66, 0x66, 0x00, 0x00, 0x00 }, /* 072 : */
|
||
{ 0x00, 0x00, 0x61, 0x66, 0x00, 0x00 }, /* 073 ; */
|
||
{ 0x00, 0x18, 0x24, 0x42, 0x81, 0x00 }, /* 074 < */
|
||
{ 0x00, 0x28, 0x28, 0x28, 0x28, 0x28 }, /* 075 = */
|
||
{ 0x00, 0x81, 0x42, 0x24, 0x18, 0x00 }, /* 076 > */
|
||
{ 0x00, 0x40, 0x80, 0x9d, 0x90, 0x60 }, /* 077 ? */
|
||
{ 0x3c, 0x42, 0x91, 0xa9, 0xa9, 0x72 }, /* 100 @ */
|
||
{ 0x3f, 0x48, 0x88, 0x88, 0x48, 0x3f }, /* 101 A */
|
||
{ 0x81, 0xff, 0x91, 0x91, 0x91, 0x6e }, /* 102 B */
|
||
{ 0x3c, 0x42, 0x81, 0x81, 0x81, 0x42 }, /* 103 C */
|
||
{ 0x81, 0xff, 0x81, 0x81, 0x42, 0x3c }, /* 104 D */
|
||
{ 0x81, 0xff, 0x91, 0x91, 0x91, 0xc3 }, /* 105 E */
|
||
{ 0x81, 0xff, 0x91, 0x90, 0x80, 0xc0 }, /* 106 F */
|
||
{ 0x3c, 0x42, 0x81, 0x89, 0x89, 0x4f }, /* 107 G */
|
||
{ 0xff, 0x10, 0x10, 0x10, 0x10, 0xff }, /* 110 H */
|
||
{ 0x00, 0x81, 0xff, 0x81, 0x00, 0x00 }, /* 111 I */
|
||
{ 0x0e, 0x01, 0x01, 0x81, 0xfe, 0x80 }, /* 112 J */
|
||
{ 0xff, 0x08, 0x10, 0x28, 0x44, 0x83 }, /* 113 K */
|
||
{ 0x81, 0xff, 0x81, 0x01, 0x01, 0x03 }, /* 114 L */
|
||
{ 0xff, 0x40, 0x30, 0x30, 0x40, 0xff }, /* 115 M */
|
||
{ 0xff, 0x20, 0x10, 0x08, 0x04, 0xff }, /* 116 N */
|
||
{ 0x3c, 0x42, 0x81, 0x81, 0x42, 0x3c }, /* 117 O */
|
||
{ 0x81, 0xff, 0x90, 0x90, 0x90, 0x60 }, /* 120 P */
|
||
{ 0x3c, 0x42, 0x81, 0x8f, 0x42, 0x3d }, /* 121 Q */
|
||
{ 0x81, 0xff, 0x90, 0x98, 0x94, 0x63 }, /* 122 R */
|
||
{ 0x22, 0x51, 0x91, 0x91, 0x89, 0x46 }, /* 123 S */
|
||
{ 0xc0, 0x80, 0x81, 0xff, 0x81, 0xc0 }, /* 124 T */
|
||
{ 0xfe, 0x01, 0x01, 0x01, 0x01, 0xfe }, /* 125 U */
|
||
{ 0xff, 0x02, 0x04, 0x08, 0x10, 0xe0 }, /* 126 V */
|
||
{ 0xff, 0x02, 0x0c, 0x0c, 0x02, 0xff }, /* 127 W */
|
||
{ 0xc3, 0x24, 0x18, 0x18, 0x24, 0xc3 }, /* 130 X */
|
||
{ 0x00, 0xe0, 0x10, 0x0f, 0x10, 0xe0 }, /* 131 Y */
|
||
{ 0x83, 0x85, 0x89, 0x91, 0xa1, 0xc1 }, /* 132 Z */
|
||
{ 0x00, 0x00, 0xff, 0x81, 0x81, 0x00 }, /* 133 [ */
|
||
{ 0x00, 0x40, 0x20, 0x10, 0x08, 0x04 }, /* 134 \ */
|
||
{ 0x00, 0x00, 0x81, 0x81, 0xff, 0x00 }, /* 135 ] */
|
||
{ 0x00, 0x10, 0x20, 0x40, 0x20, 0x10 }, /* 136 ^ */
|
||
{ 0x01, 0x01, 0x01, 0x01, 0x01, 0x00 }, /* 137 _ */
|
||
/* for all lowercase characters, first column is just a "descender" flag: */
|
||
{ 0x00, 0x00, 0x80, 0x40, 0x20, 0x00 }, /* 140 ` */
|
||
{ 0x00, 0x26, 0x29, 0x29, 0x2a, 0x1f }, /* 141 a */
|
||
{ 0x00, 0xff, 0x12, 0x21, 0x21, 0x1e }, /* 142 b */
|
||
{ 0x00, 0x1e, 0x21, 0x21, 0x21, 0x12 }, /* 143 c */
|
||
{ 0x00, 0x1e, 0x21, 0x21, 0x12, 0xff }, /* 144 d */
|
||
{ 0x00, 0x1e, 0x29, 0x29, 0x29, 0x19 }, /* 145 e */
|
||
{ 0x00, 0x20, 0x7f, 0xa0, 0xa0, 0x80 }, /* 146 f */
|
||
{ 0x01, 0x78, 0x85, 0x85, 0x49, 0xfe }, /* 147 g */
|
||
{ 0x00, 0xff, 0x10, 0x20, 0x20, 0x1f }, /* 150 h */
|
||
{ 0x00, 0x00, 0x21, 0xbf, 0x01, 0x00 }, /* 151 i */
|
||
{ 0x01, 0x02, 0x01, 0x81, 0xfe, 0x00 }, /* 152 j */
|
||
{ 0x00, 0xff, 0x08, 0x14, 0x22, 0x21 }, /* 153 k */
|
||
{ 0x00, 0x00, 0xfe, 0x01, 0x01, 0x00 }, /* 154 l */
|
||
{ 0x00, 0x3f, 0x20, 0x3f, 0x20, 0x3f }, /* 155 m */
|
||
{ 0x00, 0x3f, 0x10, 0x20, 0x20, 0x1f }, /* 156 n */
|
||
{ 0x00, 0x1e, 0x21, 0x21, 0x21, 0x1e }, /* 157 o */
|
||
{ 0x01, 0xff, 0x48, 0x84, 0x84, 0x78 }, /* 160 p */
|
||
{ 0x01, 0x78, 0x84, 0x84, 0x48, 0xff }, /* 161 q */
|
||
{ 0x00, 0x3f, 0x08, 0x10, 0x20, 0x20 }, /* 162 r */
|
||
{ 0x00, 0x12, 0x29, 0x29, 0x29, 0x26 }, /* 163 s */
|
||
{ 0x00, 0x20, 0xfe, 0x21, 0x21, 0x00 }, /* 164 t */
|
||
{ 0x00, 0x3e, 0x01, 0x01, 0x02, 0x3f }, /* 165 u */
|
||
{ 0x00, 0x3c, 0x02, 0x01, 0x02, 0x3c }, /* 166 v */
|
||
{ 0x00, 0x3e, 0x01, 0x1e, 0x01, 0x3e }, /* 167 w */
|
||
{ 0x00, 0x23, 0x14, 0x08, 0x14, 0x23 }, /* 170 x */
|
||
{ 0x01, 0xf8, 0x05, 0x05, 0x09, 0xfe }, /* 171 y */
|
||
{ 0x00, 0x23, 0x25, 0x29, 0x31, 0x21 }, /* 172 z */
|
||
{ 0x00, 0x18, 0x66, 0x81, 0x81, 0x00 }, /* 173 { */
|
||
{ 0x00, 0x00, 0xe7, 0x00, 0x00, 0x00 }, /* 174 | */
|
||
{ 0x00, 0x00, 0x81, 0x81, 0x66, 0x18 }, /* 175 } */
|
||
{ 0x00, 0x0c, 0x10, 0x08, 0x04, 0x18 }, /* 176 ~ */
|
||
{ 0x00, 0xff, 0xff, 0xff, 0xff, 0xff } /* 177 rubout */
|
||
};
|
||
|
||
/*
|
||
* VS60 character stroke table
|
||
*
|
||
* stroke[] contains "prototype" encodings for all vector strokes (visible and
|
||
* invisible) needed to draw each character at a standard size. The actual
|
||
* display is of course properly italicized, positioned, scaled, and rotated.
|
||
*
|
||
* Variable-length entries are used; each character stroke sequence is
|
||
* terminated by a 0-valued byte. Pointers to the appropriate data for all
|
||
* characters are stored into sstroke[] during a one-time initialization.
|
||
*
|
||
* The prototype strokes are for the most part constrained to a 4x6 unit area,
|
||
* except for a few cases that are handled by kludging the coordinates.
|
||
* Coordinates are relative to the left end of the character baseline.
|
||
*
|
||
* A prototype stroke is encoded as 8 bits SVXXXYYY:
|
||
* S = 0 if YYY is correct as is
|
||
* 1 if YYY needs to have 2 subtracted
|
||
* V = 0 if stroke is invisible (move)
|
||
* 1 if stroke is visible (draw)
|
||
* XXX = final X coord of stroke (0..4; 7 => -1)
|
||
* YYY = final Y coord of stroke (0..6)
|
||
*/
|
||
|
||
static const unsigned char stroke[] = {
|
||
/*
|
||
* While based on the actual VT48 strokes, these have been tweaked
|
||
* (especially the lower-case letters, which had erratic sizes) to
|
||
* improve their appearance and/or reduce the number of strokes.
|
||
* Several of the special symbols (e.g. alpha, delta, iota) could
|
||
* be further improved, but I didn't want to make them look too
|
||
* different from the original. Note that VS60 screen photos
|
||
* disagree, for several characters, with the (incomplete) chart of
|
||
* strokes given in the VT48 manual. (There could have been ROM changes.)
|
||
*
|
||
* The simulated character sizes are not exact at all scales, but there
|
||
* is no really good way to fix this without spoiling the appearance.
|
||
* char. scale VS60 units simulation units (pixel has size!)
|
||
* 1/2 5 x 7 5 x 7
|
||
* 1 10 x 14 9 x 13
|
||
* 3/2 15 x 21 13 x 19
|
||
* 2 20 x 28 17 x 25
|
||
*/
|
||
0111, 0123, 0006, 0115, 0131, 0140, 0, /* 000 lambda */
|
||
0042, 0132, 0114, 0103, 0112, 0134, 0144, 0, /* 001 alpha */
|
||
0011, 0103, 0115, 0135, 0143, 0131, 0111, 0010,
|
||
0146, 0, /* 002 phi */
|
||
0040, 0100, 0133, 0106, 0146, 0, /* 003 SIGMA */
|
||
0022, 0111, 0120, 0131, 0113, 0115, 0124, 0, /* 004 delta */
|
||
0140, 0124, 0100, 0, /* 005 DELTA */
|
||
0006, 0126, 0120, 0140, 0, /* 006 iota */
|
||
0006, 0115, 0131, 0120, 0111, 0135, 0146, 0, /* 007 gamma */
|
||
0104, 0116, 0136, 0144, 0140, 0, /* 010 intersect */
|
||
0010, 0136, 0044, 0142, 0131, 0111, 0102, 0104, 0, /* 011 psi */
|
||
0022, 0122, 0003, 0143, 0024, 0124, 0, /* 012 divide by */
|
||
0024, 0115, 0126, 0135, 0124, 0, /* 013 degree */
|
||
0001, 0101, 0025, 0125, 0041, 0141, 0, /* 014 therefore */
|
||
0111, 0115, 0012, 0121, 0131, 0142, 0045, 0142,
|
||
0151, 0, /* 015 mu */
|
||
0105, 0116, 0126, 0135, 0013, 0173, 0001, 0120,
|
||
0130, 0141, 0, /* 016 pound sterling */
|
||
0, /* 017 SHIFT IN */
|
||
0003, 0114, 0144, 0034, 0130, 0010, 0114, 0, /* 020 pi */
|
||
0010, 0116, 0036, 0130, 0, /* 021 parallel */
|
||
0110, 0111, 0102, 0104, 0115, 0135, 0144, 0142,
|
||
0131, 0130, 0140, 0, /* 022 OMEGA */
|
||
0025, 0134, 0132, 0120, 0110, 0102, 0104, 0146, 0, /* 023 sigma */
|
||
0010, 0136, 0046, 0116, 0105, 0, /* 024 UPSILON */
|
||
0003, 0133, 0045, 0136, 0116, 0105, 0101, 0110,
|
||
0130, 0141, 0, /* 025 epsilon */
|
||
0042, 0102, 0113, 0011, 0102, 0, /* 026 left arrow */
|
||
0002, 0142, 0133, 0031, 0142, 0, /* 027 right arrow */
|
||
0020, 0124, 0133, 0013, 0124, 0, /* 030 up arrow */
|
||
0024, 0120, 0131, 0011, 0120, 0, /* 031 down arrow */
|
||
0106, 0146, 0144, 0, /* 032 GAMMA */
|
||
0140, 0026, 0120, 0, /* 033 perpendicular */
|
||
0001, 0145, 0044, 0104, 0002, 0142, 0, /* 034 unequal */
|
||
0001, 0112, 0131, 0142, 0044, 0133, 0114, 0103, 0, /* 035 approx equal */
|
||
0016, 0125, 0135, 0146, 0, /* 036 vel */
|
||
0106, 0146, 0140, 0100, 0, /* 037 box */
|
||
0, /* 040 space */
|
||
0020, 0120, 0021, 0125, 0, /* 041 ! */
|
||
0004, 0126, 0046, 0124, 0, /* 042 " */
|
||
0012, 0116, 0036, 0132, 0043, 0103, 0005, 0145, 0, /* 043 # */
|
||
0001, 0110, 0130, 0141, 0142, 0133, 0113, 0104,
|
||
0105, 0116, 0136, 0145, 0026, 0120, 0, /* 044 $ */
|
||
0146, 0116, 0105, 0114, 0125, 0116, 0032, 0141,
|
||
0130, 0121, 0132, 0, /* 045 % */
|
||
0040, 0104, 0105, 0116, 0126, 0135, 0134, 0101,
|
||
0110, 0120, 0142, 0, /* 046 & */
|
||
0014, 0136, 0, /* 047 ' */
|
||
0030, 0112, 0114, 0136, 0, /* 050 ( */
|
||
0010, 0132, 0134, 0116, 0, /* 051 ) */
|
||
0002, 0146, 0026, 0122, 0042, 0106, 0, /* 052 * */
|
||
0021, 0125, 0003, 0143, 0, /* 053 + */
|
||
0211, 0120, 0121, 0, /* 054 , */
|
||
0003, 0143, 0, /* 055 - */
|
||
0020, 0120, 0, /* 056 . */
|
||
0146, 0, /* 057 / */
|
||
0001, 0145, 0136, 0116, 0105, 0101, 0110, 0130,
|
||
0141, 0145, 0, /* 060 0 */
|
||
0010, 0130, 0020, 0126, 0115, 0, /* 061 1 */
|
||
0005, 0116, 0136, 0145, 0144, 0100, 0140, 0, /* 062 2 */
|
||
0001, 0110, 0130, 0141, 0142, 0133, 0113, 0005,
|
||
0116, 0136, 0145, 0144, 0133, 0, /* 063 3 */
|
||
0030, 0136, 0025, 0102, 0142, 0, /* 064 4 */
|
||
0001, 0110, 0130, 0141, 0143, 0134, 0114, 0103,
|
||
0106, 0146, 0, /* 065 5 */
|
||
0002, 0113, 0133, 0142, 0141, 0130, 0110, 0101,
|
||
0105, 0116, 0136, 0145, 0, /* 066 6 */
|
||
0006, 0146, 0120, 0, /* 067 7 */
|
||
0013, 0133, 0142, 0141, 0130, 0110, 0101, 0102,
|
||
0113, 0104, 0105, 0116, 0136, 0145, 0144, 0133, 0, /* 070 8 */
|
||
0001, 0110, 0130, 0141, 0145, 0136, 0116, 0105,
|
||
0104, 0113, 0133, 0144, 0, /* 071 9 */
|
||
0022, 0122, 0024, 0124, 0, /* 072 : */
|
||
0010, 0121, 0122, 0024, 0124, 0, /* 073 ; */
|
||
0030, 0103, 0136, 0, /* 074 < */
|
||
0002, 0142, 0004, 0144, 0, /* 075 = */
|
||
0010, 0143, 0116, 0, /* 076 > */
|
||
0020, 0120, 0021, 0122, 0144, 0145, 0136, 0116,
|
||
0105, 0104, 0, /* 077 ? */
|
||
0030, 0110, 0101, 0104, 0115, 0145, 0141, 0121,
|
||
0112, 0113, 0124, 0134, 0131, 0, /* 100 @ */
|
||
0104, 0116, 0136, 0144, 0140, 0042, 0102, 0, /* 101 A */
|
||
0106, 0136, 0145, 0144, 0133, 0103, 0033, 0142,
|
||
0141, 0130, 0100, 0, /* 102 B */
|
||
0041, 0130, 0110, 0101, 0105, 0116, 0136, 0145, 0, /* 103 C */
|
||
0106, 0136, 0145, 0141, 0130, 0100, 0, /* 104 D */
|
||
0003, 0133, 0046, 0106, 0100, 0140, 0, /* 105 E */
|
||
0106, 0146, 0033, 0103, 0, /* 106 F */
|
||
0023, 0143, 0141, 0130, 0110, 0101, 0105, 0116,
|
||
0136, 0145, 0, /* 107 G */
|
||
0106, 0003, 0143, 0046, 0140, 0, /* 110 H */
|
||
0010, 0130, 0020, 0126, 0016, 0136, 0, /* 111 I */
|
||
0001, 0110, 0120, 0131, 0136, 0, /* 112 J */
|
||
0106, 0046, 0102, 0024, 0140, 0, /* 113 K */
|
||
0006, 0100, 0140, 0, /* 114 L */
|
||
0106, 0123, 0146, 0140, 0, /* 115 M */
|
||
0106, 0140, 0146, 0, /* 116 N */
|
||
0001, 0105, 0116, 0136, 0145, 0141, 0130, 0110,
|
||
0101, 0, /* 117 O */
|
||
0106, 0136, 0145, 0144, 0133, 0103, 0, /* 120 P */
|
||
0030, 0110, 0101, 0105, 0116, 0136, 0145, 0141,
|
||
0130, 0031, 0140, 0, /* 121 Q */
|
||
0106, 0136, 0145, 0144, 0133, 0103, 0033, 0140, 0, /* 122 R */
|
||
0001, 0110, 0130, 0141, 0142, 0133, 0113, 0104,
|
||
0105, 0116, 0136, 0145, 0, /* 123 S */
|
||
0020, 0126, 0006, 0146, 0, /* 124 T */
|
||
0006, 0101, 0110, 0130, 0141, 0146, 0, /* 125 U */
|
||
0006, 0120, 0146, 0, /* 126 V */
|
||
0006, 0100, 0123, 0140, 0146, 0, /* 127 W */
|
||
0146, 0006, 0140, 0, /* 130 X */
|
||
0020, 0123, 0106, 0046, 0123, 0, /* 131 Y */
|
||
0006, 0146, 0100, 0140, 0033, 0113, 0, /* 132 Z */
|
||
0030, 0110, 0116, 0136, 0, /* 133 [ */
|
||
0006, 0140, 0, /* 134 \ */
|
||
0010, 0130, 0136, 0116, 0, /* 135 ] */
|
||
0003, 0126, 0143, 0, /* 136 ^ */
|
||
0140, 0, /* 137 _ */
|
||
0016, 0134, 0, /* original was backward */ /* 140 ` */
|
||
0032, 0112, 0101, 0110, 0130, 0133, 0124, 0114, 0, /* 141 a */
|
||
0006, 0100, 0120, 0131, 0133, 0124, 0104, 0, /* 142 b */
|
||
0033, 0124, 0114, 0103, 0101, 0110, 0120, 0131, 0, /* 143 c */
|
||
0036, 0130, 0110, 0101, 0103, 0114, 0134, 0, /* 144 d */
|
||
0002, 0132, 0133, 0124, 0114, 0103, 0101, 0110,
|
||
0120, 0, /* 145 e */
|
||
0010, 0115, 0126, 0136, 0145, 0023, 0103, 0, /* 146 f */
|
||
0200, 0320, 0331, 0134, 0114, 0103, 0101, 0110,
|
||
0130, 0, /* 147 g */
|
||
0106, 0004, 0124, 0133, 0130, 0, /* 150 h */
|
||
0020, 0124, 0025, 0125, 0, /* 151 i */
|
||
0201, 0310, 0320, 0331, 0134, 0035, 0135, 0, /* 152 j */
|
||
0105, 0034, 0101, 0023, 0130, 0, /* 153 k */
|
||
0010, 0130, 0020, 0126, 0116, 0, /* 154 l */
|
||
0104, 0114, 0122, 0134, 0144, 0140, 0, /* 155 m */
|
||
0104, 0124, 0133, 0130, 0, /* 156 n */
|
||
0010, 0120, 0131, 0133, 0124, 0114, 0103, 0101,
|
||
0110, 0, /* 157 o */
|
||
0200, 0104, 0124, 0133, 0131, 0120, 0100, 0, /* 160 p */
|
||
0030, 0110, 0101, 0103, 0114, 0134, 0330, 0341, 0, /* 161 q */
|
||
0104, 0124, 0133, 0, /* 162 r */
|
||
0001, 0110, 0120, 0131, 0122, 0112, 0103, 0114,
|
||
0124, 0133, 0, /* 163 s */
|
||
0030, 0121, 0125, 0034, 0114, 0, /* 164 t */
|
||
0014, 0111, 0120, 0130, 0141, 0144, 0, /* 165 u */
|
||
0004, 0120, 0144, 0, /* 166 v */
|
||
0004, 0102, 0110, 0122, 0130, 0142, 0144, 0, /* 167 w */
|
||
0134, 0004, 0130, 0, /* 170 x */
|
||
0210, 0120, 0134, 0004, 0120, 0, /* 171 y */
|
||
0004, 0134, 0100, 0130, 0, /* 172 z */
|
||
0030, 0121, 0122, 0113, 0124, 0125, 0136, 0, /* 173 { */
|
||
0020, 0122, 0024, 0126, 0, /* 174 | */
|
||
0010, 0121, 0122, 0133, 0124, 0125, 0116, 0, /* 175 } */
|
||
0003, 0114, 0132, 0143, 0, /* 176 ~ */
|
||
0140, 0146, 0106, 0100, 0010, 0116, 0026, 0120,
|
||
0030, 0136, 0 /* 177 rubout */
|
||
};
|
||
|
||
/* pointers to start of stroke data for each character */
|
||
static const unsigned char *sstroke[128] = { NULL }; /* init. at run time */
|
||
|
||
/* character generator; supports control chars, POPR on term character (VS60) */
|
||
|
||
static int /* returns nonzero iff VS60 char terminate feature triggered */
|
||
character(int c)
|
||
{
|
||
/* following table maps cs_index to line-feed spacing for VS60 */
|
||
static const unsigned char vs60_csp_h[4] =
|
||
{PSCALE(12), PSCALE(24), PSCALE(46), PSCALE(62)};
|
||
/* following tables map cs_index to adjustments for sub/superscript */
|
||
/* (cs_index 0 just a guess; others from VS60 Instruction Test Part II) */
|
||
static const unsigned char sus_left[4] =
|
||
{PSCALE(0), PSCALE(2), PSCALE(4), PSCALE(3)};
|
||
static const unsigned char susr_left[4] =
|
||
{PSCALE(0), PSCALE(2), PSCALE(4), PSCALE(0)};
|
||
static const unsigned char sub_down[4] =
|
||
{PSCALE(2), PSCALE(3), PSCALE(6), PSCALE(7)};
|
||
static const unsigned char sup_up[4] =
|
||
{PSCALE(5), PSCALE(9), PSCALE(18), PSCALE(24)};
|
||
static const unsigned char esus_right[4] =
|
||
{PSCALE(0), PSCALE(2), PSCALE(0), PSCALE(0)};
|
||
static const unsigned char esub_up[4] =
|
||
{PSCALE(2), PSCALE(3), PSCALE(6), PSCALE(8)};
|
||
int x, y;
|
||
int32 xbase, ybase, xnext, ynext;
|
||
|
||
if (shift_out) {
|
||
if (c >= 040) {
|
||
so_flag = char_irq = 1; /* will generate a char intr. */
|
||
char_buf = c;
|
||
return 0; /* presumably, no POPR on term? */
|
||
}
|
||
if (c == 017) { /* SHIFT IN */
|
||
shift_out = 0;
|
||
goto copy;
|
||
}
|
||
} else { /* !shift_out */
|
||
|
||
if (c <= 040) {
|
||
switch (c) {
|
||
|
||
case 000: /* NULL */
|
||
goto cesc; /* apparently not copied to char_buf */
|
||
case 010: /* BACKSPACE */
|
||
if (char_rotate)
|
||
ypos -= CSCALE(vt11_csp_w);
|
||
else
|
||
xpos -= CSCALE(vt11_csp_w);
|
||
break;
|
||
case 012: /* LINE FEED */
|
||
if (char_rotate)
|
||
xpos += (VT11 ? CSCALE(vt11_csp_h) : vs60_csp_h[cs_index]);
|
||
else
|
||
ypos -= (VT11 ? CSCALE(vt11_csp_h) : vs60_csp_h[cs_index]);
|
||
break;
|
||
case 015: /* CARRIAGE RETURN */
|
||
if (char_rotate)
|
||
ypos = yoff;
|
||
else
|
||
xpos = xoff;
|
||
break;
|
||
case 016: /* SHIFT OUT */
|
||
shift_out = 1;
|
||
break;
|
||
|
||
case 021: /* SUPERSCRIPT */
|
||
if (VT11)
|
||
break;
|
||
if (char_rotate) {
|
||
xpos -= sup_up[cs_index];
|
||
ypos -= susr_left[cs_index];
|
||
} else {
|
||
xpos -= sus_left[cs_index];
|
||
ypos += sup_up[cs_index];
|
||
}
|
||
if (cs_index > 0)
|
||
char_scale = csi2csf[--cs_index];
|
||
break;
|
||
case 022: /* SUBSCRIPT */
|
||
if (VT11)
|
||
break;
|
||
if (char_rotate) {
|
||
xpos += sub_down[cs_index];
|
||
ypos -= susr_left[cs_index];
|
||
} else {
|
||
xpos -= sus_left[cs_index];
|
||
ypos -= sub_down[cs_index];
|
||
}
|
||
if (cs_index > 0)
|
||
char_scale = csi2csf[--cs_index];
|
||
break;
|
||
case 023: /* END SUPERSCRIPT */
|
||
if (VT11)
|
||
break;
|
||
if (cs_index < 3)
|
||
char_scale = csi2csf[++cs_index];
|
||
if (char_rotate) {
|
||
xpos += sup_up[cs_index];
|
||
ypos += esus_right[cs_index];
|
||
} else {
|
||
xpos += esus_right[cs_index];
|
||
ypos -= sup_up[cs_index];
|
||
}
|
||
break;
|
||
case 024: /* END SUBSCRIPT */
|
||
if (VT11)
|
||
break;
|
||
if (cs_index < 3)
|
||
char_scale = csi2csf[++cs_index];
|
||
if (char_rotate) {
|
||
xpos -= esub_up[cs_index];
|
||
ypos += esus_right[cs_index];
|
||
} else {
|
||
xpos += esus_right[cs_index];
|
||
ypos += esub_up[cs_index];
|
||
}
|
||
break;
|
||
case 040: /* SPACE */
|
||
goto space;
|
||
default: /* other control codes ignored */
|
||
break;
|
||
}
|
||
goto copy;
|
||
}
|
||
}
|
||
|
||
/* VT11/VS60 doesn't draw any part of a character if its *baseline* is
|
||
(partly) offscreen; thus the top of a character might be clipped */
|
||
/* (no allowance for descender, italic, or interchar. spacing) */
|
||
|
||
/* virtual CRT coordinates of this and the next character's "origin": */
|
||
xbase = xnext = PNORM(xpos);
|
||
ybase = ynext = PNORM(ypos);
|
||
if (char_rotate)
|
||
ynext += (vt11_csp_w <= 12 ? 10 : 11);
|
||
else
|
||
xnext += (vt11_csp_w <= 12 ? 10 : 11);
|
||
|
||
edge_indic = ONSCREEN(xbase, ybase) && !ONSCREEN(xnext, ynext);
|
||
edge_flag = edge_indic ||
|
||
((!ONSCREEN(xbase, ybase)) && ONSCREEN(xnext, ynext));
|
||
/* (scaling cannot make spacing so large that it crosses the
|
||
"working surface" while going from offscreen to offscreen) */
|
||
if (edge_flag) {
|
||
if (edge_intr_ena) {
|
||
edge_irq = 1;
|
||
goto space;
|
||
} else
|
||
edge_flag = 0;
|
||
}
|
||
|
||
if (!ONSCREEN(xbase, ybase) || !ONSCREEN(xnext, ynext))
|
||
goto space;
|
||
|
||
/* plot a (nominally on-screen) graphic symbol */
|
||
|
||
if (VT11) {
|
||
unsigned char col, prvcol;
|
||
|
||
/* plot a graphic symbol (unscaled, unrotated) using a dot matrix */
|
||
|
||
/* not drawn in a serpentine manner; supports control characters */
|
||
|
||
/* draw pattern using 2x2 dot size, with fudges for spacing & italics */
|
||
/* (looks very nice under all conditions at full resolution) */
|
||
|
||
if (c >= 0140) { /* lower-case */
|
||
if (dots[c][0]) /* flag: with descender */
|
||
ybase -= 4;
|
||
x = 1; /* skip first column (descender flag) */
|
||
} else /* no descender */
|
||
x = 0;
|
||
|
||
prvcol = 0;
|
||
col = dots[c][x]; /* starting column bit pattern */
|
||
for (; x < 6; ++x) {
|
||
int xllc = 2*x, yllc = 0;
|
||
unsigned char nxtcol = (x == 5) ? 0 : dots[c][x+1];
|
||
|
||
/* no LP hit on first or last column */
|
||
lp_suppress = x == 0 || x == 5;
|
||
|
||
for (y = 0; y < 8; ++y) {
|
||
int delay_skew;
|
||
int compress = vt11_csp_w <= 12 && x == 2;
|
||
int dot = col & (1<<y), nxtdot;
|
||
|
||
if (dot) {
|
||
illum2(xbase + xllc, ybase + yllc);
|
||
if (!compress || (nxtdot = nxtcol & (1<<y)) == 0)
|
||
illum2(xbase + xllc + 1, ybase + yllc);
|
||
}
|
||
if (italics) {
|
||
delay_skew = 0;
|
||
if ((y % 3) != 0
|
||
&& !(delay_skew = ((prvcol & (3<<y))>>y) == 2))
|
||
++xllc; /* shift within selected dots */
|
||
}
|
||
++yllc;
|
||
if (dot) {
|
||
illum2(xbase + xllc, ybase + yllc);
|
||
if (!compress || nxtdot == 0)
|
||
illum2(xbase + xllc + 1, ybase + yllc);
|
||
}
|
||
if (italics && delay_skew)
|
||
++xllc; /* shift between selected dots */
|
||
++yllc;
|
||
}
|
||
if (vt11_csp_w <= 12 && x == 2) /* narrow spacing: */
|
||
--xbase; /* slight compression */
|
||
|
||
prvcol = col;
|
||
col = nxtcol;
|
||
}
|
||
lp_suppress = 0;
|
||
|
||
} else { /* VS60 */
|
||
const unsigned char *p; /* -> stroke data */
|
||
unsigned char s; /* encoded stroke */
|
||
int32 xlast, ylast; /* "beam follower" within character */
|
||
int32 xp = xpos, yp = ypos; /* save these (altered by vector2()) */
|
||
|
||
/* plot a graphic symbol using vector strokes */
|
||
|
||
/* initialize starting stroke pointers upon first use only */
|
||
if (sstroke[0] == NULL) {
|
||
p = stroke; /* -> stroke data */
|
||
|
||
for (s = 0; s < 128; ++s) { /* for each ASCII code value s */
|
||
sstroke[s] = p; /* code's stroke list starts here */
|
||
while (*p++) /* 0 terminates the data */
|
||
;
|
||
}
|
||
}
|
||
|
||
stroking = 1; /* prevents stroke clipping etc. and
|
||
tells vector2() to apply global
|
||
character scale factor */
|
||
xlast = ylast = 0;
|
||
for (p = sstroke[c]; (s = *p) != 0; ++p) {
|
||
xnext = (s & 0070) >> 3;
|
||
if (xnext == 7)
|
||
xnext = -1; /* (kludge needed for pound sterling) */
|
||
ynext = s & 0007; /* delay stretching for just a moment */
|
||
if (s & 0200)
|
||
ynext -= 2; /* kludge for stroke below baseline */
|
||
xnext *= 2;
|
||
if (italics)
|
||
xnext += ynext;
|
||
ynext *= 2; /* safe to stretch now */
|
||
|
||
if (s & 0100) { /* visible stroke */
|
||
int32 dx = xnext - xlast, /* (okay if both 0) */
|
||
dy = ynext - ylast;
|
||
|
||
if (char_rotate)
|
||
vector2(1, -dy, dx);
|
||
else
|
||
vector2(1, dx, dy);
|
||
} else /* invisible stroke, can do faster */
|
||
if (char_rotate) {
|
||
xpos = xp - CSCALE(ynext);
|
||
ypos = yp + CSCALE(xnext);
|
||
} else {
|
||
xpos = xp + CSCALE(xnext);
|
||
ypos = yp + CSCALE(ynext);
|
||
}
|
||
xlast = xnext;
|
||
ylast = ynext;
|
||
skip_start = (s & 0100) && (p[1] & 0100); /* avoid bright dot */
|
||
}
|
||
/* skip_start was reset to 0 by the last iteration! */
|
||
stroking = 0;
|
||
xpos = xp; /* restore for use in spacing (below) */
|
||
ypos = yp;
|
||
} /* end of graphic character drawing */
|
||
|
||
space:
|
||
if (char_rotate)
|
||
ypos += CSCALE(vt11_csp_w);
|
||
else
|
||
xpos += CSCALE(vt11_csp_w);
|
||
|
||
/* There may have been multiple LP hits during drawing;
|
||
the last one is the only one that can be reported. */
|
||
|
||
copy:
|
||
char_buf = c;
|
||
|
||
cesc:
|
||
if (char_escape && c == char_term) { /* (VS60) */
|
||
pop(1);
|
||
return 1;
|
||
} else
|
||
return 0;
|
||
}
|
||
|
||
/*
|
||
* Perform one display processor "cycle":
|
||
* If display processor is halted or awaiting sync, just performs "background"
|
||
* maintenance tasks and returns 0.
|
||
* Otherwise, draws any pending clipped vector (VS60 only).
|
||
* Otherwise, completes any pending second CHAR or BSVECT (must be a RESUME
|
||
* after interrupt on first CHAR or BSVECT), or fetches one word from the
|
||
* display file and processes it. May post an interrupt; returns 1 if display
|
||
* processor is still running, or 0 if halted or an interrupt was posted.
|
||
*
|
||
* word_number keeps track of the state of multi-word graphic data parsing;
|
||
* word_number also serves to keep track of half-word for graphic data having
|
||
* two independent entities encoded within one word (CHAR or BSVECT).
|
||
* Note that, for the VT11, there might be control words (e.g. JMPA) embedded
|
||
* within the data! (We don't know of any application that exploits this.)
|
||
*/
|
||
int
|
||
vt11_cycle(int us, int slowdown)
|
||
{
|
||
static vt11word inst;
|
||
static int i;
|
||
static int32 x, y, z, ex, ey, sxo, syo, szo;
|
||
int c;
|
||
int32 ez;
|
||
static uint32 usec = 0; /* cumulative */
|
||
static uint32 msec = 0; /* ditto */
|
||
uint32 new_msec;
|
||
INIT
|
||
/* keep running time counter; track state even when processor is idle */
|
||
|
||
new_msec = (usec += us) / 1000;
|
||
|
||
if (msec / BLINK_COUNT != new_msec / BLINK_COUNT)
|
||
blink_off = !blink_off;
|
||
|
||
/* if awaiting sync, look for next frame start */
|
||
if (sync_period && (msec / sync_period != new_msec / sync_period))
|
||
sync_period = 0; /* start next frame */
|
||
|
||
msec = new_msec;
|
||
|
||
if ((sync_period || maint1 || !busy) && !maint2)
|
||
goto age_ret; /* just age the display */
|
||
|
||
/* draw a clipped vector [perhaps after resume from edge interrupt] */
|
||
|
||
if (clip_vect) {
|
||
int32 dx = clip_x1 - clip_x0,
|
||
dy = clip_y1 - clip_y0,
|
||
dz = clip_z1 - clip_z0;
|
||
DEBUGF(("clipped vector i%d (%ld,%ld,%ld) to (%ld,%ld,%ld)\r\n", clip_i,
|
||
(long)clip_x0, (long)clip_y0, (long)clip_z0,
|
||
(long)clip_x1, (long)clip_y1, (long)clip_z1));
|
||
if (VS60 /* XXX assuming VT11 doesn't display */
|
||
&& (dx != 0 || dy != 0 || dz != 0) /* hardware skips null vects */
|
||
&& clip_i && int0_scope) { /* show it */
|
||
if (menu)
|
||
lineTwoStep(clip_x0 + MENU_OFFSET, clip_y0, clip_z0,
|
||
clip_x1 + MENU_OFFSET, clip_y1, clip_z1);
|
||
else
|
||
lineTwoStep(clip_x0, clip_y0, clip_z0,
|
||
clip_x1, clip_y1, clip_z1);
|
||
}
|
||
/*
|
||
* In case of LP hit, recompute coords using "tangent register",
|
||
* because:
|
||
* (1) distinct virtual CRT points can be mapped into the same pixel
|
||
* (2) raster computation might not match that of the actual VT48
|
||
*/
|
||
if (lp0_hit) {
|
||
long tangent;
|
||
int32 adx = ABS(dx), ady = ABS(dy);
|
||
if (adx >= ady) {
|
||
tangent = 010000L * dy / dx; /* signed */
|
||
lp_ypos = clip_y0 + tangent * (lp_xpos - clip_x0) / 010000L;
|
||
tangent = 010000L * dz / dx;
|
||
lp_zpos = clip_z0 + tangent * (lp_xpos - clip_x0) / 010000L;
|
||
} else {
|
||
tangent = 010000L * dx / dy; /* signed */
|
||
lp_xpos = clip_x0 + tangent * (lp_ypos - clip_y0) / 010000L;
|
||
tangent = 010000L * dz / dy;
|
||
lp_zpos = clip_z0 + tangent * (lp_ypos - clip_y0) / 010000L;
|
||
}
|
||
DEBUGF(("adjusted LP coords (0%o,0%o,0%o)\r\n",
|
||
lp_xpos, lp_ypos, lp_zpos));
|
||
/* xpos,ypos,zpos still pertain to the original endpoint
|
||
(assuming that Maintenance Switch 3 isn't set) */
|
||
}
|
||
if (VS60) { /* XXX assuming just 1 intr for VT11 */
|
||
edge_xpos = clip_x1;
|
||
edge_ypos = clip_y1;
|
||
edge_zpos = clip_z1;
|
||
edge_indic = (clip_vect & 2) != 0; /* indicate clipped going out */
|
||
edge_flag = edge_intr_ena;
|
||
if (edge_flag) {
|
||
edge_irq = 1;
|
||
vt_lpen_intr(); /* post graphic interrupt to host */
|
||
}
|
||
}
|
||
clip_vect = 0; /* this finishes the condition */
|
||
goto check; /* possibly post more interrupts; age */
|
||
}
|
||
|
||
/* fetch next word from display file (if needed) and process it */
|
||
|
||
if (word_number != 1 || (graphic_mode != CHAR && graphic_mode != BSVECT)) {
|
||
time_out = vt_fetch((uint32)((DPC+reloc)&0777777), &inst);
|
||
DPC += 2;
|
||
if (time_out)
|
||
goto bus_timeout;
|
||
DEBUGF(("0%06o: 0%06o\r\n",
|
||
(unsigned)(DPC - 2 + reloc) & 0777777, (unsigned)inst));
|
||
if (finish_jmpa)
|
||
goto jmpa;
|
||
if (finish_jsra)
|
||
goto jsra;
|
||
}
|
||
/* else have processed only half the CHAR or BSVECT data word so far */
|
||
|
||
fetched:
|
||
|
||
if (TESTBIT(inst,15)) { /* control */
|
||
unsigned op;
|
||
mode_field = GETFIELD(inst,14,11); /* save bits 14-11 for diags. */
|
||
word_number = -1; /* flags "control mode"; ersatz 0 */
|
||
switch (mode_field) {
|
||
|
||
case 7: /* Set Graphic Mode 0111 */
|
||
case 011: /* Set Graphic Mode 1001 */
|
||
if (VT11)
|
||
goto bad_ins;
|
||
/*FALLTHRU*/
|
||
case 010: /* Set Graphic Mode 1000 */
|
||
if (VT11) {
|
||
DEBUGF("SGM 1000 IGNORED\r\n");
|
||
break;
|
||
}
|
||
/*FALLTHRU*/
|
||
case 0: /* Set Graphic Mode 0000 */
|
||
case 1: /* Set Graphic Mode 0001 */
|
||
case 2: /* Set Graphic Mode 0010 */
|
||
case 3: /* Set Graphic Mode 0011 */
|
||
case 4: /* Set Graphic Mode 0100 */
|
||
case 5: /* Set Graphic Mode 0101 */
|
||
case 6: /* Set Graphic Mode 0110 */
|
||
DEBUGF("Set Graphic Mode %u", (unsigned)mode_field);
|
||
graphic_mode = mode_field;
|
||
offset = 0;
|
||
shift_out = 0; /* seems to be right */
|
||
if (TESTBIT(inst,10)) {
|
||
intensity = GETFIELD(inst,9,7);
|
||
DEBUGF(" intensity=%d", (int)intensity);
|
||
}
|
||
if (TESTBIT(inst,6)) {
|
||
lp0_intr_ena = TESTBIT(inst,5);
|
||
DEBUGF(" lp0_intr_ena=%d", (int)lp0_intr_ena);
|
||
}
|
||
if (TESTBIT(inst,4)) {
|
||
blink_ena = TESTBIT(inst,3);
|
||
DEBUGF(" blink=%d", (int)blink_ena);
|
||
}
|
||
if (TESTBIT(inst,2)) {
|
||
line_type = GETFIELD(inst,1,0);
|
||
DEBUGF(" line_type=%d", (int)line_type);
|
||
}
|
||
DEBUGF("\r\n");
|
||
break;
|
||
|
||
case 012: /* 1010: Load Name Register */
|
||
if (VT11)
|
||
goto bad_ins;
|
||
name = GETFIELD(inst,10,0);
|
||
DEBUGF("Load Name Register name=0%o\r\n", name);
|
||
{ static unsigned nmask[4] = { 0, 03777, 03770, 03600 };
|
||
|
||
if (search != 0 && ((name^assoc_name) & nmask[search]) == 0)
|
||
name_irq = 1; /* will cause name-match interrupt */
|
||
}
|
||
break;
|
||
|
||
case 013: /* 1011: Load Status C */
|
||
if (VT11)
|
||
goto bad_ins;
|
||
DEBUGF("Load Status C");
|
||
if (TESTBIT(inst,9)) {
|
||
char_rotate = TESTBIT(inst,8);
|
||
DEBUGF(" char_rotate=d", (int)char_rotate);
|
||
}
|
||
if (TESTBIT(inst,7)) {
|
||
cs_index = GETFIELD(inst,6,5); /* 0, 1, 2, 3 */
|
||
char_scale = csi2csf[cs_index]; /* for faster CSCALE macro */
|
||
DEBUGF(" cs_index=%d(x%d/4)", (int)cs_index, (int)char_scale);
|
||
}
|
||
if (TESTBIT(inst,4)) {
|
||
vector_scale = GETFIELD(inst,3,0);
|
||
DEBUGF(" vector_scale=%d/4", (int)vector_scale);
|
||
}
|
||
DEBUGF("\r\n");
|
||
break;
|
||
|
||
case 014: /* 1100__ */
|
||
if (VT11) /* other bits are "spare" */
|
||
op = 0; /* always Display Jump Absolute */
|
||
else
|
||
op = GETFIELD(inst,10,9);
|
||
switch (op) {
|
||
|
||
case 0: /* 110000: Display Jump Absolute */
|
||
finish_jmpa = 1;
|
||
break;
|
||
jmpa:
|
||
finish_jmpa = 0;
|
||
DPC = inst & ~1;
|
||
DEBUGF("Display Jump Absolute 0%06o\r\n", (unsigned)inst);
|
||
break;
|
||
|
||
case 1: /* 110001: Display Jump Relative */
|
||
ez = GETFIELD(inst,7,0);/* relative address (words) */
|
||
ez *= 2; /* convert to bytes */
|
||
/* have to be careful; DPC is unsigned */
|
||
if (TESTBIT(inst,8)) {
|
||
#if 0 /* manual seems to say this, but it's wrong: */
|
||
DPC -= ez;
|
||
DEBUGF(("Display Jump Relative -0%o\r\n",
|
||
(unsigned)ez));
|
||
#else /* sign extend, twos complement add, 16-bit wrapping */
|
||
DPC = (DPC + (~0777 | ez)) & 0177777;
|
||
DEBUGF(("Display Jump Relative -0%o\r\n",
|
||
~((~0777 | ez) - 1)));
|
||
#endif
|
||
} else {
|
||
DPC += (vt11word)ez;
|
||
DEBUGF(("Display Jump Relative +0%o\r\n",
|
||
(unsigned)ez));
|
||
}
|
||
/* DPC was already incremented by 2 */
|
||
break;
|
||
|
||
case 2: /* 110010: Display Jump to Subroutine Absolute */
|
||
finish_jsra = 1;
|
||
jsr = 1; /* diagnostic test needs this here */
|
||
/* but the documentation says JSR bit set only for JSR REL! */
|
||
goto check; /* (break would set jsr = 0) */
|
||
jsra:
|
||
finish_jsra = 0;
|
||
push(); /* save return address and parameters */
|
||
DPC = inst & ~1;
|
||
DEBUGF(("Display Jump to Subroutine Absolute 0%06o\r\n",
|
||
(unsigned)inst));
|
||
goto check; /* (break would set jsr = 0) */
|
||
|
||
case 3: /* 110011: Display Jump to Subroutine Relative */
|
||
ez = GETFIELD(inst,7,0);/* relative address (words) */
|
||
ez *= 2; /* convert to bytes */
|
||
push(); /* save return address and parameters */
|
||
/* have to be careful; DPC is unsigned */
|
||
if (TESTBIT(inst,8)) {
|
||
#if 0 /* manual seems to say this, but it's wrong: */
|
||
DPC -= ez;
|
||
DEBUGF(("Display Jump to Subroutine Relative -0%o\r\n",
|
||
(unsigned)ez));
|
||
#else /* sign extend, twos complement add, 16-bit wrapping */
|
||
DPC = (DPC + (~0777 | ez)) & 0177777;
|
||
DEBUGF(("Display Jump to Subroutine Relative -0%o\r\n",
|
||
~((~0777 | ez) - 1)));
|
||
#endif
|
||
} else {
|
||
DPC += (vt11word)ez;
|
||
DEBUGF(("Display Jump to Subroutine Relative +0%o\r\n",
|
||
(unsigned)ez));
|
||
}
|
||
/* DPC was already incremented by 2 */
|
||
break; /* jsr = 0 ?? */
|
||
}
|
||
break;
|
||
|
||
case 015: /* 1101__ */
|
||
if (VT11)
|
||
DEBUGF("Display NOP\r\n");
|
||
else {
|
||
op = GETFIELD(inst,10,9);
|
||
switch (op) {
|
||
|
||
case 0: /* 110100: Load Scope Selection */
|
||
/* also used as Display NOP */
|
||
DEBUGF("Load Scope Selection");
|
||
c = TESTBIT(inst,8);
|
||
DEBUGF(" console=%d", c);
|
||
if (TESTBIT(inst,7)) {
|
||
ez = TESTBIT(inst,6);
|
||
DEBUGF(" blank=%d", (int)!ez);
|
||
if (c)
|
||
int1_scope = (unsigned char)(ez & 0xFF);
|
||
else
|
||
int0_scope = (unsigned char)(ez & 0xFF);
|
||
}
|
||
if (TESTBIT(inst,5)) {
|
||
ez = TESTBIT(inst,4);
|
||
DEBUGF(" lp_intr_ena=%d", (int)ez);
|
||
if (c)
|
||
lp1_intr_ena = (unsigned char)(ez & 0xFF);
|
||
else
|
||
lp0_intr_ena = (unsigned char)(ez & 0xFF);
|
||
}
|
||
if (TESTBIT(inst,3)) {
|
||
ez = TESTBIT(inst,2);
|
||
DEBUGF(" lp_sw_intr_ena=%d", (int)ez);
|
||
if (c)
|
||
lp1_sw_intr_ena = (unsigned char)(ez & 0xFF);
|
||
else
|
||
lp0_sw_intr_ena = (unsigned char)(ez & 0xFF);
|
||
}
|
||
DEBUGF("\r\n");
|
||
break;
|
||
|
||
case 1: /* 110101: Display POP Not Restore */
|
||
DEBUGF("Display POP Not Restore\r\n");
|
||
pop(0); /* sets new DPC as side effect */
|
||
break;
|
||
|
||
case 2: /* 110110: Display POP Restore */
|
||
DEBUGF("Display POP Restore\r\n");
|
||
pop(1); /* sets new DPC as side effect */
|
||
break;
|
||
|
||
default: /* 110111: undocumented -- ignored? */
|
||
DEBUGF("Display NOP?\r\n");
|
||
}
|
||
}
|
||
break;
|
||
|
||
case 016: /* 1110: Load Status A */
|
||
DEBUGF("Load Status A");
|
||
internal_stop = TESTBIT(inst,10); /* 11101 Display Stop */
|
||
if (internal_stop) {
|
||
stopped = 1; /* (synchronous with display cycle) */
|
||
DEBUGF(" stop");
|
||
}
|
||
if (TESTBIT(inst,9)) {
|
||
stop_intr_ena = TESTBIT(inst,8);
|
||
DEBUGF(" stop_intr_ena=%d", (int)stop_intr_ena);
|
||
}
|
||
if (TESTBIT(inst,7)) {
|
||
lp_intensify = !TESTBIT(inst,6);
|
||
DEBUGF(" lp_intensify=%d", (int)lp_intensify);
|
||
}
|
||
if (TESTBIT(inst,5)) {
|
||
italics = TESTBIT(inst,4);
|
||
DEBUGF(" italics=%d", (int)italics);
|
||
}
|
||
refresh_rate = GETFIELD(inst,VS60?3:2,2);
|
||
DEBUGF(" refresh=%d", refresh_rate);
|
||
if (sync_period != refresh_rate)
|
||
DEBUGF("old sync_period=%d, new refresh=%d", sync_period, refresh_rate);
|
||
switch (refresh_rate) {
|
||
case 0: /* continuous */
|
||
sync_period = 0;
|
||
break;
|
||
case 1: /* VT11: 60 Hz; VS60: 30 Hz */
|
||
sync_period = VT11 ? 17 : 33;
|
||
break;
|
||
case 2: /* VS60: 40 Hz */
|
||
sync_period = 25;
|
||
break;
|
||
default: /* (case 3) VS60: external sync */
|
||
sync_period = 17; /* fake a 60 Hz source */
|
||
break;
|
||
}
|
||
if (internal_stop) {
|
||
sync_period = 0; /* overridden */
|
||
}
|
||
if (VS60 && TESTBIT(inst,1)) {
|
||
menu = TESTBIT(inst,0);
|
||
DEBUGF(" menu=%d", (int)menu);
|
||
}
|
||
DEBUGF("\r\n");
|
||
break;
|
||
|
||
case 017: /* 1111_ */
|
||
if (VS60 && TESTBIT(inst,10)) { /* 11111: Load Status BB */
|
||
DEBUGF("Load Status BB");
|
||
if (TESTBIT(inst,7)) {
|
||
depth_cue_proc = TESTBIT(inst,6);
|
||
DEBUGF(" depth_cue_proc=%d", (int)depth_cue_proc);
|
||
}
|
||
if (TESTBIT(inst,5)) {
|
||
edge_intr_ena = TESTBIT(inst,4);
|
||
DEBUGF(" edge_intr_ena=%d", (int)edge_intr_ena);
|
||
}
|
||
if (TESTBIT(inst,3)) {
|
||
file_z_data = TESTBIT(inst,2);
|
||
DEBUGF(" file_z_data=%d", (int)file_z_data);
|
||
}
|
||
if (TESTBIT(inst,1)) {
|
||
char_escape = TESTBIT(inst,0);
|
||
DEBUGF(" char_escape=%d", (int)char_escape);
|
||
}
|
||
} else { /* 11110: Load Status B */
|
||
DEBUGF("Load Status B");
|
||
if (VS60 && TESTBIT(inst,9)) {
|
||
color = GETFIELD(inst,8,7);
|
||
DEBUGF(" color=%d", (int)color);
|
||
}
|
||
if (TESTBIT(inst,6)) {
|
||
graphplot_step = GETFIELD(inst,5,0);
|
||
DEBUGF(" graphplot_step=%d", (int)graphplot_step);
|
||
}
|
||
}
|
||
DEBUGF("\r\n");
|
||
break;
|
||
|
||
default:
|
||
bad_ins: DEBUGF("SPARE COMMAND 0%o\r\n", mode_field);
|
||
/* "display processor hangs" */
|
||
DPC -= 2; /* hang around scene of crime */
|
||
break;
|
||
|
||
} /* end of control instruction opcode switch */
|
||
jsr = 0;
|
||
|
||
} else { /* graphic data */
|
||
|
||
#if 0 /* XXX ? */
|
||
lp0_hit = 0; /* XXX maybe not for OFFSET? */
|
||
#endif
|
||
if (word_number < 0) /* (after reset or control instr.) */
|
||
word_number = 0;
|
||
if (word_number == 0)
|
||
offset = 0;
|
||
|
||
#define MORE_DATA { ++word_number; goto check; }
|
||
|
||
switch (mode_field = graphic_mode) { /* save for MPR read */
|
||
|
||
case CHAR:
|
||
if (word_number > 1)
|
||
word_number = 0;
|
||
if (word_number == 0) {
|
||
c = GETFIELD(inst,6,0);
|
||
DEBUGF("char1 %d (", c);
|
||
DEBUGF(040 <= c && c < 0177 ? "'%c'" : "0%o", c);
|
||
DEBUGF(")\r\n");
|
||
if (character(c)) /* POPR was done; end chars */
|
||
break;
|
||
MORE_DATA /* post any intrs now */
|
||
}
|
||
c = GETFIELD(inst,15,8);
|
||
DEBUGF("char2 %d (", c);
|
||
DEBUGF(040 <= c && c < 0177 ? "'%c'" : "0%o", c);
|
||
DEBUGF(")\r\n");
|
||
(void)character(c);
|
||
break;
|
||
|
||
case SVECTOR:
|
||
if (word_number > 1 || (!file_z_data && word_number > 0))
|
||
word_number = 0;
|
||
if (word_number == 0) {
|
||
i = TESTBIT(inst,14); /* inten_ena: beam on */
|
||
x = GETFIELD(inst,12,7);/* delta_x */
|
||
if (TESTBIT(inst,13))
|
||
x = -x;
|
||
y = GETFIELD(inst,5,0); /* delta_y */
|
||
if (TESTBIT(inst,6))
|
||
y = -y;
|
||
if (file_z_data)
|
||
MORE_DATA
|
||
}
|
||
if (file_z_data) { /* (VS60) */
|
||
z = GETFIELD(inst,9,2); /* delta_z */
|
||
if (TESTBIT(inst,13))
|
||
z = -z;
|
||
DEBUGF(("short vector i%d (%d,%d,%d)\r\n",
|
||
i, (int)x, (int)y, (int)z));
|
||
vector3(i, x, y, z);
|
||
} else {
|
||
DEBUGF("short vector i%d (%d,%d)\r\n", i, (int)x, (int)y);
|
||
vector2(i, x, y);
|
||
}
|
||
break;
|
||
|
||
case LVECTOR:
|
||
if (word_number > 2 || (!file_z_data && word_number > 1))
|
||
word_number = 0;
|
||
if (word_number == 0) {
|
||
ex = VS60 && TESTBIT(inst,12);
|
||
i = TESTBIT(inst,14);
|
||
x = GETFIELD(inst,9,0); /* delta_x */
|
||
if (TESTBIT(inst,13))
|
||
x = -x;
|
||
MORE_DATA
|
||
}
|
||
if (word_number == 1) {
|
||
y = GETFIELD(inst,9,0); /* delta_y */
|
||
if (TESTBIT(inst,13))
|
||
y = -y;
|
||
if (file_z_data)
|
||
MORE_DATA
|
||
}
|
||
if (file_z_data) { /* (VS60) */
|
||
if (ex)
|
||
goto norot;
|
||
z = GETFIELD(inst,9,2); /* delta_z */
|
||
if (TESTBIT(inst,13))
|
||
z = -z;
|
||
DEBUGF(("long vector i%d (%d,%d,%d)\r\n",
|
||
i, (int)x, (int)y, (int)z));
|
||
vector3(i, x, y, z);
|
||
} else {
|
||
if (ex)
|
||
norot: /* undocumented and probably nonfunctional */
|
||
DEBUGF("ROTATE NOT SUPPORTED\r\n");
|
||
else {
|
||
DEBUGF("long vector i%d (%d,%d)\r\n", i, (int)x, (int)y);
|
||
vector2(i, x, y);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case POINT: /* (or OFFSET, if VS60) */
|
||
/* [VT48 manual incorrectly says point data doesn't use sign bit] */
|
||
if (word_number > 2 || (!file_z_data && word_number > 1))
|
||
word_number = 0;
|
||
if (word_number == 0) {
|
||
ex = GETFIELD(inst,(VS60?11:9),0);
|
||
offset = VS60 && TESTBIT(inst,12); /* offset flag */
|
||
if (!offset)
|
||
i = TESTBIT(inst,14); /* for point only */
|
||
if (VS60) {
|
||
sxo = TESTBIT(inst,13); /* sign bit */
|
||
if (sxo)
|
||
ex = -ex;
|
||
}
|
||
/* XXX if VT11, set xpos/xoff now?? */
|
||
MORE_DATA
|
||
}
|
||
if (word_number == 1) {
|
||
ey = GETFIELD(inst,(VS60?11:9),0);
|
||
if (VS60) {
|
||
syo = TESTBIT(inst,13); /* sign bit */
|
||
if (syo)
|
||
ey = -ey;
|
||
}
|
||
if (file_z_data)
|
||
MORE_DATA
|
||
}
|
||
if (file_z_data) { /* (VS60) */
|
||
ez = GETFIELD(inst,11,2);
|
||
szo = TESTBIT(inst,13); /* sign bit */
|
||
if (szo)
|
||
ez = -ez;
|
||
if (offset) { /* OFFSET rather than POINT */
|
||
DEBUGF("offset (%d,%d,%d)\r\n", (int)ex,(int)ey,(int)ez);
|
||
xoff = PSCALE(ex);
|
||
yoff = PSCALE(ey);
|
||
zoff = PSCALE(ez * 4); /* XXX include bits 1:0 ? */
|
||
s_xoff = (unsigned char)(sxo & 0xFF);
|
||
s_yoff = (unsigned char)(syo & 0xFF);
|
||
s_zoff = (unsigned char)(szo & 0xFF);
|
||
} else {
|
||
DEBUGF(("point i%d (%d,%d,%d)\r\n", i,
|
||
(int)ex, (int)ey, (int)ez));
|
||
point3(i, VSCALE(ex) + xoff, VSCALE(ey) + yoff,
|
||
VSCALE(ez * 4) + zoff, VS60);
|
||
}
|
||
} else {
|
||
if (offset) { /* (VS60) OFFSET rather than POINT */
|
||
DEBUGF("offset (%d,%d)\r\n", (int)ex, (int)ey);
|
||
xoff = PSCALE(ex);
|
||
yoff = PSCALE(ey);
|
||
s_xoff = (unsigned char)(sxo & 0xFF);
|
||
s_yoff = (unsigned char)(syo & 0xFF);
|
||
} else {
|
||
DEBUGF("point i%d (%d,%d)\r\n", i, (int)ex, (int)ey);
|
||
point2(i, VSCALE(ex) + xoff, VSCALE(ey) + yoff, VS60);
|
||
}
|
||
}
|
||
break;
|
||
|
||
case GRAPHX: /* (or BLVECT if VS60) */
|
||
word_number = 0;
|
||
i = TESTBIT(inst,14);
|
||
if (VS60 && TESTBIT(inst,10))
|
||
goto blv; /* (VS60) BLVECT rather than GRAPHX */
|
||
else {
|
||
ex = GETFIELD(inst,9,0);
|
||
DEBUGF("graphplot x (%d) i%d\r\n", (int)ex, i);
|
||
ey = ypos + VSCALE(graphplot_step);
|
||
/* VT48 ES says first datum doesn't increment Y; that's wrong */
|
||
/* diagnostic DZVSD shows that "i" bit is ignored! */
|
||
point2(1, VSCALE(ex) + xoff, ey, VS60);
|
||
}
|
||
break;
|
||
|
||
case GRAPHY: /* (or BLVECT if VS60) */
|
||
word_number = 0;
|
||
i = TESTBIT(inst,14);
|
||
if (VS60 && TESTBIT(inst,10)) {
|
||
blv: /* (VS60) BLVECT rather than GRAPHY */
|
||
x = GETFIELD(inst,13,11); /* direction */
|
||
y = GETFIELD(inst,9,0); /* length */
|
||
DEBUGF(("basic long vector i%d d%d l%d\r\n",
|
||
i, (int)x, (int)y));
|
||
basic_vector(i, (int)x, (int)y);
|
||
} else {
|
||
ey = GETFIELD(inst,9,0);
|
||
DEBUGF("graphplot y (%d) i%d\r\n", (int)ey, i);
|
||
ex = xpos + VSCALE(graphplot_step);
|
||
/* VT48 ES says first datum doesn't increment X; that's wrong */
|
||
/* diagnostic DZVSD shows that "i" bit is ignored! */
|
||
point2(1, ex, VSCALE(ey) + yoff, VS60);
|
||
}
|
||
break;
|
||
|
||
case RELPOINT:
|
||
if (word_number > 1 || (!file_z_data && word_number > 0))
|
||
word_number = 0;
|
||
if (word_number == 0) {
|
||
i = TESTBIT(inst,14);
|
||
ex = GETFIELD(inst,12,7);
|
||
if (TESTBIT(inst,13))
|
||
ex = -ex;
|
||
ey = GETFIELD(inst,5,0);
|
||
if (TESTBIT(inst,6))
|
||
ey = -ey;
|
||
if (file_z_data)
|
||
MORE_DATA
|
||
}
|
||
if (file_z_data) { /* (VS60) */
|
||
ez = GETFIELD(inst,9,2);
|
||
if (TESTBIT(inst,13))
|
||
ez = -ez;
|
||
DEBUGF(("relative point i%d (%d,%d,%d)\r\n",
|
||
i, (int)ex, (int)ey, (int)ez));
|
||
point3(i, xpos + VSCALE(ex), ypos + VSCALE(ey),
|
||
zpos + VSCALE(ez * 4), 1);
|
||
} else {
|
||
DEBUGF("relative point i%d (%d,%d)\r\n", i, (int)ex, (int)ey);
|
||
point2(i, xpos + VSCALE(ex), ypos + VSCALE(ey), 1);
|
||
}
|
||
break;
|
||
|
||
/* the remaining graphic data types are supported by the VS60 only */
|
||
|
||
case BSVECT: /* (VS60) */
|
||
if (word_number > 1)
|
||
word_number = 0;
|
||
if (word_number == 0) {
|
||
i = TESTBIT(inst,14);
|
||
x = GETFIELD(inst,6,4); /* direction 0 */
|
||
y = GETFIELD(inst,3,0); /* length 0 */
|
||
ex = GETFIELD(inst,13,11); /* direction 1 */
|
||
ey = GETFIELD(inst,10,7); /* length 1 */
|
||
DEBUGF(("basic short vector1 i%d d%d l%d\r\n",
|
||
i, (int)x, (int)y));
|
||
basic_vector(i, (int)x, (int)y);
|
||
if (lphit_irq || edge_irq) /* MORE_DATA skips this */
|
||
vt_lpen_intr(); /* post graphic interrupt to host */
|
||
MORE_DATA
|
||
}
|
||
DEBUGF("basic short vector2 i%d d%d l%d\r\n", i, (int)ex,(int)ey);
|
||
basic_vector(i, (int)ex, (int)ey);
|
||
break;
|
||
|
||
case ABSVECTOR: /* (VS60) */
|
||
/* Note: real VS60 can't handle a delta of more than +-4095 */
|
||
if (word_number > 2 || (!file_z_data && word_number > 1))
|
||
word_number = 0;
|
||
if (word_number == 0) {
|
||
i = TESTBIT(inst,14);
|
||
x = GETFIELD(inst,11,0);
|
||
if (TESTBIT(inst,13))
|
||
x = -x;
|
||
MORE_DATA
|
||
}
|
||
if (word_number == 1) {
|
||
y = GETFIELD(inst,11,0);
|
||
if (TESTBIT(inst,13))
|
||
y = -y;
|
||
if (file_z_data)
|
||
MORE_DATA
|
||
}
|
||
if (file_z_data) {
|
||
z = GETFIELD(inst,11,2);
|
||
if (TESTBIT(inst,13))
|
||
z = -z;
|
||
DEBUGF(("absolute vector i%d (%d,%d,%d)\r\n",
|
||
i, (int)x, (int)y, (int)z));
|
||
ex = VSCALE(x) + xoff;
|
||
ey = VSCALE(y) + yoff;
|
||
ez = VSCALE(z * 4) + zoff;
|
||
vector3(i, PNORM(ex - xpos), PNORM(ey - ypos),
|
||
PNORM(ez - zpos) / 4); /* approx. */
|
||
zpos = ez; /* more precise, if PSCALEF > 1 */
|
||
} else {
|
||
DEBUGF("absolute vector i%d (%d,%d)\r\n", i, (int)x, (int)y);
|
||
ex = VSCALE(x) + xoff;
|
||
ey = VSCALE(y) + yoff;
|
||
vector2(i, PNORM(ex - xpos), PNORM(ey - ypos)); /* approx. */
|
||
}
|
||
xpos = ex; /* more precise, if PSCALEF > 1 */
|
||
ypos = ey;
|
||
break;
|
||
|
||
case CIRCLE: /* (VS60) */
|
||
if (word_number > 5 || (!file_z_data && word_number > 3))
|
||
word_number = 0;
|
||
if (word_number == 0) {
|
||
i = TESTBIT(inst,14);
|
||
x = GETFIELD(inst,9,0); /* delta cx */
|
||
if (TESTBIT(inst,13))
|
||
x = -x;
|
||
MORE_DATA
|
||
}
|
||
if (word_number == 1) {
|
||
y = GETFIELD(inst,9,0); /* delta cy */
|
||
if (TESTBIT(inst,13))
|
||
y = -y;
|
||
MORE_DATA
|
||
}
|
||
if (word_number == 2) {
|
||
if (file_z_data) {
|
||
z = GETFIELD(inst,11,2); /* delta cz */
|
||
if (TESTBIT(inst,13))
|
||
z = -z;
|
||
MORE_DATA
|
||
}
|
||
}
|
||
if (word_number == 2 + file_z_data) {
|
||
ex = GETFIELD(inst,9,0); /* delta ex */
|
||
if (TESTBIT(inst,13))
|
||
ex = -ex;
|
||
MORE_DATA
|
||
}
|
||
if (word_number == 3 + file_z_data) {
|
||
ey = GETFIELD(inst,9,0); /* delta ey */
|
||
if (TESTBIT(inst,13))
|
||
ey = -ey;
|
||
if (file_z_data)
|
||
MORE_DATA
|
||
}
|
||
if (file_z_data) {
|
||
ez = GETFIELD(inst,11,2); /* delta ez */
|
||
if (TESTBIT(inst,13))
|
||
ez = -ez;
|
||
DEBUGF(("circle/arc i%d C(%d,%d,%d) E(%d,%d,%d)\r\n",
|
||
i, (int)x, (int)y, (int)z, (int)ex, (int)ey, (int)ez));
|
||
conic3(i, x, y, z, ex, ey, ez); /* approx. */
|
||
} else {
|
||
DEBUGF(("circle/arc i%d C(%d,%d) E(%d,%d)\r\n",
|
||
i, (int)x, (int)y, (int)ex, (int)ey));
|
||
conic2(i, x, y, ex, ey);
|
||
}
|
||
break;
|
||
|
||
default: /* "can't happen" */
|
||
DPC -= 2; /* hang around scene of crime */
|
||
break;
|
||
|
||
} /* end of graphic_mode switch */
|
||
++word_number;
|
||
|
||
/* LP hit & edge interrupts triggered only while in data mode */
|
||
if (lphit_irq || edge_irq)
|
||
vt_lpen_intr(); /* post graphic interrupt to host */
|
||
|
||
} /* end of instruction decoding and execution */
|
||
goto check;
|
||
|
||
bus_timeout:
|
||
DEBUGF("TIMEOUT\r\n");
|
||
/* fall through to check (time_out has already been set) */
|
||
|
||
check:
|
||
|
||
/* post an interrupt if conditions are right;
|
||
because this simulation has no pipeline, only one is active at a time */
|
||
|
||
if (lp0_sw_state != display_lp_sw) { /* tip-switch state change */
|
||
lp0_sw_state = display_lp_sw; /* track switch state */
|
||
lp0_up = !(lp0_down = lp0_sw_state); /* set transition flags */
|
||
if (lp0_sw_intr_ena)
|
||
lpsw_irq = 1;
|
||
}
|
||
|
||
if (lpsw_irq) /* (LP hit or edge interrupt already triggered above) */
|
||
vt_lpen_intr(); /* post graphic interrupt to host */
|
||
else if (internal_stop && stop_intr_ena) /* ext_stop does immediately */
|
||
vt_stop_intr(); /* post stop interrupt to host */
|
||
else if (char_irq || stack_over || stack_under || time_out)
|
||
vt_char_intr(); /* post character interrupt to host */
|
||
else if (name_irq)
|
||
vt_name_intr(); /* post name-match interrupt to host */
|
||
#if 1 /* risky? */
|
||
else /* handle any pending 2nd CHAR/BSVECT */
|
||
if (word_number == 1 && (graphic_mode==CHAR || graphic_mode==BSVECT))
|
||
goto fetched;
|
||
#endif
|
||
|
||
/* fall through to age_ret */
|
||
|
||
age_ret:
|
||
display_age(us, slowdown);
|
||
return !maint1 && !maint2 && busy;
|
||
} /* vt11_cycle */
|