Share this project

Done

Share this project

Done
Learn Game Programming (codeschool.org)'s video poster
Play

Learn game programming from a video series for novice programmers and non-game programmers. Part of a larger series at codeschool.org. Read more

Ventura, CA Software
Share this project
702
backers
$7,005
pledged of $700 goal
0
seconds to go

Funded!

This project was successfully funded on November 25, 2012.

Learn game programming from a video series for novice programmers and non-game programmers. Part of a larger series at codeschool.org.

Ventura, CA Software
Share this project

New installments: "2D Algorithms (part 3)" and "Texture Mapping and Filtering"

1 like

Hope these are easy enough to follow. Making this material simple was like pulling teeth! The next few installments about lighting won't take too long (for real this time).

New installment: 3D Transformations

Just posted the (much longer) video on 3D Transformations, which is mostly about rotations. This material is considerably more confusing, so be sure to ask for clarifications about anything that doesn't make sense.

From here out, I'll simply make the videos public on Youtube as soon as I post them because I'm concerned some backers may have forgotten how find the new material. Besides, I'd like some more feedback, and not many backers are rushing to watch the new videos.

New installment: 2D Transformations

If you check your backer page link, you'll find a new installment on 2D Transformations (moving objects around in 2D space). This one's quite short but will be followed in a day or two by 3D Transformations, which covers the confusing business of rotations in 3D space. Both of these videos cover transformations using just simple algebra and trigonometry, but we'll later look at performing transformations using matrices, which is the preferred method in 3D rendering.

New installment: 3D projection

If you visit the backer page at codeschool.org, you'll find a new video on 3D projection, which is our entry point into 3d rendering and then OpenGL. The follow-ups will be a video on transformations (moving geometry around in 3D space), another on the essential matrix math we need, and then another revisiting projection and transformations, this time using matrices (as is common practice in 3D rendering). After that, we'll probably go into texture mapping and lighting. The general approach here is to explain 3D rendering as much as possible on its own terms before getting to OpenGL, which after all is just a particular API for implementing these basic techniques.

Apologies again for the radio silence. If the series has been slow in coming, it's been due to four roadblocks:

1) Pyglet, while admirable for its simple design, hasn't been reliable, and continuing progress on the project seems anemic. New AMD drivers broke Pyglet's functioning on my system on multiple occasions, and if I'm having difficulty just getting it to run, many backers probably are as well. So the executive decision is to switch from Pyglet and Python to HTML 5 and Javascript. The browsers (Firefox and Chrome, at least) are getting better-and-better game-related features very rapidly, including WebGL (the browser version of OpenGL) and gamepad support, so the future for HTML 5 games looks very bright. I do prefer Python to Javascript, but they really are very similar languages semantically. In case you don't know any Javascript or HTML, they're both quite easy to pick up, and the videos on codeschool.org tell you everything you need to know. At some point, I may go back and redo the earlier code examples in Javascript, but for now I'll just focus on moving forward.

2) Explaining 3D rendering is really tricky! It's especially hard to find an easy entry point, and after much consideration, I concluded that there's just no way around introducing some matrix math. I think I finally have the first pieces in place. If you want a sneak preview of this sort of material, the Udacity course at  https://www.udacity.com/course/cs291 is really good and covers a lot of the same basic concepts we will. However, its treatment of some of the thornier bits, like using matrices and how rotations work, feels a bit out of order and incomplete.

3) I've been thinking a lot of how to make my videos more watchable. The most obvious place to start is better audio quality and narration. I hope you notice in the new video that I'm finally using a proper microphone instead of a cheap headset and that I took a bit more care in the recording and editing. (A lot of my older programming videos desperately need re-recording, so that's something I'll be doing slowly over the next year.)

4) Lastly, when I started the project, I didn't have much work going, but a couple months later, some opportunities came up which I couldn't pass on. Things have slowed down again, so it's a good time to get this ball rolling again.

In any case, while the original promised completion dates have come and gone, I am committed to getting there eventually, and progress will be more regular. I'll make up for the delays by expanding past the original scope in one way or another.

--Brian

Installment 6: 2D Graphics Algorithms (part 2)

Apologies for the long, silent hiatus! Life, work, and burnout interceded. I'm clearly not going to make the original February completion deadline, but rest assured, I remain committed to making good on the project. 

You'll find links to the new video on your backer page at codeschool.org.

In the next few weeks, we'll cover some groundwork for 3D rendering, write an Asteroids clone, and perhaps look at some broad object-oriented design principles that concern game code. 

In the downtime, I've been reconsidering the later material. We may end up skipping 'old-style' OpenGL for modern OpenGL, and Pyglet has become increasingly frustrating to work with (among other things, updated AMD drivers seem to have broken Pyglet on my Windows install). So after the next few updates, there may be another (shorter) hiatus while I do some investigating.