Hello again

I've got a scenario where I need a simple grayscale image to be represented as an array or similar construct within my HLSL pixel shader code. Each pixel of the image should be mapped to a value within the code construct in question.

In the particular case I don't have the means to pass the image as texture to the shader and sample it from there, nor could I load it from anywhere. It needs to be present as a (const / static) variable or #define construct as part of the source code. I neither have access to the DirectX / D3D API functions so everything needs to be pure HLSL.

There are tools that help converting the image into HLSL code but I'm not sure about the best storage construct.

Would it be recommendable to use e.g. an array of unsigned integers with each entry representing a grayscale / color value, or are there better ways of doing such in terms of performance and memory usage?

Which shader model are you compiling your code to? SM4.0 and up have some (limited) support for indexing into immediate constant buffers, but if I recall correctly SM3.0 has no such functionality.

Generally SM 3.0, but SM 4.0 or 5.0 could be an option as well. Could you maybe provide an example or link about this "indexing into immediate constant buffers" thing?

If the image represents a continuous function of some sort (such as a ramp or a wave), you could just procedurally evaluate it in the shader.

It is also possible to represent photographic images procedurally, if you store the image data's frequency coefficients over x and y (see Fast Fourier Transform). Depending on the image size, this can be very fast in the shader. You can even perform a principal component analysis before shader compilation to determine and select the dominant frequencies of the image, so as to save shader constants.

I have cases of photographic images and others of procedural (such as perlin/simplex noise) which I need to "flatten" in order to gain performance.

As I said the transformation of the photo data into basically "numbers" is not the issue here as I already found tools for that, but my question was in what way / with what programming language constructs it would be best to save those numbers in my HLSL pixel shader code.

Thanks. So are you saying the best HLSL code structure for storing the image data would be a float array? Wouldn't that become quite expensive in terms of memory usage and compile time / run time performance?

Thanks again, that should help

Good to know, thank you!