The -D predates CMake and is part of gcc syntax for a definition which gets translated to a #define statement. Other executables (like java) use this convention as well for injecting variables (of one kind or another) in from the command line.

I was trying to build GLFW into my project from a git submodule for 9 hours, learned compiling, learned linking, learned cmake, with the first and second tutorial... I spent 3 hours searching about how things were seen by various linkers and whatnot... then I noticed there was a 3rd tutorial episode.

16:00 in target_link_libraries you reference other targets, in this case glfw specifies a target. This comes from the call to add_library() in external/glfw/src/CMakeLists.txt. In that CMakeLists.txt file you can see that they somehow set the name of the target library to glfw3 (for whatever reason), but the beauty of using targets is that you don't need to care about how it is actually called. You work only with the target name which can be completely different than the library name.

don't know if i suck at finding it but this was the only good tutorial on git submodules, thanks a lot

Thanks so much for these videos man! I know you're more of a small KZfaqr, but I don't like the other videos on KZfaq about CMake as much as yours. Your examples, even though sometimes you make a lot of errors along the way, actually help me learn a lot better, because I see what doesn't work and what does Usually it makes me learn _why._ This is very helpful for me, because I can get a sense of what under-girds the principles behind these tools. Thanks so much man!

Thank you for the wonderful explanation of the teeny tiny details! Great to learn as a beginner!

This series is so great! Really push me to tick CMake off my to-learn list!!!

Very well done and very helpful for the total NOOB. I enjoy the little bit of light humor. Keeps things from getting too bland.

this play list is my main reference whenever I want to use CMake, extremally helpful

I enjoy the small jokes you slip in, "git into git" and the binocular vision when something in the Cmake documentation piqued your interest in the last episode. Informative and funny, thanks for this series.

EXTREMELY helpful tutorial series! I've been trying to get this setup since 2014, unsuccessfully. I know I'm dumb but it's generous digital elves like you that save grace upon this wretched planet 😅

Make this is top notch tutorial! This is such a complex topic and you make it look so easy.

Thank you for this tutorial, as a novice in CMake, it really helped me in my project.

These courses are fantastic.

Awesome series. Been a great help for my project👏

Thank you thank you, this was the video that finally helped me get SFML configured for VSCode and CMake on a Mac.

this tutorial is pure gold

I think we use glfw instead of glfw3, because we should put here the parameter, which was used in add_library(glfw [...]) (in external/glfw/src/CMakeLists.txt,). The same was for Adder. Let me know if it's a good way of thinking about it :)

Thanks for the great tutorial man, very well made and easy to understand.

This is a great series! Thank you!

Literally trying to figure out how to setup a cross platform project for Linux/Windows that uses GLFW and CMake and just found this series, thankyou, such relief to have someone explain this in simple terms.

Amazing tutorials!

Good tutorial. Thank you!

Thanks a lot for the video. Best explanation overrall.

I feel like a will become the very Lord and Savior by end of this course! Great job!

Thanks for the video.

You're the man!!! So easy to follow you.

This was very helpful. Thank you!!

Cool video and explanation

fascinating explanation, best regards

This is very so good lecture!!!!! Great job!!!! Thanks!

thankyou for your efforts bro...!

Thank you very much!

i think in this example target_include_directories is not necessary as these header file directories from library are already included when building the libraries, and when you do the target_link_libraries it will add its interface_include_directories to the current target include_directories automatically. Nice tutorial! Really appreciate it!

I have subbed. Your channel is awesome. Thank you so much 🙏

Really good tutorial!!!

good tutorial!

thank you

TY SO MUCH!!!

Oh Zeus you're the real saviour, thy shal be thanked!

thanks for the awesome tutorial and didn't know he bring his twin brother to talk this time lol.

OMG Somebody stole your goatee, did you have it insured ? Haha 😄 another great tutorial!!

10:21 "-D" is use for option because it's actually #define of particular macro.

Regarding cmake targets (around the 14:30 mark): target_include_directories refers to the directories that the target needs to search for its own include headers (in this case adder). If that target were to be used as a dependency of a different target (like glfw here), its directories would be transitive and be passed on (provided they are public) by just adding the cmake target in target_link_libraries. Having said that, adding another target’s directories to the target in question is kind of hijacking it to make the directories visible at compilation time. Hope this wasn’t too confusing.

My god. Thanks a ton. Sincerely.

Great tutorial. Made me subscribe to your channel. :)

Thanks

It probably has been mentioned below. But the target_link_directories don't seem to be needed since you actually use the names in the add_library commands and not the names of the library files. That's why you use glwf and not glwf3 since the CMakeLists.txt of GLWF uses the add_library(glfw ...) command to create the library Well, at least as a noob, that's how see to understand it

Thanks, Sir! I learn a LOT! Question: why is the libglfw3.a file generated in the src dir (though it involves under 'build' dir)? Is it source code? And when we include the path of libglfw3.a, why don't we need to include the 'out/build' in front of it?

I wonder what would happen if I import two submodules with options having conflicting names, and I want to have one of them ON and other OFF.

Thanks for the very helpful tutorial! What about libs like GLEW ? That don't have CMakeLists.txt in treir repos ? How can you add them as a submodule ? or is there a different approach for those ? Thx and keep up and the good work!

glfw3 is a library name but cmake needs a target, which is glfw.

Do not try to add multiple directories via one add_subdirectory() command (it is not even plural!!!) as i tried to. It works, but only the first directory is added which results in linking errors!!!

A change needed in CMakeLists.txt (line 29): "external_modules/glfw" --> "external/glfw".

re: 10:22 why "D" is option. The -D* is probably mimicking the way that g++ does macro [D]efinitions

where I can find the source code? It's no longer in the description.

Hi, thanks for the tut, I wonder what does this "#!" mean, and when I use it on my windows, the command just won't work, tells me '#!' is not recognized as an internal or external command....

Firstly , Thank you for great tutorial ! I have a question. I add git submodules glad and sdl2. when glad build , it build a glad.c and glad.h so i can't target_include it in cmake . How can i make it work ?

What if my submodule only has MakeFile not CMakeLists?

If I remove the `target_include_directories(...)` it can still be run without problem. Any idea? btw, I think -D means Define variable

Maybe someone can help and explain why do we need "target_link_directories"? And what is the difference with target_link_libraries? I wrote the code without "target_link_directories", but with "target_link_libraries" and it still works just fine.

When building I got the following error: /home/pavel/Projects/olas/external/glfw/include/GLFW/glfw3.h:241:12: fatal error: GL/gl.h: No such file or directory #include . I fixed it by modification of glfw3.h, which is not the correct way I guess. Any advice, please?

I have a question. In main.cpp you include . Why did you include as a system library? #include "glfw3.h" seems more reasonable to me due to target_include_directories(${PROJECT_NAME} PUBLIC Adder PUBLIC external/glfw/include ) However, that solution throws me an error during compilation. What am I missing? Nice video anyway! It helps me to understand cmake much better!

Your videos are great; make me sub to it. I have followed this video, didn't get any error, but the window didn't pop up :( What did I miss?

git into git............... I'm dead

10:25 my guess D was used because D could mean "Dependency" but I dont think it means Dependency, but perhaps thats why they chose D because the options that people use could be seen as build deps.

what happened to ur hair? on previous video u were more like Jesus, i liked it better)