Rotating Pyramid

This program renders a rotating 3D wireframe pyramid with hidden-line elimination, based on algorithms from the Myers book “Microcomputer Graphics.” It uses a spherical coordinate viewing system (RHO, THETA, PHI) with perspective projection centered at screen coordinates (127, 87), and applies incremental rotation matrices across 36 frames to animate the pyramid. Hidden faces are detected by computing surface normal vectors via cross products and testing their dot product against the eye vector; edges shared by two visible faces are marked with a status value of 2 in the edge table array E(6,3). All computed frame data is stored sequentially in a flat array P(912), with the first 48 values duplicated at the end (line 750) to enable seamless looping during playback.

From Roy Myer’s book Microcomputer Graphics.

---

Program Analysis

Program Structure

The program divides into three distinct phases: a one-time setup and data-loading phase (lines 1–150), a pre-computation loop that calculates all 36 animation frames and stores them in array P (lines 160–740), and a playback loop that reads from P and draws to the screen (lines 780–970). This separation means all the mathematically expensive work is done before any drawing begins.

3D Geometry and Viewing Model

The pyramid is defined by four vertices in array V(4,3): an apex at (0,0,3) and three base vertices. A spherical coordinate camera is set up with RHO=15, THETA=0.5, and PHI=0.9. The view transform converts world coordinates to eye space using the standard spherical-to-Cartesian rotation, and perspective projection divides by the eye-space Z component, scaled by D=400 and offset by screen center CX=127, CY=87.

Hidden-Line Elimination

Face visibility is determined by computing the surface normal for each of the four triangular faces via the cross product of two edge vectors (lines 290–380). The eye position in world space is computed at line 390, and for each face the dot product of the normal with the vector from the face vertex to the eye is tested (line 460). Faces with a non-positive dot product are back-facing and skipped.

Edge visibility tracking uses the array E(6,3), where columns 1 and 2 store vertex indices and column 3 stores a count: 1 means the edge borders one visible face, 2 means it is shared by two visible faces and is therefore a silhouette or interior edge. Only edges with a non-zero status are recorded for drawing (line 590). The edge table is cleared each frame at line 270.

Frame Pre-computation and Storage

Rather than drawing directly, each frame’s visible edge endpoints are packed four values at a time into the flat array P(912) using pointer ADDR: P(ADDR)=x1, P(ADDR+1)=y1, P(ADDR+2)=x2, P(ADDR+3)=y2. With 6 potential edges × 4 values × 36 frames = 864 entries, the array is sized at 912 to accommodate the 48-value wrap-around copy added at line 750, which allows the playback loop to seamlessly cycle.

Rotation

Each frame, all four vertices are rotated by a small incremental rotation matrix computed from angles TN, TT, and TP (lines 650–680). The sine and cosine values (SO, CO, ST, CT, SP, CP) are pre-computed once at lines 40–50, making the per-vertex rotation only multiplications and additions. After rotation the 2D projected coordinates are immediately updated in W(4,2).

Playback Loop

The playback loop at lines 880–970 reads six edge records per frame using ADDR, skipping records where P(ADDR)=0 (invisible edges). After each six records, ADDR is advanced by an additional 24 to skip to the next frame’s block (line 930). When ADDR reaches 865, it wraps back to 1 (line 940). A PAUSE 2 at line 955 provides minimal inter-frame delay, followed by CLS and a branch back to the draw loop.

Notable Techniques

• POKE 23692,255 at line 730 resets the scroll prompt counter, preventing the “scroll?” prompt from appearing during the computation phase.
• The REM comment at line 3 discusses an optimization strategy involving two display files and an LDIR copy, indicating awareness of machine-level display manipulation.
• The wrap-around copy at line 750 (FOR I=1 TO 48: LET P(I+864)=P(I)) is an elegant technique to avoid a bounds check in the circular playback loop.
• BEEP 2,22 at line 760 provides an audible signal that pre-computation is complete before playback begins.

Bugs and Anomalies

• Line 610 contains a duplicate assignment: LET P(ADDR+2)=W(K,1): LET P(ADDR+2)=W(K,1). The second statement is redundant but harmless.
• Line 610 only executes when E(I,3)<>0, but line 620 (LET ADDR=ADDR+4) is outside the conditional and always advances the pointer, meaning invisible edge slots are still consumed in P. This is intentional by design — it keeps the frame record size fixed at 24 values.
• The N variable at line 400 is used as a counter for valid edges, but N is also used as a loop variable implicitly in the FOR I=1 TO 4 at line 210 for the faces. Because N is not a loop control variable there, there is no conflict, but the reuse alongside the array N(4,3) for normals could cause confusion.
• Line 930 advances ADDR by 24 after the 6-edge inner loop has already advanced it by 24 (6 × 4), giving a total advance of 48 per frame iteration — this is correct since each frame occupies exactly 24 slots (6 edges × 4 values), and the inner loop handles one frame’s 6 edges starting at the current ADDR. On closer inspection the inner loop at 880–920 iterates 6 times, each time advancing by 4, consuming 24 values, then line 930 adds another 24. This means the playback loop skips every other frame’s data block, effectively playing back at half the recorded frame count. This appears to be a bug.

Data Tables

Array	Dimensions	Purpose
V(4,3)	4 vertices × 3 coords	World-space vertex positions (updated each frame)
W(4,2)	4 vertices × 2 coords	Screen-space projected positions
T(4,4)	4 faces × 4 indices	Face-to-vertex index table
N(4,3)	4 faces × 3 components	Surface normal vectors
E(6,3)	6 edges × 3 fields	Edge table: vertex pair + visibility count
P(912)	912 scalars	Pre-computed frame data store