
How to Start Learning Computer Graphics Programming - phodo
https://erkaman.github.io/posts/beginner_computer_graphics.html
======
flafla2
For anyone looking for a great starter codebase that you can poke around in to
learn the fundamentals of CG, check out Scotty3D [0], the base code for CMU's
computer graphics class 15-462/662 (I am a TA for this class). It is a
supplemental codebase to the lecture slides [1], which are all available
online. The idea is that Scotty3D is a full 3D modeling suite akin to Blender
or Maya, but all of the actual functionality is stripped out, waiting to be
implemented by students.

It includes code for 3D model loading, linear algebra, basic (OpenGL)
rendering, and UX, and provides stubs for you to implement:

    
    
        - local geometry operations (ex: edge split, 
          vertex/edge/face bevel, vertex/edge/face delete, etc)
        - global geometry operations (ex: upsampling via catmull 
          clark subdivision, downsampling using quadric error, etc)
        - a path tracer that supports Diffuse/Mirror/Glass 
          materials with Fresnel reflections and environment 
          lighting (ex: you can render the cornell box)
        - an animation suite that implements skinning, spline 
          interpolation, and basic simulation (wave sims)
    

There's a lot of documentation in the wiki [2] to help you get started. A
great resource, even if you can't take the class yourself!

[0] [https://github.com/cmu462/Scotty3D](https://github.com/cmu462/Scotty3D)

[1]
[http://15462.courses.cs.cmu.edu/fall2018/lectures](http://15462.courses.cs.cmu.edu/fall2018/lectures)

[2]
[https://github.com/cmu462/Scotty3D/wiki](https://github.com/cmu462/Scotty3D/wiki)

~~~
robko
Ah, the good old OpenGL fixed function pipeline, deprecated for over 11 years
now.

For something a bit more modern, I'd recommend [0], but one might argue that
old OpenGL is easier to learn since you don't have to setup your own shaders.

[0]
[https://learnopengl.com/Introduction](https://learnopengl.com/Introduction)

~~~
ryandrake
There's something charming and engaging about the "legacy" fixed function
pipeline that we've lost with our increasing focus on lower and lower level
APIs. The ability to have a 10 line hello-world program that draws a colored
triangle on the screen is magical, and encouraging to beginners, and that
experience can't be replaced by the massive boilerplate and "copy-paste-this-
stuff-dont-worry-about-what-it-does-yet" you need to do in order to do
graphics the more modern way.

With Apple working to eliminate all traces of OpenGL with Metal, and Microsoft
already having abandoned it close to two decades ago, I feel it's close to the
end of the road for fixed function OpenGL. It was a wonderful part of graphics
development history that, sadly, future beginners will likely not be able to
experience.

~~~
rectang
One more instance of how the interests of vendors and the interests of
developers are not aligned. Microsoft and Apple don't want you learning
portable skills -- they want to limit your future prospects to developing only
for their specific platform.

~~~
kkarakk
noob here - how come no one is making a cross platform API to abstract away
this stuff? whenever i read about opengl or vulkan or metal or whatever w/ the
tutorial going "learn this engine to bypass complexities of bare api usage",
it's my first thought

~~~
jcelerier
> noob here - how come no one is making a cross platform API to abstract away
> this stuff?

... but there are hundred of cross-platform APIs to abstract this stuff -
unity3d, unreal engine, qt3d, etc...

~~~
orbat
Unity or Unreal aren't 3D rendering APIs, they're game engines

------
nyxxie
I think the author of this guide doesn't remember the mindset that a beginner
is in when they first start learning graphics programming (or really any
subject).

Why is someone reading this tutorial in the first place? It's likely because
they have some end goal in mind, and are looking to get from 0 to that goal as
quickly as possible. For most readers, this is probably making a game.
Following the advice of this guide will give the reader a deep understanding
of how 3d graphics works, but it won't bring them much closer to making a game
than they were when they started.

Why am I bothering to point this out? Because countless guides like this exist
that confuse neophytes into believing that the subject they wish to learn is
difficult and requires learning countless prerequisites before they can get
started tangibly moving towards their goal. It's demotivating. A lot of the
knowledge in this guide is good to know but ultimately not immediately
relevant to someone seeking to achieve some higher level graphics goal. It
feels like the equivalent of trying to teach someone programming by starting
them at assembly.

I personally think that this guide should be directed towards someone who has
had experience noodling around with OpenGL or a game engine and wants to reach
the next level. In order for any of the lessons this guide wishes to teach to
be impactful, the reader needs the necessary context to understand why
learning them is relevant to 3d graphics and by extension the reader's end
goal. Starting off by making a ray tracer is a cool idea for example, but does
the author honestly believe that it's more useful than just learning OpenGL
first? It might be more "confusing", but they're going to have to learn OpenGL
(or some game engine) at some point whether they want to or not if their goal
is to make a game.

~~~
wrs
It depends on what you mean by “graphics programming”. If that means
“implement a game on top of a tall stack of abstractions” then sure, this
isn’t the answer you’re looking for, but I’d call that “game programming”.

If “graphics programming” is implementing the rendering engine for the game
(recall his final goal is “draw a triangle”), I believe his point is that it’s
easier to learn the required APIs for that if you understand the concepts
behind them first (rather than just leaping into meaningless copypasta), and
the best way to learn those concepts is to work with them directly.

------
aappleby
Start with WebGL, Shadertoy.com, and jsfiddle.net.

No other tooling needed until you've got the basics of vertex buffers and
shaders down.

(20 year graphics veteran here who's boostrapped some coworkers)

~~~
voltagex_
What about 2D graphics? Sprites? Old school stuff? I keep meaning to fire up
DOSBox-X and go through some old tutorials. I really just want to put pixels
on the screen and work my way up from there - everything else just seems to
get in the way.

~~~
mysterydip
Personally I'd recommend grabbing an old copy of qbasic with dosbox and going
to town on some old tutorials here
[http://www.petesqbsite.com/sections/tutorials/graphics.shtml](http://www.petesqbsite.com/sections/tutorials/graphics.shtml)

I know some would say it's a bad language, but back in the day it was
incredibly accessible and spawned a lot of shared code and tutorials. If you
focus on the techniques and algorithms, treat the language as pseudocode
rather than "the right way to do things", you can have a lot of fun and learn
quickly things you can translate to whatever your language of choice is.

~~~
rpeden
I think most of those will work on QB64, too. So you could end up end with
fast, native executable files on Windows, MacOS, and Linux. That doesn't
matter much for those tutorials, but QB64 might be ever so slightly quicker to
get up and running than DosBox + QBasic.

~~~
mysterydip
Great point! I had forgotten about QB64. Heck, I may give it a go myself. This
thread gave me an itch for software rendering again.

------
rjf72
It depends on your motivation but if you really want to learn about graphics
programming (as opposed to learning an API) then I think the best way to do so
is to remove any API from the picture. There is an absolutely phenomenal book
that does just this: Andre LaMothe's 'Tricks of the 3D Game Programming
Gurus'. It was published in 2003 but when you remove APIs from the picture
it's just as relevant today and will remain so for the foreseeable future.

The book starts with little more than plotting a pixel on the screen. By the
end you'll have a complete lit, shaded, 3D game engine that you've written
entirely from scratch. And in the process you will learn absolutely everything
that goes into it.

And one thing I'd add is that this might sound somewhat overwhelming but it's
really not. The book is extremely well written and clearly was a labor of
love. If you get some pleasure out of math and code, you'll have no technical
troubles working your way through the book and in the end will be rewarded
with an intimate, flexible understanding of graphics development that won't be
hamstrung by dependence on a specific API.

[1] - [https://www.amazon.com/Tricks-Programming-Gurus-Advanced-
Gra...](https://www.amazon.com/Tricks-Programming-Gurus-Advanced-Graphics-
Rasterization/dp/0672318350)

------
mlboss
I will highly recommend ray tracing in weekend
[http://www.realtimerendering.com/raytracing/Ray%20Tracing%20...](http://www.realtimerendering.com/raytracing/Ray%20Tracing%20in%20a%20Weekend.pdf)

~~~
camargo
+1 The author released all the "ray tracing in a weekend" pdfs last year
through a "pay what you want" model:
[https://twitter.com/Peter_shirley/status/984947257035243520](https://twitter.com/Peter_shirley/status/984947257035243520)

~~~
godelski
They're all in a google drive (hosted my Shirley). It was previously shared on
HN.

[https://drive.google.com/drive/folders/14yayBb9XiL16lmuhbYhh...](https://drive.google.com/drive/folders/14yayBb9XiL16lmuhbYhhvea8mKUUK77W)

------
buchanae
I've been learning (mostly 2D) graphics as my side project for a couple years
now. I spend a ton of time on this project. I still feel like a beginner. It
is one of the more complex topics I've ever delved into.

I've crawled through more topics than I can list here. Many of them were not
easy to learn, due to disorganized learning resources and materials.

Documentation and information is scattered, frequently outdated, sometimes
sparse, and just downright messy. OpenGL and its many quirks and legacy
versions muddy the waters too. I've considered trying to pull this into one
big guide, hopefully resulting in something like the Filament docs [1].

Side note: macOS (my dev env) is a terrible place to write OpenGL, I've
learned. Debugging tools are practically non-existent.

[1]
[https://google.github.io/filament/Filament.md.html](https://google.github.io/filament/Filament.md.html)

------
ChicagoBoy11
The most incredible educational experience of my life was this course I did at
Columbia University while in High School on game programming. At the end of
the course we made our own game with OpenGL, but for the first week or so we'd
have basically math classes in the morning on he physics of lighting, and then
in the afternoon we'd implement the things we did in C. It was where I was
introduced to lots of math concepts, including vector math that I would not
see in school for another year or so.

At any rate, at the end we built our own raytracer, and say a text file with
vertices that was given to us produce an image on the screen from 100% code
that we'd written ourselves. It was one of the most empowering, deep
intellectual experiences I've ever had.

~~~
usgroup
Out of interest, does learning linear algebra in this way give you a deeper
sense of linear algebra? Do you think you think you are able to formulate
other problems more effectively in terms of LA as a result?

~~~
ChicagoBoy11
Absolutely. Like, for the average school kid learning about vector
multiplication or dot products of things of this kind are so abstract and seem
kinda pointless. But the way he taught it, we had a problem in terms of making
things look real. And the math was motivated as a strategy to solving those
issues. Based on the real world problem, it was great to develop intuition for
the results.

------
cimi_
I enjoyed going through The Book of Shaders[1] by Patricio Gonzalez Vivo. It
comes with an interactive programming environment that's great if you're just
getting started.

It's free but please consider donating if you find it useful.

[1] [https://thebookofshaders.com/](https://thebookofshaders.com/)

------
PinkMilkshake
3Blue1Brown has a great series on Linear Algebra. His explanations are so
clear that by the 2nd or 3rd video you'll already understand how it applies to
computer graphics.

[https://youtu.be/fNk_zzaMoSs](https://youtu.be/fNk_zzaMoSs)

~~~
kevinskii
I agree. I've had quite a bit of exposure to linear algebra through other
textbooks and online courses, and the 3Blue1Brown series explains the
intuition better than just about anyone. In particular, the video on
determinants really crystallized the concept for me.

------
Entalpi
I picked up graphics maybe three years ago and have been mostly learnt all the
stuff I needed through different sites scattered all over the internet.

For ray tracing Peter Shirleys books are very good.

OpenGL stuff are usually found at docs.gl,
[https://learnopengl.com/About](https://learnopengl.com/About).

For Physically Based Rendering (PBR) material checkout the bool Real-time
Rendering and all the cool stuff has been coming out of Siggraph these past
years, [https://blog.selfshadow.com/publications/s2013-shading-
cours...](https://blog.selfshadow.com/publications/s2013-shading-course/).

If you can, go take an elementary linear algebra course or prepare to spend
time studying these. It is well worth it.

One thing I have found when hacking on my own engine (see here:
[https://github.com/Entalpi/MeineKraft](https://github.com/Entalpi/MeineKraft))
is that graphics APIs (especially OpenGL) can have a lot of hidden meanings or
even old names still being used, etc. Try to find out how the API evolved and
get the reasoning behind the design decisions. This way it makes more sense
and it gets a bit easier to learn.

GLHF

------
davidwparker
Shameless self-promotion:

On my YouTube channel, I have over 100 WebGL Tutorial videos, and over 50 3d
math related videos.

[https://www.youtube.com/user/iamdavidwparker](https://www.youtube.com/user/iamdavidwparker)

------
hyperpallium
The single most helpful thing I discovered for _learning_ android opengl es
graphics programming is that it _does_ have error messages, after all! [abbrev
code, use to lookup docs]

    
    
      int error;
        while((error=GLES20.glGetError())!=GLES20.GL_NO_ERROR) {
        msg += android.opengl.GLU.gluErrorString(error);
      }
    

Also, the offical android opengl es 2.0 tutorial is wrong in subtle ways
(after the non-subtle wrongnesses were corrected).

TIL "advice" can be countable:
[https://blog.oxforddictionaries.com/2014/05/30/advise-
advice...](https://blog.oxforddictionaries.com/2014/05/30/advise-advice/)

> _Advice_ is mainly used with the first meaning, and in this meaning it is a
> mass noun (that is, it has no plural). The business/legal meaning, however,
> is a count noun: it has a plural form, _advices_.

~~~
exDM69
When getting started with a new OpenGL project, the first thing you should do
is to enable the debug output [0] w/ glDebugMessageCallback. You also need to
enable the debug bit when creating a GL context.

This will give you human readable error messages (as in complete sentences of
what went wrong) as well as some other info to pinpoint what went wrong and
where.

Additionally, it's a good idea to use Renderdoc [1] or your $GPU_VENDOR's
debugging and profiling tools.

[0]
[https://www.khronos.org/opengl/wiki/Debug_Output](https://www.khronos.org/opengl/wiki/Debug_Output)
[1] [https://renderdoc.org/](https://renderdoc.org/)

~~~
hyperpallium
Good to know about! For openGL ES, it looks like it wasn't implemented until
version 3.2, the most recent (I don't have a device with that version).

[https://developer.android.com/reference/android/opengl/GLES3...](https://developer.android.com/reference/android/opengl/GLES32.html#glDebugMessageCallback\(android.opengl.GLES32.DebugProc\))

------
rhwk97
If anyone wants to play around with Computational Geometry and Python, I'd
recommend as a great starting point:
[http://blancosilva.github.io/post/2014/10/28/Computational-G...](http://blancosilva.github.io/post/2014/10/28/Computational-
Geometry-in-Python.html)

Also, Apress has a cool book about Python and graphics with some pretty
intense source code found here: [https://github.com/Apress/python-
graphics](https://github.com/Apress/python-graphics)

~~~
rhwk97
quick note on the first link...I think graphs are done using tikz:
[http://blancosilva.github.io/post/2010/12/12/using-tikz-
as-a...](http://blancosilva.github.io/post/2010/12/12/using-tikz-as-an-
igse.html)

------
billsix
Here is my work in progress for intro OpenGL programming

[http://billsix.github.io/modelviewprojection/](http://billsix.github.io/modelviewprojection/)

It in python, doesn’t involve matrices. It really only requires high school
math, with the exception of the z axis.

Hope it’s helpful!

------
packetslave
Jamis Buck has a new-ish book out called "The Ray Tracer Challenge" that I've
been slowly working through.

So far I really like the way it's written: everything is test-based, so you
get a problem like: "given matrix X and vector Y, X * Y should be vector Z"
and then you implement both the test and the code in whatever language you
like.

[https://pragprog.com/book/jbtracer/the-ray-tracer-
challenge](https://pragprog.com/book/jbtracer/the-ray-tracer-challenge)

------
mickduprez
There are so many comments here missing the point saying "why? just use "X"
API" or "this is a waste of time when you will need 'X' API anyway" etc. but
they miss the point. It's about 'how' graphics work, not building game
engines.

Computer graphics is more about producing an image on a computer screen and
whether it's for image processing or a game engine renderer it's the same
process and very useful to know whichever field you want to pursue.

------
wtracy
I would love to see a similar "jumping off point" for audio programming.
Anybody know of one?

~~~
drivers99
This is my own limited experience, so I hope an expert also answers. In the
Handmade Hero video series/project, he codes a game engine from scratch. I
didn't get very far into it, but I followed along coding it myself, using what
I learned watching him. He writes it in a way that all the platform-specific
code is in its own file, and he does it in DirectX, although other people have
ported it to other platforms. Early in the series, he gets it to where you can
create a sound buffer of samples and play it out to the speakers. So I played
around with simply adding sine waves to generate things such as dial tones,
busy signals, and DTMF dialing sounds. I would consider that "ground up" for
the Windows platform. It should be pretty simple from there to load audio
samples from files, adjust their volume, play them back faster/slower, and mix
them together. And/or generate more complicated sythensized music. There is a
book about building modular synthesizers, and I was thinking about using that
but doing it in software.

~~~
beetwenty
The best motivator for me was to start building a Standard MIDI Format
sequencer and test its output on MIDI files. The underlying MIDI standard is a
well-understood protocol with many resources, while SMF adds some room for
creative interpretation since it's meant to work across sample-based synths,
FM, etc. I started with a simple square-wave beeper, added polyphony and
volume envelopes, and built it up from there. By the end, the architecture I
had initially built was melting down, but it was playing Soundfonts to some
degree, and I could confidently claim to understand audio coding.

There's a lot of room to do things incorrectly and not notice in audio, which
makes it forgiving to learn: e.g. playing a sample at a different pitch can be
done badly by adding or removing arbitrary samples, but resampling it with
minimal distortion is actually a fairly intensive DSP problem. Or when
computing a volume, the linear amplitude usually isn't the parameter you want
to work with(see every UI where volume changes imperceptibly until you reach
the bottom 10% of the slider), and while there are computations to convert
between linear and dB values, you still have to qualify it with one of these
various references and suffixes[0]. There's a lot of crossover between audio
and electrical signal terminology that can make it hard to follow this
material.

So you can spend a lot of time doing simple things well!

[0]
[https://en.wikipedia.org/wiki/Decibel#Voltage](https://en.wikipedia.org/wiki/Decibel#Voltage)

~~~
drivers99
Very cool! Thank you! That gives me a lot more ideas.

------
Vektorweg
The best way to learn computer graphics programming is to first ask what you
want to do with it. Most people interested in this topic have some end goal,
be it just writing a game. In that case, writing raytracers and rasterizers
may just be a waste of time, when the main interest isn't the interworkings of
math, but to put something up the screen. For a reasonably wide range of
modern tools, its absolutely not necessary to know any deep math to bring to
screen what you want.

------
tokyodude
Start with [https://webglfundamentals.org](https://webglfundamentals.org) ?

------
divyahansg
Scratchapixel[1] is also a helpful resource for explaining the basic concepts.

[1] [http://www.scratchapixel.com/](http://www.scratchapixel.com/)

------
akdas
I'll plug the materials for the one-weekend class I taught on computer
graphics: [https://avik-das.github.io/build-your-own-raytracer/](https://avik-
das.github.io/build-your-own-raytracer/)

I didn't assume a particular mathematical background for the students, so I
introduced the relevant math in what I hope was a motivated way. Hopefully it
can help others as well.

------
kragen
My very first raytracer was [http://canonical.org/~kragen/sw/aspmisc/my-very-
first-raytra...](http://canonical.org/~kragen/sw/aspmisc/my-very-first-
raytracer.html) and was quite a bit easier than I expected. My second one was
a bit under 1K in Clojure:
[http://canonical.org/~kragen/sw/dev3/raytracer1k.clj](http://canonical.org/~kragen/sw/dev3/raytracer1k.clj)
or unobfuscated:
[http://canonical.org/~kragen/sw/dev3/circle.clj](http://canonical.org/~kragen/sw/dev3/circle.clj)

I was pleasantly surprised by how easy it was to compute the pixels, but
getting them on the screen was a huge hassle. So I wrote
[https://gitlab.com/kragen/bubbleos/tree/master/yeso](https://gitlab.com/kragen/bubbleos/tree/master/yeso)
to make it trivial. I haven't ported a raytracer to it yet; I'll do that soon!

------
mickduprez
Thanks for the extra links, I'm building a base software rendering engine in
Go just for this purpose. It still needs work to get to a good 'base' but it
can be used as is to start learning CG from your notes and links.
[https://github.com/MickDuprez/go-window](https://github.com/MickDuprez/go-
window) cheers.

------
antoineMoPa
I invite everyone to try all of these techniques and math tools in ShaderGif
[42]. Hopefully you'll learn and make nice gifs in the process. Learning new
math concepts is even better when you create art and share it after!

[42] [https://shadergif.com/](https://shadergif.com/)

------
thinkingkong
I've always been a fan of the NeHe GL tutorials. I learned programming
starting with these 'back in the day' and really enjoyed it. Its modernized
now but still maintained.

[http://nehe.gamedev.net/](http://nehe.gamedev.net/)

------
piterdevries
I don't think the hindrance when starting to learn graphics programming is the
math or the lack of ideas of what to build. The biggest problem is that the
most known APIs (DirectX, OpenGL and especially DirectX 12 and Vulkan) are so
badly designed and so poorly documented that it deters anyone trying to start
doing anything. All these API are like magic invocation you have to make the
calls in just the right order or it doesn't work at all. There is no real
specification of what goes underneath and it can't be because the actual
implementation is written by different vendors (Nvidia or AMD) which only
slightly abides to the specification.

------
Animats
This is the old-line "bottom up" approach.

It might be more appropriate today to work top down. Install Unreal Engine,
build a simple demo, and look at the code it generated and you can modify.

~~~
nosrednAhsoJ
Zero graphics experience, so I may be asking an idiotic question, but why
learn anything other than a framework like UE?

I'm a web guy, so all I know is frameworks (Angular, React, etc.).

~~~
ed312
You'll ultimately become a better dev (e.g. higher quality code, faster, and
more maintainable) as you learn more of the underlying stuff. For web dev
definitely learn how to do everything in "vanilla" js, html, and css at least
a few times.

------
yzh
fwiw, pbrt can be read online for free since earlier last year:
[http://www.pbr-book.org/](http://www.pbr-book.org/)

------
ChuckMcM
I think this article, and the comments here, are a splendid example of how
deep (and often confusing) 3D graphics can be.

One of the things I appreciated about the Glide3D API for the old VooDoo cards
back in the day was how basic it was relative to the work of getting the 3D
stuff on the screen.

There are several ways in which you can "learn" 3D graphics; You can get it by
theory, you can get it by API, and you can get it by modelling.

If you're someone who is a theory person you should start at the beginning and
learn linear algebra and vector arithmetic. You can learn about projections,
and camera "views" and project your 3D scene onto a 2D surface whether it is a
computer screen or a plotter page. Once you get there you can then do hidden
line, and then hidden surface removal. You can learn about the 'Z' plane and
the clipping frustrum which lets you not worry about things that won't appear
in your projection. With a relatively simple array of coordinates type data
structure you can project triangles or NURBs onto your surface and draw pretty
pictures. Then you can start learning about light and all the many ways it
interacts with materials. At the end of this journey you can take a 3D model
and render it in a photorealistic way, one frame at a time.

The second way to learn 3D programming is the API path. Here you don't really
learn too much of the math, although having that background will help you
understand what the functions are doing. You learn an API like Unity or
Vulkan. These APIs have taken a lot the basic 3D programming and done it for
you, you need to learn how to write shaders which decorate your surfaces in
ways that simulate light or water or fog Etc. Generally you construct a scene
with calls to set up the frame, and then call 'render' with the appropriate
screen resource referenced. Blam! instant 3D scene.

The third way you might come at this is modelling things, building models in
Maya or some other modelling tool that are built with skeletons, which is
simply a data structure that identifies how different parts of the model can
move in relation to other parts. You probably don't have to know anything
about 3D math, but you have to have a good eye for construction of the models
and the area in which those models are placed.

There are so many ways to go at this particular quest, each have their own
challenges and rewards.

------
chadcmulligan
If anyone would like to see ray tracer code, have a look at pov-ray
[http://povray.org](http://povray.org) Its a venerable old ray tracer but has
some of the best features around and the code is very readable (once you've
got the basics). It's a different way to do things than the vertex/shader
style rendering pipeline.

------
Lithy
For anybody looking for a minimal cross-plateforme _modern_ OpenGL hello world
with a lot of comments:
[https://github.com/eliemichel/AugenLight](https://github.com/eliemichel/AugenLight)

By _modern_ I mean as in OpenGL 4.5 Core Profile, using future-oriented APIs
(e.g. named buffers). Any feedback welcome!

------
resist_futility
I'm always on the lookout for tutorials that go deeper than just implementing
single one off things. Been meaning to go through Handmade Hero.

[https://www.youtube.com/user/handmadeheroarchive/videos](https://www.youtube.com/user/handmadeheroarchive/videos)

------
darelc
I'm currently enrolled in an online Computer Graphics course on edX that has
been an excellent introduction to the subject:
[https://www.edx.org/course/computer-
graphics](https://www.edx.org/course/computer-graphics)

------
lurquer
I've found SFML an easy way to get some stuff on the screen in 2D.

As far as true 3D graphics, I made a Minecraft clone using OpenGL... it was a
nice project as, surprisingly, you end up using all the basic techniques as
you tweak it, particularly when you try to get lighting and shadows working.

------
mnutt
I'd definitely second the ray tracer recommendation, starting from a 2D canvas
and building a ray tracer to render a shaded sphere was really an "ah-ha"
moment, as the math is quite approachable and you can get a cool result with
not much more than some trigonometry.

------
webmobdev
This sounds good for those who want to learn graphics programming for gaming
and / or for animation etc. But where should a beginner start from to learn
GUI programming without using existing frameworks or widget toolkits?

------
mesaframe
The article says "How to start" but it's more like "What to start with".
Anyway, I'll really like to have a reference for good computer graphics
lecture videos which I am failing to find

------
zappo2938
I found myself having to remember how to do matrix calculations. Before I
could count to 100 I was going back and back until I was reviewing basic math
on the Khan Academy. Embarrassing but that is where to start.

------
ramoz
Is it worth it to get into this area as an experienced dev?

------
tw1010
Does anyone know something similar but for data projects/science? Preferably
something with practical data, not just the math.

~~~
eshyong
I've heard good things about Andrew Ng's Coursera machine learning class, and
it's free:

[https://www.coursera.org/learn/machine-
learning](https://www.coursera.org/learn/machine-learning)

There is a free intro to data science class on Udacity as well:

[https://www.udacity.com/course/intro-to-data-science--
ud359](https://www.udacity.com/course/intro-to-data-science--ud359)

Lastly, there's always Kaggle, which has plenty of resources to learn from,
and competitions as well:

[https://www.kaggle.com/](https://www.kaggle.com/)

~~~
gamedna
I can vouch for Andrew Ng's class. Its really top notch.

------
nikki93
[https://open.gl](https://open.gl) is the best OpenGL tutorial IMO.

------
aqibgatoo
Well, i was waiting for some starting graphics programming guide.

------
cambaceres
Raytracing and Rasterization sounds so cool :D

------
erricravi
A smart idea, i like it

