Reddit mentions of Computer Graphics: Principles and Practice (3rd Edition)

Computer Graphics: Principles and Practice

Work your way through this book. Computer Graphics: Principles and Practice (3rd Edition) https://www.amazon.com/dp/0321399528/ref=cm_sw_r_cp_api_c.DrzbB4MJ0F0

If you haven't already read "Computer Graphics: Principles and Practice" I'd heartily recommend it.

(Edited to delete repetition in Amazon's title)

I've never seen a beginner's book on OpenGL that I really liked. I started with the classic NeHe tutorials, but I would never recommend them these days because they're based on the old, deprecated APIs, which aren't available in OpenGL ES, WebGL, or the strict versions of OpenGL 3.0+.

For modern OpenGL, my favourite set of tutorials for now is here: http://arcsynthesis.org/gltut/

But if you're extremely new to graphical programming, you'll probably want a solid introduction to the parts of linear algebra that are used in graphics programming. I got that from the 2nd edition of the classic text, Computer Graphics: Principles and Practice, though I think it's a fairly dry approach to the subject.

part of being a scientist is reviewing a wide range of references - you might be expecting a bit much from one online source. let me suggest this one and this one, and especially this one are going to have the general graphics pipeline explanation chapters that you're looking for. if $$$ is a problem (and it is for most of us with these texts), perhaps you can insist that your local library gets them?
you can also pick up some good ideas by visiting course pages for some of the more well-known university graphics programmes - some of them have slides online, otherwise check out their reading lists - these guys are the best in the world at teaching graphics. read what they read.

http://www.cs.cornell.edu/Courses/cs465/2007fa/
http://graphics.stanford.edu/courses/
http://www.cs.utah.edu/research/areas/graphics/
http://www.cis.upenn.edu/~badler/courses/cis560.html

but i suspect, your best bet for this sort of stuff is actually Eric Haines' online course, which has a free version. it uses webgl but the main concepts are exactly the same as desktop gl and it's really very good https://www.udacity.com/course/cs291

also, interesting side note - Myers-Briggs has been widely discredited. it's actually based on Jung's germanic mysticism, which comes from ancient European magic. earth/air/wind/fire, alchemy, the four humours, the four personality components etc. etc. not a drop of science in it, but employers insist on you doing it.

Real Time Rendering was recommended to me by a few professional graphics devs when I asked them the same question. This is NOT a light read, and it won't tell you how to use a specific API (DirectX, OpenGL), but it will give you the foundations to better understand an entire graphics pipeline and the various techniques used.

Other posters have mentioned starting with a software rasterizer. I'd highly suggest this as it helped me a lot when I had to do a very small one in college. There is a more recent version that is likely better(haven't looked yet), but this is the book we used and it can be picked up for dirt cheep!

This is the classic text on computer graphics. It's been at least 10 years since I touched it though, so I'm not sure how up to date the latest edition is.

> You seem to have a very negative bias against Carmack.

Not at all. I just think he's overrated as a programmer. He reminds me of Steve Jobs a bit, in that he made a name/fortune largely by popularizing the work of others. This isn't a bad thing, but in both cases they get too much credit from the Plebeians.

> What does that have to do with Commander Keen being the first game to do smooth bidirectional scrolling?

Carmack got most of his ideas from a column Abrash wrote for Dr. Dobb's Journal:

http://www.drdobbs.com/parallel/graphics-programming-black-book/184404919

And for the record, I love these conversations as I inevetably end up learning something. Like Commander Keen wasn't the first game to use that technique!

https://www.quora.com/How-such-smooth-scrolling-was-achieved-in-games-like-Super-Mario-and-Commander-Keen

The point is, lots of people around that time were doing similar tricks. Carmack just ended up with the most visibility.

> What Wing Commander did isn't comparable to what Catacomb 3D did. The texture mapping in Catacomb 3D was applied to world surfaces and was perspective correct whereas Wing Commander only had scaled bitmaps (which also Catacomb 3D had).

Ultima Underwold was way more influential than Catacomb 3D. And even it wasn't the first dungeon crawler with perpsecitve-correct 3D textures. The Bard's Tale has that title. Dungeon Master was another influential early effort:

https://en.wikipedia.org/wiki/Dungeon_Master_(video_game)

>First of all, we're talking about their use in games here. Carmack is a games programmer. Beyond that, i'd like a proof that "all existed in the Unix workstation market" for them, especially for the "all" part.

