# OpenGL Misc D3D9 questions.

## Recommended Posts

Hi, My apologies, these aren't really progamming questions, although this still seemed the most relevant forum for this topic. I've been looking at DirectX and OpenGL and doing some comparing. I know one disadvantage (or an advantage depending on your POV) for OpenGL is that it is very much library based so there must be many checks for the hardware to see if you can use certain extensions to achieve a certain result. I assume that with DX being more structured that each version 9.0a/b/c brings in a new set of features and that GPU's are assigned a certain DirectX version that they are guaranteed to support. Is this correct, if so: 1) What is the reason for caps in pre-DX10? 2) What advantages does DirectX 10 bring as I thought that one of the big advantages was to unify GPU features? 3) Why the numerous cards if they all support the same features? Thanks, NB

##### Share on other sites
Before 10, what you have is a wide range of cards, each of which has lots of itty bitty features because the manufacturers were trying to outdo each other, or just because they managed to convince ARB or MS that it was worth allowing in the spec. So you ended up with a very large range of caps, most of which are utterly pointless.

What happens with versions of DX is that MS says "you absolutely must have these features to be called a DirectX 9 card" or whatever. It's an expression of feature set, not what DirectX versions can actually run on the machine. (Common mistake.) Cards were still allowed to go above and beyond, and so caps provided more information about that. (Plus since DirectX 9 could run on DX8 cards...you get the idea.)

With 10, MS decided to simplify this further, by making these stratifications much more specific. If you are a DX10 card you support exactly a certain feature set, and that's that. If you're a DX10.1 card that feature set expands by a very well defined set of features, no more no less.

As for all the different hardware -- why do we have ten different series of Athlons, Phenoms, Core 2s, Core i7s, etc? Same thing. They perform differently.

##### Share on other sites
Ah okay, I think I understand, pre DX10 cards must reach a certain DX version of features (irrelevant of performance of those features), but there can be more features available which are 'extras' and are used through the 'caps' method. But DX 10 states there is one feature set which must be met no more no less. Correct? Do the DX10 cards still allow for varying performance of DX10 features?

Thanks,
NB

##### Share on other sites
Quote:
 Original post by NewBreedBut DX 10 states there is one feature set which must be met no more no less. Correct?
Spot-on [smile]

Quote:
 Original post by NewBreedDo the DX10 cards still allow for varying performance of DX10 features?
Performance is not in the specification/requirements, so yes the performance is up for grabs by anyone who wants it.

Think of it another way.

In the D3D9 era you could scale on two axis - features and performance. You could have more/less of either, say be a lightning fast SM2 card or an average SM3 card (not necessarily implying that more features equals slower perf though!). With D3D10 onwards you can only scale on performance - a single axis as the feature axis is now locked and non-negotiable.

Combinatorial explosion was the big problem. For D3D9 you could have roughly 4 grades of features (fixed function, sm1, sm2, sm3) and 3 performance grades (low, mid, high). That means you can have 12 types of D3D9 card that can all be accessed via the same software - break down those lists in more detail and you can easily see how you get to 100's if not 1000's of combinations.

Now remove the feature axis and you might have "budget performance", "medium performance", "high performance" and "super mega ultra gamer performance" models. You're suddenly down from 100's or 1000's to ~5.

Go on a step to Direct3D 11 and you can scale your geometry according to performance if you want. The new tesselation units allow you to write the exact same algorithm but increase the detail for your "super mega ultra gamer performance" card but drop it right back down for the "budget performance".

hth
Jack

##### Share on other sites
Thanks both for your time, cleared up a number of issues there for me. :)

##### Share on other sites
Its also my understanding that D3D10 and onward are also more stringent on image quality issues, by integrating certain buffer formats, filtering levels, etc into the validation process, whereas the criteria for meeting API compliance in this regard prior to D3D10 was much less stringent, if not non-existent.

While you can say that these things boil down to features, and in many ways they do, I believe the difference is that, by the old measuring stick, hardware vendors were largely left to define what was an acceptable level of quality regarding a feature area, whereas now Microsoft takes a more-active role in defining what that acceptable level of quality is.

JollyJeffers is right that D3D10 is about reducing the dimensional differences to a single axis, but I think that there was a least one more axis than what he alluded to in the days prior to D3D10.

##### Share on other sites
Quote:
 Original post by RavyneIts also my understanding that D3D10 and onward are also more stringent on image quality issues
Absolutely - the spec has a lot to say on the topic of numerical and operator precision. 10.1 and 11 are largely the same but raise the barrier a little bit in a few places.

