and all of these go through the CPU and GPU?! |
Efficient transfer of data from the CPU to the GPU can be a bottleneck if you're not careful, but these days GPU connections can have very high throughput. For example, loading the dozens of textures that a room in a game has must be done at the proper times as to not make the game feel choppy. Back in the '90s and '00s, ( for example, the door-opening animation in Resident Evil,
https://www.youtube.com/watch?v=lJK6QeDFncI ). These days, the loading of wait-scenes like that is much rarer.
I'm asking just because I can't find a lot by search |
I feel you, it can be difficult to search for concepts like this when you're not sure how to express them.
I wonder how they work all together on the same piece of code, they split the work? |
They
don't all work together on the same piece of code. That's the beauty of it. They work on the same overall project, but a good project takes a lot of planning and design time. Code is broken up into different, mostly independent parts that different developers are more knowledgeable in than others. For example, the guy scripting a quest ideally shouldn't have to worry about what version your graphics card is, or what animation the character does when he jumps. Also, large projects have documentation, testing, and most importantly, source control. Source control is part of Software Configuration Management (SCM), and allows you to, for example, see who made changes to a file, and what changes were made, line by line. This helps track down any future bugs or features.
what I need to look for in a search |
First, search for a library to do <search term here>. I suggest a multimedia graphics library. It will take care of the a lots of the boring "guts", like window context and low-level functionality. Then, try to get the simplest thing you can to compile and run. For example, simply show a red square in the middle of the screen. Then, have the red square move around randomly or something.
One thing is you could look up the source code of open-source projects (GitHub, GitLab,
https://en.wikipedia.org/wiki/Comparison_of_source_code_hosting_facilities etc.) This can in itself be very overwhelming if you're not used to looking at a large codebase, but everything is there for you to see.
If you want to see what happens at a
most basic level for a GUI window, look into the source code of a Window class in GLFW or SFML. You'll eventually get into OS-specific code, and you'll see what Windows API or Linux API functions are called. That's basically as low as you can go for the CPU side of how a graphical window is made.
On the GPU side, it can take a few hundred lines of code just to get sometimes as simple as a red triangle to show up on the screen. That's pretty much as low-level as you'll ever need to go unless you are planning on developing hardware.
As helios said, you learn by doing. My advice is to start small -- so many people first try to make a game (or something similar), and get overwhelmed by the complexity of it. Just start small, and keep adding on. During this process, you'll figure out how to better organize your code, and you'll learn from your mistakes.
Edit: No, you don't need to work in a team. If you have an idea of something you want to do, just start doing it. Just be aware that very complex, commercial-grade projects are usually made in teams, but they certainly don't have to be.