http://www.amazon.com/Computer-Graphics-Principles-Practice-Edition/dp/0321399528

AFAIK Carmack has no software patents (though he has expressed a firm opposition to them) and has not published any novel research in the field of computer graphics. I was going to mention "Carmack's Reverse" as a possible invention, however it turns out even that has prior art:

https://en.wikipedia.org/wiki/Shadow_volume

I mean, I'm a computer scientist and have worked in IT for 20+ years. I don't use any code, processes or inventions from Carmack (that I'm aware of). I haven't even played one of his games in over a decade.

>Of course they did. Most of the rendering techniques we take granted today were first done during the 70s and 90s. But i was talking about games. Notice how every quote of me you made being with a game.

That's my point exactly. Why does the fact that he is a game developer make him a better programmer than someone that worked on CAD/CAM/CGI software?

>Unreal had a bunch of stuff before id's engines, like what Tim Sweeney called "texture space coordinate" dithering to provide a kind of fake bilinear filtering on the software rasterizer. Also it probably was the first engine to use realtime procedural textures (often used for fire effects, smoke, water, energy fields and other things that at the time were too expensive to do with particles). And it had skeletal animation before id's engines too.

Yes and I think Tim Sweeney is a better programmer than Carmack. He is certainly better with C++, at least.

>I was talking about the first game to use a unified lighting system for everything in the world. Cry Engine uses different lighting methods for indoor and outdoor scenes and also uses lightmaps. The whole point of the unified lighting system was to avoid all these "special cases".

Doom 3 avoided these "special cases" by being set on Mars, so there was no need to render complex organic geometry. So that is not really a fair comparison.

>Indeed but my point wasn't about the engine using voxels, but why it used them (to "bake" geometry so that artists can create unique spaces without worrying about polycounts). However since this was a research that he didn't finish due to his move to Oculus it doesn't make much sense to compare it to other stuff out there - since there is nothing to compare.

This is not a new thing. The Voxel Space engine did exactly this in 1992:

https://en.wikipedia.org/wiki/Voxel_Space

The entire map was a single "megatexure" and every texel was properly ray-traced as well. It was also programmed entirely in assembly language, so I would say it's creator (Kyle Freeman) is a better programmer than Carmack.

>Of course there is still the possibility that Source 2 in the list is still based on Quake 1's codebase like Source 1 is.

Unlikely:

https://en.wikipedia.org/wiki/Source_(game_engine)#History

>I don't think he's overrated, he is popular both because of his accomplishments and the games he was involved with.

Being popular is a prerequisite of being overrated.

> It’s hard to consolidate databases theory without writing a good amount of code. CS 186 students add features to Spark, which is a reasonable project, but we suggest just writing a simple relational database management system from scratch. It will not be feature rich, of course, but even writing the most rudimentary version of every aspect of a typical RDBMS will be illuminating.
>
> Finally, data modeling is a neglected and poorly taught aspect of working with databases. Our suggested book on the topic is Data and Reality: A Timeless Perspective on Perceiving and Managing Information in Our Imprecise World.
>
>
>
>
>
> ### Languages and Compilers
>
> Most programmers learn languages, whereas most computer scientists learn about languages. This gives the computer scientist a distinct advantage over the programmer, even in the domain of programming! Their knowledge generalizes; they are able to understand the operation of a new language more deeply and quickly than those who have merely learnt specific languages.
>
> The canonical introductory text is Compilers: Principles, Techniques & Tools, commonly called “the Dragon Book”. Unfortunately, it’s not designed for self-study, but rather for instructors to pick out 1-2 semesters worth of topics for their courses. It’s almost essential then, that you cherrypick the topics, ideally with the help of a mentor.
>
> If you choose to use the Dragon Book for self-study, we recommend following a video lecture series for structure, then dipping into the Dragon Book as needed for more depth. Our recommended online course is Alex Aiken’s, available from Stanford’s MOOC platform Lagunita.
>
> As a potential alternative to the Dragon Book we suggest Language Implementation Patterns by Terence Parr. It is written more directly for the practicing software engineer who intends to work on small language projects like DSLs, which may make it more practical for your purposes. Of course, it sacrifices some valuable theory to do so.
>
> For project work, we suggest writing a compiler either for a simple teaching language like COOL, or for a subset of a language that interests you. Those who find such a project daunting could start with Make a Lisp, which steps you through the project.
>
>
>
> [Compilers: Principles, Techniques & Tools](https://teachyourselfcs.com//dragon.jpg) [Language Implementation Patterns](https://teachyourselfcs.com//parr.jpg)> Don’t be a boilerplate programmer. Instead, build tools for users and other programmers. Take historical note of textile and steel industries: do you want to build machines and tools, or do you want to operate those machines?
>
> — Ras Bodik at the start of his compilers course
>
>
>
>
>
> ### Distributed Systems
>
> As computers have increased in number, they have also spread. Whereas businesses would previously purchase larger and larger mainframes, it’s typical now for even very small applications to run across multiple machines. Distributed systems is the study of how to reason about the tradeoffs involved in doing so, an increasingly important skill.
>
> Our suggested textbook for self-study is Maarten van Steen and Andrew Tanenbaum’s Distributed Systems, 3rd Edition. It’s a great improvement over the previous edition, and is available for free online thanks to the generosity of its authors. Given that the distributed systems is a rapidly changing field, no textbook will serve as a trail guide, but Maarten van Steen’s is the best overview we’ve seen of well-established foundations.
>
> A good course for which some videos are online is MIT’s 6.824 (a graduate course), but unfortunately the audio quality in the recordings is poor, and it’s not clear if the recordings were authorized.
>
> No matter the choice of textbook or other secondary resources, study of distributed systems absolutely mandates reading papers. A good list is here, and we would highly encourage attending your local Papers We Love chapter.
>
>
>
> [Distributed Systems 3rd edition](https://teachyourselfcs.com//distsys.png)
>
>
>
> ## Frequently asked questions
>
> #### What about AI/graphics/pet-topic-X?
>
> We’ve tried to limit our list to computer science topics that we feel every practicing software engineer should know, irrespective of specialty or industry. With this foundation, you’ll be in a much better position to pick up textbooks or papers and learn the core concepts without much guidance. Here are our suggested starting points for a couple of common “electives”:
>
> - For artificial intelligence: do Berkeley’s intro to AI course by watching the videos and completing the excellent Pacman projects. As a textbook, use Russell and Norvig’s Artificial Intelligence: A Modern Approach.
> - For machine learning: do Andrew Ng’s Coursera course. Be patient, and make sure you understand the fundamentals before racing off to shiny new topics like deep learning.
> - For computer graphics: work through Berkeley’s CS 184 material, and use Computer Graphics: Principles and Practice as a textbook.
>
> #### How strict is the suggested sequencing?
>
> Realistically, all of these subjects have a significant amount of overlap, and refer to one another cyclically. Take for instance the relationship between discrete math and algorithms: learning math first would help you analyze and understand your algorithms in greater depth, but learning algorithms first would provide greater motivation and context for discrete math. Ideally, you’d revisit both of these topics many times throughout your career.
>
> As such, our suggested sequencing is mostly there to help you just get started… if you have a compelling reason to prefer a different sequence, then go for it. The most significant “pre-requisites” in our opinion are: computer architecture before operating systems or databases, and networking and operating systems before distributed systems.
>
> #### Who is the target audience for this guide?
>
> We have in mind that you are a self-taught software engineer, bootcamp grad or precocious high school student, or a college student looking to supplement your formal education with some self-study. The question of when to embark upon this journey is an entirely personal one, but most people tend to benefit from having some professional experience before diving too deep into CS theory. For instance, we notice that students love learning about database systems if they have already worked with databases professionally, or about computer networking if they’ve worked on a web project or two.
>
> #### How does this compare to Open Source Society or freeCodeCamp curricula?
>
> The OSS guide has too many subjects, suggests inferior resources for many of them, and provides no rationale or guidance around why or what aspects of particular courses are valuable. We strove to limit our list of courses to those which you really should know as a software engineer, irrespective of your specialty, and to help you understand why each course is included.
>
> freeCodeCamp is focused mostly on programming, not computer science. For why you might want to learn computer science, see above.
>
> #### What about language X?
>
> Learning a particular programming language is on a totally different plane to learning about an area of computer science — learning a language is much easier and much less valuable. If you already know a couple of languages, we strongly suggest simply following our guide and fitting language acquisition in the gaps, or leaving it for afterwards. If you’ve learned programming well (such as through Structure and Interpretation of Computer Programs), and especially if you have learned compilers, it should take you little more than a weekend to learn the essentials of a new language.
>
> #### What about trendy technology X?
>

> (continues in next comment)