Jump to content

  • Log In with Google      Sign In   
  • Create Account

Banner advertising on our site currently available from just $5!


1. Learn about the promo. 2. Sign up for GDNet+. 3. Set up your advert!


Set constant buffers every frame?


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
6 replies to this topic

#1 Funkymunky   Members   -  Reputation: 785

Like
0Likes
Like

Posted 26 October 2013 - 10:32 PM

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...?



Sponsor:

#2 Hodgman   Moderators   -  Reputation: 37945

Like
3Likes
Like

Posted 26 October 2013 - 11:38 PM

You're binding the buffer to the device, not binding it to the shader.
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.

#3 Funkymunky   Members   -  Reputation: 785

Like
0Likes
Like

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.



#4 MJP   Moderators   -  Reputation: 13412

Like
0Likes
Like

Posted 27 October 2013 - 06:46 PM

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.



#5 Hodgman   Moderators   -  Reputation: 37945

Like
0Likes
Like

Posted 28 October 2013 - 02:06 AM


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.
There's times where each abstraction is more useful.

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 happy.png



#6 mhagain   Crossbones+   -  Reputation: 9342

Like
0Likes
Like

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.


#7 RobyX   Members   -  Reputation: 111

Like
1Likes
Like

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.


Roberto

 

If at first you don't succeed; call it version 1.0

 

visit my page at

https://www.facebook.com/pages/Not-Just-App/626958400688928





Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS