How could I use glShaderSource in glad-fortran

[lj-cug]

My vertex shader is defined as:
character(len=:), allocatable, target :: vertexShaderSource vertexShaderSource = & "#version 330 core" // C_NEW_LINE // & "layout (location = 0) in vec3 aPos;" // C_NEW_LINE // & "void main()" // C_NEW_LINE // & "{" // C_NEW_LINE // & " gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);" // C_NEW_LINE // & "}" // C_NULL_CHAR
How can I use
" vertexShader = glCreateShader(GL_VERTEX_SHADER)
call glShaderSource(vertexShader, 1, shader_ptr)
"
I am not sure how to use glShaderSource, what's the arguments?

Actually I don't know how to use many APIs with several arguments, especially the commented API calls in the uploaded Fortran code. Could you please check it for me?
Thanks
Li

gl_glfw.txt

[gadjalin]

There are a couple of things that should be noted here, and I will work on a more extensive documentation and set of example codes to make it clearer.
First, I suggest the very good tool docs.gl for a complete documentation on the OpenGL specification and the functions signatures.
This is of course for C, but the C signatures of the functions and their usage can be straightforwardly translated to Fortran by following a couple of rules.
In your case, for the glShaderSource, it takes an array of strings, which size is given by the second argument (count), and the length of each string given by the array in fourth position:

glShaderSource(shader, count, strings, lengths)

Because the Fortran type system is quite restricting in instances, and it is difficult to handle special cases when generically generating code like glad-fortran does, this signature should be taken quite literally.
In C, having a single string and passing a reference to it can be interpreted as a size one array. Fortran must explicitly use an array in this case.
On the other hand, there is no need for you to worry about null-termination, the translation from Fortran to C strings is handled by glad-fortran, so no C_NULL_CHAR is required in your code.
I tested with your code and suggest the following:

• First allocate an array of strings in your preferred fashion. I don't know what is the easiest and user-friendliest way to do it, but the simplest is probably:

character(len=:), dimension(:), allocatable, target :: source
allocate(character(1024) :: source(1))
source(1) = ...

There's probably a nicer, more dynamic way to do this though.

• Then, because glad-fortran takes care of adding null-termination characters before giving it to the C code, ignoring the fourth lengths argument will work fine, as per the OpenGL documentation says. It is declared as optional in Fortran.

call glShaderSource(shader, 1, source)

Note that this function uses a character(:), dimension(:), pointer dummy argument, so the actual argument must be an allocatable target, which is a bit annoying but is a consequence of the restricting Fortran type system and the need to have pointers to convert to C strings and pass it to OpenGL.

Ideally I would like to do something like

character(:), allocatable :: source
source = ...
...
call glShaderSource(shader, 1, [source])

So that it would be simpler when using only one string like this, but I did not figure out any way to do this currently.

Here are also a couple of examples of things you should be careful with in your original code (I'll just throw a bunch)

• glGetShaderiv returns an integer. Logical types cannot be used here.

call glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, success)
if (success == GL_FALSE) then
...

• Something I wrote in the README is about handling arrays of arbitrary types, such as glBufferData expects. The Fortran code makes use of assumed-types so that the user does not have to call c_loc or use type(c_ptr) explicitly. The trade-off is that it cannot handle both arrays and scalars, so the input must be scalar: the first element to a contiguous array (vertices(1))

call glBufferData(GL_ARRAY_BUFFER, c_sizeof(verticies), vertices(1), GL_STATIC_DRAW)

• Handling type size is bit annoying as well. There are some mismatch between the OpenGL type and what routines such as c_sizeof return. Some alternatives would be to store intrinsic type sizes in parameter variables, or the intrinsic storage_size function.

call glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, int(3*c_sizeof(vertices(1)), kind=c_int))

This was a lengthy answer, and I will put all of this in a documentation very soon.
Let me know if you have more similar questions about how to use certain routines here.

[lj-cug]

gl_glfw.txt