Quote:
 Original post by RavyneI think that there was a least one more axis than what he alluded to in the days prior to D3D10.
Yes, the quality axis would be a valid addition to what I mentioned. After all, what good would a 3D API be if it only had 2D axis'?? [grin]

Jack

## Create an account

Register a new account

• ### Forum Statistics

• Total Topics
627754
• Total Posts
2978944
• ### Similar Content

• Hello! As an exercise for delving into modern OpenGL, I'm creating a simple .obj renderer. I want to support things like varying degrees of specularity, geometry opacity, things like that, on a per-material basis. Different materials can also have different textures. Basic .obj necessities. I've done this in old school OpenGL, but modern OpenGL has its own thing going on, and I'd like to conform as closely to the standards as possible so as to keep the program running correctly, and I'm hoping to avoid picking up bad habits this early on.
Reading around on the OpenGL Wiki, one tip in particular really stands out to me on this page:
For something like a renderer for .obj files, this sort of thing seems almost ideal, but according to the wiki, it's a bad idea. Interesting to note!
So, here's what the plan is so far as far as loading goes:
Set up a type for materials so that materials can be created and destroyed. They will contain things like diffuse color, diffuse texture, geometry opacity, and so on, for each material in the .mtl file. Since .obj files are conveniently split up by material, I can load different groups of vertices/normals/UVs and triangles into different blocks of data for different models. When it comes to the rendering, I get a bit lost. I can either:
Between drawing triangle groups, call glUseProgram to use a different shader for that particular geometry (so a unique shader just for the material that is shared by this triangle group). or
Between drawing triangle groups, call glUniform a few times to adjust different parameters within the "master shader", such as specularity, diffuse color, and geometry opacity. In both cases, I still have to call glBindTexture between drawing triangle groups in order to bind the diffuse texture used by the material, so there doesn't seem to be a way around having the CPU do *something* during the rendering process instead of letting the GPU do everything all at once.
The second option here seems less cluttered, however. There are less shaders to keep up with while one "master shader" handles it all. I don't have to duplicate any code or compile multiple shaders. Arguably, I could always have the shader program for each material be embedded in the material itself, and be auto-generated upon loading the material from the .mtl file. But this still leads to constantly calling glUseProgram, much more than is probably necessary in order to properly render the .obj. There seem to be a number of differing opinions on if it's okay to use hundreds of shaders or if it's best to just use tens of shaders.
So, ultimately, what is the "right" way to do this? Does using a "master shader" (or a few variants of one) bog down the system compared to using hundreds of shader programs each dedicated to their own corresponding materials? Keeping in mind that the "master shaders" would have to track these additional uniforms and potentially have numerous branches of ifs, it may be possible that the ifs will lead to additional and unnecessary processing. But would that more expensive than constantly calling glUseProgram to switch shaders, or storing the shaders to begin with?
With all these angles to consider, it's difficult to come to a conclusion. Both possible methods work, and both seem rather convenient for their own reasons, but which is the most performant? Please help this beginner/dummy understand. Thank you!

• I want to make professional java 3d game with server program and database,packet handling for multiplayer and client-server communicating,maps rendering,models,and stuffs Which aspect of java can I learn and where can I learn java Lwjgl OpenGL rendering Like minecraft and world of tanks

• A friend of mine and I are making a 2D game engine as a learning experience and to hopefully build upon the experience in the long run.

-What I'm using:
C++;. Since im learning this language while in college and its one of the popular language to make games with why not.     Visual Studios; Im using a windows so yea.     SDL or GLFW; was thinking about SDL since i do some research on it where it is catching my interest but i hear SDL is a huge package compared to GLFW, so i may do GLFW to start with as learning since i may get overwhelmed with SDL.
-Questions
Knowing what we want in the engine what should our main focus be in terms of learning. File managements, with headers, functions ect. How can i properly manage files with out confusing myself and my friend when sharing code. Alternative to Visual studios: My friend has a mac and cant properly use Vis studios, is there another alternative to it?

• Both functions are available since 3.0, and I'm currently using glMapBuffer(), which works fine.
But, I was wondering if anyone has experienced advantage in using glMapBufferRange(), which allows to specify the range of the mapped buffer. Could this be only a safety measure or does it improve performance?
Note: I'm not asking about glBufferSubData()/glBufferData. Those two are irrelevant in this case.
• By xhcao
Before using void glBindImageTexture(    GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format), does need to make sure that texture is completeness.

• 11
• 10
• 10
• 23
• 14