Do I have to call VSSetConstantBuffers/PSSetConstantBuffers every frame after calling VSSetShader/PSSetShader? With OpenGL, you can call glBindBufferBase once to set up a binding point and then you don't have to call it again unless you want to bind a different buffer to the program. But it seems like that's not the case with DirectX...?
Set constant buffers every frame?
Moderators - Reputation: 47483
Posted 26 October 2013 - 11:38 PM
If different shaders require different buffers, then yes, you have to rebind them.
The GL idea where the shader program object can have values bound to it is a leftover from the days when shader variables didn't actually exist in the hardware, so setting new values required the driver to recompile the shader.
Members - Reputation: 1178
Posted 27 October 2013 - 06:28 PM
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. It shouldn't change just because I've bound a different program and different buffers to that program. The program still exists within the context, and as such any bindings to it should be maintained... but I can rebind them if that's the way DirectX works.
Moderators - Reputation: 47483
Posted 28 October 2013 - 02:06 AM
There's times where each abstraction is more useful.
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.
#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
Crossbones+ - Reputation: 11120
Posted 28 October 2013 - 07:56 AM
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.
Edited by mhagain, 28 October 2013 - 07:58 AM.
It appears that the gentleman thought C++ was extremely difficult and he was overjoyed that the machine was absorbing it; he understood that good C++ is difficult but the best C++ is well-nigh unintelligible.
Members - Reputation: 111
Posted 31 October 2013 - 04:24 AM
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.
If at first you don't succeed; call it version 1.0
visit my page at