Hello

Is it somehow possible to call the hardware-supported features of the respective DirectX version, such as volumetric light and fog in DX10, directly from a vertex or pixel shader using pure HLSL code? Or is the only way to do this with the "D3D..." API functions being called from the main program?

Thanks.

Thanks for the correction, but that was not very helpful. As you know very well every DirectX version brings a set of new or improved high-level methods to address low-level methods and GPU hardware features. Some hardware features that could not be addressed directly from a high-level API in a specific DirectX version thus needed to be done purely software-wise, can be addressed fairly simple in a subsequent DirectX version from the main app (as long as the GPU also supports that feature hardware-wise).

So forget about volumetric light and fog, please just tell me if it's possible to address what you call "simpler features" purely from within HLSL shader code, in order to "build advanced features", or if those features are only accessible by the D3D... or whatever API functions.

Ok, but does that mean that a specific HLSL version / target / shader model provides access to exact the same feature set as the respective higher-level program API? For example, do I have access to the same GPU features from HLSL code compiled against Shader Model 5 / ps_5_0 as I would have when programming XNA / C++ / C# code against the DirectX11 high level API? Or are there any differences between what "simple features" are accessible from within HLSL or XNA functions on the same target?

(always under the condition that the underlying GPU supports the features in question)

HLSL is just used to program GPU's, so they know how to fill a texture, etc.

1-You can't do anything using only HLSL!
2-You write a GPU program called shader in HLSL.
3-You set the correct render target, and textures needed by the shader using DirectX API and C++/C#.
4-You tell the GPU which shader to run using DirectX API and C++/C#.
5-You tell the GPU to execute the shader using DirectX API and C++/C#.

To create more advanced effects you do this multiple times.

Example (shadow mapping) (this is an extreme simplification):

(Application-side code = C++/C# + DirectX API - Executed in the GPU)
(GPU-side code =HLSL shader programs)

Application side:
-Bind the shadow map as the render target.
-Tell the GPU to use the shadow mapping HLSL shader.
-Make the draw calls of the scene geometry.

GPU side:
-The shadow mapping shader calculates the distance from the camera to the geometry vertices and stores it in the render target bound in the application side.

Application side:
-Bind the Back buffer as the render target (back buffer is the texture shown on your screen).
-Bind the shadow map as a shader resource (texture).
-Tell the GPU to use the final HLSL shader.
-Make the draw calls of the scene geometry.

GPU side:
-The shader calculates the color of the screen pixel using the shadow map bound in the application side and the geometry diffuse maps, etc.

ANYWAY: Without C++/C# + DirectX API you can't bind render targets, textures, tell the GPU what to do and when to do it, so HLSL shaders are useless.

Ok, thanks everybody for the explanations. I think I got the idea now