As your guides, I succeed to compile and run my testing Fortran code.
But the expected triangle was not showing in my screen?

Besides that, I cannot use this API in right style:
character(len=:, kind=c_char), dimension(:), pointer :: infoLog ... call glGetShaderInfoLog(vertexShader, 512, infoLog(1)) ! how can I call it?
Thank you!
Li

[gadjalin]

A couple a thing:

• In your code, I suggest you declare your vertexShaderSource and fragmentShaderSource with allocatable and not pointer. If you use pointer you HAVE to deallocate them, or the memory will leak. Note that these variable are used as input, that you give to OpenGL. If you use allocatable, they will be deallocated at the end of execution if you don't do it before. On the other hand, you have to use the target attribute because glad-fortran will take a pointer dummy argument.

character(:), dimension(:), allocatable, target :: source

• On the other hand, infoLog is used to retrieve an output, that is a single character string handled by OpenGL. It means that glGetShaderInfoLog expects a fixed-length buffer where to store the result. It can be allocatable or pointer, but it should be allocated before calling the function. And it should not be an array. Therefore, it can simply be declared as:

character(512) :: infoLog
...
call glGetShaderInfoLog(shader, 512, infoLog=infoLog)

This is quite straightforwardly the Fortran application of what the C code would expect. EDIT: Note however that I am ignoring the third length parameter here, which is optional, and must assign the fourth infoLog argument to its right dummy argument.

• The reason why you don't see your triangle is because you declared you vertices array with real(c_double), but called glBufferData with GL_FLOAT. Your data layout is wrong, which is not a problem with glad-fortran but a misuse of OpenGL (very common however). Either declare your array as normal real or real(real32), that is, a 4 byte float, or declare your data layout approprietly using GL_DOUBLE.
• Lastly, the rule I gave of passing arrays by using their first element, using e.g. vertices(1) in glBufferData, usually only applies to pointers to numerical types (int, float, double,...) and arbitrary data types (typically void*). This is because some functions take user pointers as input that can be both interpeted as scalar output, or array input (which arrays can sometimes be interpreted as length one, so technically scalars). It is hard to make a disctinction when generating code, and Fortran is restricting in this case. So the input type is usually a scalar pointer, which can then be the first slot of an array (which is actually how C works: an array is just a pointer to the first element). Character types are generally used in different situations, and the distinction is made obvious by the type. So glShaderSource does take a string array as input, because the intent of char** is usually well-defined, whereas glGetShaderInfoLog takes a buffer string, or char*. So your attempt at passing infoLog(1) would have been incorrect.

There are some of these points that I should definitely clarify in a documentation.

In conclusion, always check the OpenGL documentation to make sure you understand what a function does and what are its arguments, so you know if you are calling it right or not.
And if you find something that is not obviously translatable to Fortran or does not behave as expected, please let me know!

[lj-cug]

Thank you very much for your help! Now triangle can be shown. https://docs.gl/ is helpful to me!
I have to point out that "call glGetShaderInfoLog(vertexShader, 512, buffsize, infoLog)" , integer buffsize should be as one argument, it's not optional? Otherwise, compilation error will happen.
Thank you once again for your contributions and help. I think glad-fortran and glf90w can be ready for production-level development for Fortran applications.
Cheers
Li

[gadjalin]

Right, glGetShaderInfoLog takes an extra int* to return the size of the written string to the user. Because it is a simple int* used for returning something to the user, it is in fact optional on the Fortran side, as I consider that it could be ignored (i.e. passing NULL in C), however, because it is in third position before the infoLog string, you must explicitly assign infoLog in the function call, or the compiler will understand that infoLog is supposed to be the third length argument:

call glGetShaderInfoLog(shader, 512, infoLog=infoLog)

I did do this when testing but forgot about it in my previous answers.

Thank YOU for your help testing the code and giving feedback! I don't know about production level, but there are definitely some things that I want to improve, especially in glad-fortran.
I hope that this is all useful to you and that it may be useful to someone else as well.
Let me know if there is anything else.