It is completely absurd to have to create an overlay layer just to do clipping to an arbitrary path. What’s the big deal, you ask? Consider the following scenario:

I have a partially transparent image that I want to render (clipped) to my drawing context and overwrite the existing contents (i.e. use copy blending mode). It’s impossible to do this with a layer because, when the layer is composed back into the main context, the transparent bits are ignored. That took me about half of the 50 hours to figure out. Why should I need to reverse engineer details like this just to do something very standard in 2D rendering (clipping)?

I could go on about having find the secret knowledge where you can use QueryInterface() to convert an ID2D1RenderTarget to an ID2D1DeviceContext (to get access to D2D 1.1 blending modes). Or the fact that there are no less than 74 interfaces in the current version Direct2D! But I’ll leave it at the following statement:

I’ve done 2D graphics programming in GDI/GDI+, Quartz2D, Cocoa, Qt, and Cairo and I have never experienced such a convoluted 2D API in my life.

Season 1
Episode 50
Original air date: January 26th, 2009
A Camaro that Doesn’t Explode

It doesn’t even matter ( for me at least ) that they are made by MS, or that D2D is build on top of D3D, or that this new D2D still uses COM technology. What matters is the CONCEPT itself. The idea that 2D is simpler than 3D in real world geometry, and this concept must be fully respected when we speak about some APIs.

I’m a programmer, but at least for now, I’m only doing graphical applications or small games as a hobby. However, I find OpenGL superior to this DirectX technologies. And when I say superior, I’m saying that it is *at least* more intuitive and more clean. I’m not God so please don’t take this as an assertion, it’s only an affirmation, my affirmation, build on own opinions /tastes.

cheers for everyone!
— Mihail

That and it really does begin to look like that all the smart people have left Microsoft as well, and all that are left are people who can’t leave to go find another job somewhere else.

I shudder to think about some poor kid who wants to write some code to draw to the screen nowadays. Back when I was a kid, it was all open, you wanted to scribble on the screen, go at it. Now, you have to know and understand what COM is, and about 2 or 3 other infrastructure overhead systems before you can even begin to think about drawing. And COM isn’t exactly fun to learn either, and that’s speaking as an adult. As a kid, no f—ing way!

At some point, we’re gonna lose all the kids to something else, you know. They’re going to say f— it and go do something else.

Your comment above seems a bit backwards
“I will ask you, though, if you are using a Microsoft higher-level API like D3DX, how do you know when D3DX is holding references to objects and when it is not? They sure as hell don’t document it. Not knowing that, but also knowing that sometimes the lower-level graphics API is going to require you to make the reference counts to go 0 at arbitrary times, what are you going to do? How are you going to make it work? And is any of this garbage necessary in the first place?”

This is exactly the problem that reference counting tries to solve. Let me ask you this, would you rather not ref-count and not know if you can delete the object without leaving a dangling pointer?

Also, can you give an example of an MS api that “require[s] you to make the reference counts to go 0 at arbitrary times”. I mean, if you’re holding an object that _requires_ a pointer to another object, then the ref-count of said object better not go to zero out from under it. seems like memory management 101.

The Express edition is for non commercial use and only works for .NET development unless the Platform SDK is also installed.

Best usage scenario for me is to use Microsoft headers and libraries and install the Intel C++ compiler.

I do think that Casey’s comment compares two different situations, as you say, but maybe they connect up in his mind in a way he didn’t verbalize. Not sure!

Some preliminaries: I came “late” to every Visual Studio release after 6. I ran VS6 concurrently with other releases as late as early 2007. I skipped VS.NET (2002) entirely. I only installed Visual Studio 2008 for actual development use *in 2008*, some time shortly before SP 1 was released; I now use VS2008 daily. I generally wish Microsoft would slow down on releasing new Visual Studio versions; I don’t expect to be switching to VS2010 until sometime in 2011 or 2012, depending on a lot of variables. I switched from VS2005 to VS2008 primarily for the ability to target different .NET versions from the IDE, better multithreaded debugging, and for some OpenMP and C/C++ standards and strictness improvements. I do not do game development for a living.

