Screens & 2D Graphics: Crash Course Computer Science #23

Main ideas, concepts, and lessons

• Early computers separated text and graphics hardware

  • Early systems often used distinct devices:
    • A teletype machine for text/persistent output.
    • A round display screen mainly for monitoring program state (e.g., register values), not for final results.
  • Reason: screens struggled to render crisp text, while paper typing produced higher contrast and resolution.
  • Because teletype printing was slow and paper-consuming, screens were better for fast, temporary updates.

• CRT display fundamentals (most influential early display technology)

  • Cathode Ray Tubes (CRTs) work by:
    • Firing electrons toward a phosphor-coated screen.
    • Where electrons impact, the phosphor glows briefly.
  • Since electrons are charged, their paths can be steered using electromagnetic fields (plates/coils) in left-right and up-down directions.

• Two CRT-based ways to draw graphics

  1. Vector Scanning
     • The electron beam directly traces lines/shapes.
     • Because the glow persists briefly, repeating the path quickly makes the image appear solid.
  2. Raster Scanning
     • The beam repeatedly scans line-by-line in a fixed pattern (e.g., top-left to bottom-right), looping continuously.
     • The beam is turned on only at selected points to create graphics.
     • With improvement, raster can produce crisp dots (pixels).

• Why early computers didn’t use pixels much (memory constraints)

  • Even a modest pixel grid was expensive in memory.
  • Example given:
    • 200×200 = 40,000 pixels
    • Even 1 bit per pixel (black/white) would require 40,000 bits—too much for systems like the PDP-1.
  • This forced alternatives to full pixel frame buffers.

• Character-generator approach (text-as-graphics)

  • Instead of storing pixels, early systems stored a small grid of character codes, typically:
    • 80×25 characters = 2000 characters
    • With 8 bits per character (e.g., ASCII), a full screen might use 16,000 bits—more manageable.
  • Required extra hardware:
    • A character generator (early “graphics card” concept)
      • Contains a ROM with a dot-matrix pattern for each character.
    • Workflow:
      • When the screen buffer contains the code for (e.g.) “K”, the character generator raster-scans the stored dot-matrix for that character into the correct position.
  • Resulting limitation:
    • These systems mainly allowed text drawing, plus limited “pseudo-graphics” using extended character sets and symbols (e.g., ASCII art, box-drawing characters).
  • Extensions:
    • Character-set expansions such as IBM’s CP437 (used in DOS).
    • Some systems allowed extra bits for text color and background color.

• Vector graphics to draw arbitrary shapes (no pixel grids)

  • Character generators couldn’t efficiently draw arbitrary shapes (circuits, plans, maps, etc.).
  • Solution used the vector mode on CRTs:
    • Define content purely as a sequence of line segments.
    • If text is needed, it must be “drawn” from lines too.
  • Vector instruction concept:
    • Stored in memory and executed by a vector graphics card.
    • Multiple commands in the screen buffer build complex line graphics.
  • Because vector data is in memory, programs can update it frequently → animation.
  • Example historical linkage:
    • Spacewar! (1962) used vector graphics on a PDP-1, influencing later games and even early commercial arcade video games (e.g., Computer Space).

• Interactive graphical computing: Sketchpad and the light pen

  • Sketchpad (1962) is presented as an early complete graphical application and CAD precursor.
  • Interaction device: light pen
    • A stylus with a light sensor.
    • Detects monitor refresh timing so the computer can estimate pen position on-screen.
  • Sketchpad capabilities mentioned:
    • Drawing lines and simple shapes.
    • Tools for precision:
      • Parallel lines
      • Equal lengths
      • Perfect 90-degree corners
      • Dynamic scaling of shapes
    • Productivity features:
      • Save designs, reuse via paste, build libraries of components.

• Bitmapped/pixel-based displays in the late 1960s

  • True pixel graphics (bitmapped displays) appear later:
    • Frame buffer memory holds pixel values.
    • Initially RAM, later VRAM on graphics cards for faster access.
  • Example intensity model:
    • On an 8-bit grayscale display, intensity ranges 0 (black) to 255 (white) (though some early displays used colors instead of white).
  • Basic drawing logic shown conceptually with loops:
    • Set a pixel at coordinates (x,y) to a chosen intensity/color.
    • Draw a line by iterating along the y-range for fixed x (example: x=30 from y=0 to y=35).
    • Draw a rectangle using:
      • x,y for a starting corner
      • width and height
      • two nested loops:
        • outer loop iterates over one dimension
        • inner loop iterates over the other
      • Fill pixels within the rectangle with an intensity (e.g., 127 for “grey”).
    • Encapsulate as a draw rectangle function, then reuse by calling it for other rectangles.

• Libraries and abstraction

  • Programmers typically don’t implement primitives manually each time.
  • They rely on graphics libraries providing routines for:
    • Lines, curves, shapes, text, etc.
  • This is described as a “new level of abstraction.”

• Cost and impact toward the GUI era

  • Even after pixel graphics became possible, they were expensive for decades.
  • By 1971, interactive graphical screens were rare:
    • ~70,000 teletype machines/terminals in the US
    • only ~1,000 computers with interactive graphical screens
  • The stage was set by projects like Sketchpad and Spacewar for:
    • more widespread displays
    • eventual emergence of graphical user interfaces (GUIs) (to be covered later).

---

Methodology / instruction-style content (detailed)

A) CRT vector drawing sequence (example “vector commands”)

1. Reset

   • Clears the screen
   • Moves the drawing point to origin (0,0)
   • Sets line brightness/intensity to 0

2. Move drawing point and set intensity

   • Move point to (50,50)
   • Set line intensity to 100% (turn drawing on)

3. Draw connected line segments

   • Move to (100,50)
   • Then to (60,75)
   • Then back to (50,50)

4. Turn drawing off

   • Set line intensity back to 0%

• Outcome
  • The connected segments form a triangle
• Efficiency claim
  • Stores/uses on the order of ~160 bits, avoiding large pixel matrices.

B) Bitmapped drawing routines (examples described with loops and coordinates)

1. Set a pixel

• Choose coordinates (x,y).
• Set the pixel value/intensity to a specified color (e.g., white).

2. Draw a line (vertical line example)

• Given start (30,0) and end (30,35):
  • Use a loop over y from 0 to 35
  • For each y, set pixel at (30,y) to the desired intensity (e.g., white).

3. Draw a filled rectangle (general approach)

• Provide:
  • Starting corner coordinates (x,y)
  • width
  • height
• Choose an intensity/color for the fill (example: grey = 127).
• Use two nested loops:
  • Outer loop: iterate across one dimension (e.g., x direction) for the rectangle width
  • Inner loop: iterate across the other dimension (e.g., y direction) for the rectangle height
  • For every (x+i, y+j) within the bounds, set pixel to the rectangle fill intensity.
• Encapsulate into a draw rectangle function.
• Reuse the function by calling it with different positions and colors.

---

Speakers / sources featured (named)

• Carrie Anne (host/presenter of Crash Course Computer Science)
• Ivan Sutherland (inventor of Sketchpad; awarded the Turing Award mentioned)
• Vectrex (early vector display system referenced as the source of the example vector command style)
• IBM (mentions CP437 character set; IBM’s extension)
• PDP-1 (machine referenced where early graphics/game work occurred)
• VGA/CRT/later hardware referenced generally (e.g., CRTs, LCDs, VRAM), but not as specific named external sources beyond technology names
• Historical works/products/events referenced:
  • Spacewar! (1962)
  • Asteroids (as later influence)
  • Computer Space (first commercial arcade video game mentioned)
  • Sketchpad (1962)