It's just a different abstraction. In both cases the driver still has to do a ton of work behind the scenes to turn the bindings into something the hardware can work with.

Okay. It still seems excessive, since I'm not binding the buffer to the "device", I'm binding it to a program that exists within the device context.

e.g.

#1 say you've got a prop in a level, and you need to set it's position once, and after that it doesnt move. It's nice for that prop to have it's own "shader instance", which contains shader code, but also contains this positional data. Each time you render the prop, you can just tell GL to use this program.

#2 say you've got a camera, and you need to set it's position every frame. The vertex shader of every object needs to know the camera position. It's nice that you can put this data in a buffer and bind it to a particular slot on the device. Then when rendering every object, they automatically know about the camera, without the object being modified.

The first design (the GL2.x design) is fairly easy to emulate in D3D if you want to. Make your own structure that contains shader program pointers and constant buffer pointers. Make a function that accepts this structure and then binds all the resources inside it.

The second design (the D3D design) is really hard to emulate in GL2.x -- if you've got some data that is shared between 1000 "shader instances", you have to repeatedly set that same data 1000 times, instead of setting it just once.

Because of this, I have to say I prefer the D3D API design, because it lets you quite efficiently write code that works like #1 or #2, whereas GL2.x is horribly inefficient when you try and use use-case #2 with it (data shared between many instances). N.B. with GL3.x, you also have the option of binding shader data in a D3D-like manner

With the GL2.x design you can use glVertexAttrib calls to sort-of-kind-of emulate the D3D design; it's not perfect owing to the more limited number of attrib slots and the fact that it's a VS-only solution, but it can be done.

With D3D10+ constant buffer bindings belong to the device (context), not the program, as Hodgman has pointed out. In theory that means that there are only two times you ever need to call *SetConstantBuffers: once during startup, and once again if your display mode changes and you need to chuck the current state/bindings. Of course, that assumes that you design your cbuffers so that the number of them you use is more limited, i.e. instead of a different cbuffer type for different object types, you design a common cbuffer type for all objects.

D3D10+ has absolutely no concept whatsoever of binding a buffer to a "program" (the concept of a "program object" as GL defines it doesn't even exist in any version of D3D). Constant buffers in D3D10+ work the same way as vertex and index buffers do in both D3D and OpenGL: set them once and they're available to all shaders, and changing the shader doesn't affect that.

This is honestly a design problem in your code rather than an API problem. It reads to me as though the lower-level API-specific stuff has been allowed to bubble-up and influence the design of your higher-level abstraction layer. Instead of an abstraction layer that models renderable objects, you've probably got one that resembles a wrapper around OpenGL, and now you're trying to shoehorn an API with some different thinking behind it into it. If that's the case, then you really should go back and fix that first, otherwise other API differences are just going to continue to bite you as you proceed.

Hi, in DirectX do you not need to bind constant buffer every frame. The best practise is to create 3 constant buffers types:

A)Updated only when needed (example if you need to pass screen size to shader)

B)Updated every frame (for passing camera and data that change one time for frame)

C)Update every models (for passing models data like materials or world matrix)

Ordering rendering in the right way and avoid switching constant buffer, texture, buffer and shader every times improve perfomance.