I can understand that for game development needs, especially C/C++ based game development (which to say the majority of it, still, today), most of Visual Studio is overkill. I can understand why you and Jeff and Casey don’t care about integrated UML designers or extensive Team Foundation Server specific functionality, or .NET features, etc. What you seem to be arguing for is a toolchain from Microsoft geared specifically for professional game development (i.e. not what XNA is today) as a separate product from Visual Studio.

It’s clear, I hope, that Visual Studio is a huge, sprawling product (really, product line) that caters to the largest possible set of all its buyers as possible, which is no longer solely C/C++ developers on Windows writing desktop client applications, but also client-server developers, ASP.NET developers, .NET application developers, large distributed teams working on complex business software stacks, etc. etc. We could argue about the relative utility and overwroughtness of all of that, and the requirements each of those development communities (and more) ask of the product, and what Microsoft decides to add in. There’s ample arguments to be made, but the point I’m getting at is that’s what Visual Studio is targeted to a much broader audience, most of whom have concerns far more abstract and less about writing code, perhaps, (certainly, at least, less about writing high-performance C/C++ code) than professional game developers do.

PerfHUD is intersting, and makes total sense given NVIDIA as a company wanting developers to make the most use of their hardware to enhance their product offering to consumers (who are primarily gamers), but for PC development, games alone must not equate in providing value to Windows consumers, compared to the other priorities shown in what Visual Studio exposes in its feature set. On the other hand, all is not doom and gloom. There’s thinks like PIX, which I’m sure you’re more familiar with than I am, and the real and important work people like Andy Ayers and the Phoenix group (http://connect.microsoft.com/Phoenix) are doing to make an all new compiler infrastructure (see a [large] video at http://channel9.msdn.com/Showpost.aspx?postid=396461).

XNA shows at least a willingness on the part of Microsoft to make a focused game development product, even if you and Casey and Jeff aren’t the market for it either. I think it might be possible to get what you want from Microsoft given the right combination of the right people, luck, timing, and enough strong demand from professional game developers seriously interested in continuing to develop for the PC, in addition to consoles like Xbox 360. The fact that what you want is, by comparison to Visual Studio, such less work to make, should be an easier sell. I don’t have any sure-fire ways to go about making that a reality, but I think the less you rail against Visual Studio and the more you carve out yoru own set of requirements and find external support and an internal champion or two, the more likely it is to happen.

Thanks for this post. There’s lots of points here, and lots of follow-up commentary I want to get to in detail as well, but I wanted to just lead off with this question (and maybe this is for Casey too).

With regards to the comment Casey makes early in the podcast: “Every single time they’ve updated their development environment (and their operating system), they’ve made it less likely that you will be able to distribute a program. That is not exaggeration. […] We are at the point where there is no question that if you installed Ubuntu, you can get a program working on it faster than you can get it working on a Windows PC, *without question*, like, I mean, there’s no question at all.”

I don’t mean to cherry-pick here, and I realize the Jeff and Casey show is meant mostly as comedy and satire, but given your experience with looking at porting Braid to Linux, do you think this is true? My sense is that the game development on Windows and PCs in general has many pitfalls, especially around OS and hardware compatibility/support, but I still think the Linux landscape is more cumbersome overall compared to Windows in this regard.

I don’t think Casey is comparing apples to apples in his comment above. His Windows comment concerns a developer writing an app and being able to distribute it and have it run on other versions of Windows; the Ubuntu comment only mentions how easy it is to run a program installed with it out of the box, but I assume he meant to include the case where a developer writing an app on a certain version of Ubuntu and the ease of distributing that and having it run on another version of Ubuntu. Again, not a big deal for the purposes of this question.

Thanks in advance. I want to dive in more on this thread, and will catch up on the commentary so far.