Screens & 2D Graphics: Crash Course Computer Science #23 Video Lecture | Introduction to Computer Science: An Overview - Software Development

Hi, I’m Carrie Anne, and welcome to CrashCourse
Computer Science!
This 1960 PDP-1 is a great example of early
computing with graphics.
You can see a cabinet-sized computer on the
left, an electromechanical teletype machine
in the middle, and a round screen on the right.
Note how they’re separated.
That’s because text-based tasks and graphical
tasks were often distinct back then.
In fact, these early computer screens had
a very hard time rendering crisp text, whereas
typed paper offered much higher contrast and
resolution.
The most typical use for early computer screens
was to keep track of a program's operation,
like values in registers.
It didn’t make sense to have a teletype
machine print this on paper over and over
and over again -- that’d waste a lot of
paper, and it was slow.
On the other hand, screens were dynamic and
quick to update -- perfect for temporary values.
Computer screens were rarely considered for
program output, though.
Instead, any results from a computation were
typically written to paper or some other more
permanent medium.
But, screens were so darn useful that by the
early 1960s, people started to use them for
awesome things.
INTRO
A lot of different display technologies have
been created over the decades, but the most
influential, and also the earliest, were Cathode
Ray Tubes, or CRTs.
These work by shooting electrons out of an
emitter at a phosphor-coated screen.
When electrons hit the coating, it glows for
a fraction of a second.
Because electrons are charged particles, their
paths can be manipulated with electromagnetic
fields.
Plates or coils are used inside to steer electrons
to a desired position, both left-right and
up-down.
With this control, there are two ways you
can draw graphics.
The first option is to direct the electron
beam to trace out shapes.
This is called Vector Scanning.
Because the glow persists for a little bit,
if you repeat the path quickly enough, you
create a solid image.
The other option is to repeatedly follow a
fixed path, scanning line by line, from top
left to bottom right, and looping over and
over again.
You only turn on the electron beam at certain
points to create graphics.
This is called Raster Scanning.
With this approach, you can display shapes...
and even text... all made of little line segments.
Eventually, as display technologies improved,
it was possible to render crisp dots onto
the screen, aka pixels.
The Liquid Crystal Displays, or LCDs, that
we use today are quite a different technology.
But, they use raster scanning too, updating
the brightness of little tiny red, green and
blue pixels many times a second.
Interestingly, most early computers didn’t
use pixels -- not because they couldn’t
physically, but because it consumed way too
much memory for computers of the time.
A 200 by 200 pixel image contains 40,000 pixels.
Even if you use just one bit of data for each
pixel, that’s black OR white -- not grayscale!
-- the image would consume 40,000 bits of
memory.
That would have gobbled up more than half
of a PDP-1’s entire RAM.
So, computer scientists and engineers had
to come up with clever tricks to render graphics
until memory sizes caught up to our pixelicious
ambitions.
Instead of storing tens of thousands of pixels,
early computers stored a much smaller grid
of letters, most typically 80 by 25 characters.
That’s 2000 characters in total.
And if each is encoded in 8 bits, using something
like ASCII, it would consume 16,000 bits of
memory for an entire screen full of text,
which is way more reasonable.
To pull this off, computers needed an extra
piece of hardware that could read characters
out of RAM, and convert them into raster graphics
to be drawn onto the screen.
This was called a character generator, and
they were basically the first graphics cards.
Inside, they had a little piece of Read Only
Memory, a ROM, that stored graphics for each
character, called a dot matrix pattern.
If the graphics card saw the 8-bit code for
the letter “K”, then it would raster scan
the 2D pattern for the letter K onto the screen,
in the appropriate position.
To do this, the character generator had special
access to a portion of a computer's memory
reserved for graphics, a region called the
screen buffer.
Computer programs wishing to render text to
the screen simply manipulated the values stored
in this region, just as they could with any
other data in RAM.
This scheme required much less memory, but
it also meant the only thing you could draw
was text.
Even still, people got pretty inventive with
ASCII art!
People also tried to make rudimentary, pseudo-graphical
interfaces out of this basic set of characters,
using things like underscores and plus signs
to create boxes, lines and other primitive
shapes.
But, the character set was really too small
to do anything terribly sophisticated.
So, various extensions to ASCII were made
that added new semigraphical characters, like
IBM’s CP437 character set, seen here, which
was used in DOS.
On some systems, the text color and background
color could be defined with a few extra bits.
That allowed glorious interfaces like this
DOS example, which is built entirely out the
character set you just saw.
Character generators were a clever way to
save memory.
But, they didn’t provide any way to draw
arbitrary shapes.
And that’s important if you want to draw
content like electrical circuits, architectural
plans, maps, and... well… pretty much everything
that isn’t text!
To do this, without resorting to memory-gobbling
pixels, computer scientists used the vector
mode available on CRTs.
The idea is pretty straightforward: all content
to be drawn on screen is defined by a series
of lines.
There’s no text.
If you need to draw text, you have to draw
it out of lines.
Don’t read between the lines here.
There is only lines!
Got it?
Alright, no more word play.
I’m drawing the line here.
Let’s pretend this video is a cartesian
plane, 200 units wide and 100 tall, with the
origin – that’s the zero-zero point – in
the upper left corner.
We can draw a shape with the following vector
commands, which we’ve borrowed from the
Vectrex, an early vector display system.
First, we reset, which clears the screen,
moves the drawing point of the electron gun
to zero-zero, and sets the brightness of lines
to zero.
Then we move the drawing point down to 50
50, and set the line intensity to 100%.
With the intensity up, now we move to 100,
50, then 60, 75 and then back to 50,50.
The last thing to do is set our line intensity
back to 0%.
Cool!
We’ve got a triangle!
This sequence of commands would consume on
the order of 160 bits, which is way more efficient
than keeping a huge matrix of pixel values!
Just like how characters were stored in memory
and turned into graphics by a character generator,
these vector instructions were also stored
in memory, and rendered to a screen using
a vector graphics card.
Hundreds of commands could be packed together,
sequentially, in the screen buffer, and used
to build up complex graphics.
All made of lines!
Because all these vectors are stored in memory,
computer programs can update the values freely,
allowing for graphics that change over time
-- Animation!
One of the very earliest video games, Spacewar!,
was built on a PDP-1 in 1962 using vector
graphics.
It’s credited with inspiring many later
games, like Asteroids, and even the first
commercial arcade video game: Computer Space.
1962 was also a huge milestone because of
Sketchpad, an interactive graphical interface
that offered Computer-Aided Design -- called
CAD Software today.
It’s widely considered the earliest example
of a complete graphical application.
And its inventor, Ivan Sutherland, later won
the Turing Award for this breakthrough.
To interact with graphics, Sketchpad used
a recently invented input device called a
light pen, which was a stylus tethered to
a computer with a wire.
By using a light sensor in the tip, the pen
detected the refresh of the computer monitor.
Using the timing of the refresh, the computer
could actually figure out the pen’s position
on the screen!
With this light pen, and various buttons on
a gigantic computer, users could draw lines
and other simple shapes.
Sketchpad could do things like make lines
perfectly parallel, the same length, straighten
corners into perfect 90 degree intersections,
and even scale shapes up and down dynamically.
These things that were laborious on paper,
a computer now did with a press of a button!
Users were also able to save complex designs
they created, and then paste them into later
designs, and even share with other people.
You could have whole libraries of shapes,
like electronic components and pieces of furniture
that you could just plop in and manipulate
in your creations.
This might all sound pretty routine from today’s
perspective.
But in 1962, when computers were still cabinet-sized
behemoths chugging through punch cards, Sketchpad
and light pens were equal parts eye opening
and brain melting.
They represented a key turning point in how
computers could be used.
They were no longer just number crunching
math machines that hummed along behind closed
doors.
Now, they were potential assistants, interactively
augmenting human tasks.
The earliest computers and displays with true
pixel graphics emerged in the late 1960s.
Bits in memory directly “mapped” to pixels
on the screen, what are called bitmapped displays.
With full pixel control, totally arbitrary
graphics were possible.
You can think of a screen’s graphics as
a huge matrix of pixel values . As before,
computers reserve a special region of memory
for pixel data, called the frame buffer.
In the early days, the computer’s RAM was
used, but later systems used special high
speed Video RAM, or VRAM, which was located
on the graphics card itself for high speed
access.
This is how it’s done today.
On an 8-bit grayscale screen, we can set values
from 0 intensity, which is black, to 255 intensity,
which is white.
Well actually, it might be green... or orange,
as many early displays couldn’t do white.
Let’s pretend this video is a really low
resolution bitmapped screen, with a resolution
of 60 by 35 pixels.
If we wanted to set the pixel at 10 10 to
be white, we could do it with a piece of code
like this.
If we wanted to draw a line, let’s say from
30, 0 to 30, 35, we can use a loop, like so….
….And this changes a whole line of pixels
to white.
If we want to draw something more complicated,
let’s say a rectangle, we need to know four
values.
The X and Y coordinate of its starting corner,
and its width and height.
So far, we’ve drawn everything in white,
so let’s specify this rectangle to be grey.
Grey is halfway between 0 and 255, so that’s
a color value of 127.
Then, with two loops – one nested in the
other, so that the inner loop runs once for
every iteration of the outer loop – we can
draw a rectangle.
When the computer executes our code as part
of its draw routine, it colors in all the
pixels we specified.
Let’s wrap this up into a “draw rectangle
function”, like this:
Now, to draw a second rectangle on the other
side of the screen, maybe in black this time,
we can just call our rectangle drawing function.
Voila!!
Just like the other graphics schemes we’ve
discussed, programs can manipulate pixel data
in the framebuffer, creating interactive graphics.
Pong time!
Of course, programmers aren’t wasting time
writing drawing functions from scratch.
They use graphics libraries with ready-to-go
functions for drawing lines, curves, shapes,
text, and other cool stuff.
Just a new level of abstraction!
The flexibility of bitmapped graphics opened
up a whole new world of possibilities for
interactive computing, but it remained expensive
for decades.
As I mentioned last episode, by as late as
1971, it was estimated there were around 70,000
electro-mechanical teletype machines and 70,000
terminals in use, in the United States.
Amazingly, there were only around 1,000 computers
in the US that had interactive graphical screens.
That’s not a lot!
But the stage was set – helped along by
pioneering efforts like Sketchpad and Spacewars
– for computer displays to become ubiquitous,
and with them, the dawn of graphical user
interfaces, which we’ll cover in a few episodes!
I’ll see you next week.