abseil-cpp
LearnOpenGL
Our great sponsors
abseil-cpp | LearnOpenGL | |
---|---|---|
54 | 624 | |
13,768 | 10,125 | |
3.1% | - | |
9.5 | 3.7 | |
4 days ago | 21 days ago | |
C++ | C++ | |
Apache License 2.0 | GNU General Public License v3.0 or later |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
abseil-cpp
- Sane C++ Libraries
- Is Ada safer than Rust?
-
Appending to an std:string character-by-character: how does the capacity grow?
Yeah, it's nice! And Abseil does it, IFF you use LLVM libc++.
https://github.com/abseil/abseil-cpp/blob/master/absl/string...
The standard adopted it as resize_and_overwrite. Which I think is a little clunky.
-
Shaving 40% Off Google’s B-Tree Implementation with Go Generics
This may be confusing to those familiar with Google's libraries. The baseline is the Go BTree, which I personally never heard of until just now, not the C++ absl::btree_set. The benchmarks aren't directly comparable, but the C++ version also comes with good microbenchmark coverage.
https://github.com/google/btree
https://github.com/abseil/abseil-cpp/blob/master/absl/contai...
-
“Once” one-time concurrent initialization with an integer
An implementation of call_once that accommodates callbacks that throw: https://github.com/abseil/abseil-cpp/blob/master/absl/base/c...
-
[R] AlphaDev discovers faster sorting algorithms
I wouldn't say it's that cryptic. It's just a few bitwise rotations/shifts/xor operations.
-
Deepmind Alphadev: Faster sorting algorithms discovered using deep RL
You can see hashing optimizations as well https://www.deepmind.com/blog/alphadev-discovers-faster-sort..., https://github.com/abseil/abseil-cpp/commit/74eee2aff683cc7d...
I was one of the members who reviewed expertly what has been done both in sorting and hashing. Overall it's more about assembly, finding missed compiler optimizations and balancing between correctness and distribution (in hashing in particular).
It was not revolutionary in a sense it hasn't found completely new approaches but converged to something incomprehensible for humans but relatively good for performance which proves the point that optimal programs are very inhuman.
Note that for instructions in sorting, removing them does not always lead to better performance, for example, instructions can run in parallel and the effect can be less profound. Benchmarks can lie and compiler could do something differently when recompiling the sort3 function which was changed. There was some evidence that the effect can come from the other side.
For hashing it was even funnier, very small strings up to 64 bit already used 3 instructions like add some constant -> multiply 64x64 -> xor upper/lower. For bigger ones the question becomes more complicated, that's why 9-16 was a better spot and it simplified from 2 multiplications to just one and a rotation. Distribution on real workloads was good, it almost passed smhasher and we decided it was good enough to try out in prod. We did not rollback as you can see from abseil :)
But even given all that, it was fascinating to watch how this system was searching and was able to find particular programs can be further simplified. Kudos to everyone involved, it's a great incremental change that can bring more results in the future.
-
Backward compatible implementations of newer standards constructs?
Check out https://abseil.io. It offers absl::optional, which is a backport of std::optional.
-
Best practice for cpp projects using CMake
As far as scientific studies go, I'm not sure if there are any that support the arguments of the linked proposal, but if you take a look at some of the most complex, large scale projects out there, you'll notice that they follow to a large extent the same structure as the one outlined in the above proposal. For instance, checkout the Google Chromium project, the AOSP projects, abseil, folly and many others. Of course, there will be exceptions so this is not a foolproof argument but I think it's interesting that projects of this scale have been designed this way.
LearnOpenGL
-
LearnD3D11, a guide aimed at anyone trying to learn Direct3D11
Also recommended: LearnOpenGL [1] and Vulkan Guide [2]
-
Is there space in this field for extreme cases like mine ?
- Game development - Unity3D project based learning in C#: https://learn.unity.com/ - Graphics - There was another user on r/GraphicsProgramming the other day (who teaches Computer Graphics at his university) that linked their lecture series for the entry year of their course here: https://tamats.com/learn/realtime-graphics/ - Project based learning: https://github.com/ssloy/tinyrenderer/wiki - Rendering API tutorials: https://vulkan-tutorial.com/, https://learnopengl.com/
-
Where do I start to learn C++ for a game development
If u want to make 3D game, you'll probably want to learn some 3D shader graphic stuff. OpenGL is a good start. https://learnopengl.com
-
Ask HN: Learn Graphics Programming, Recommendations?
LearnOpenGl.com
Possibly a smidge outdated.
Goes from blank window to rendering 3d meshes with advanced lighting techniques (HDR, SSAO and more).
Heped me understand shader pipeline, so I recommend it.
- Ajutor in privinta incercarii a face un joc
-
Realtime Ray Marching implemented with Rust and wgpu
Perhaps you could learn something like https://learnopengl.com/ first to master intermediate and advanced content in Computer Graphics. And then try to port these richly documented algorithms to WGSL.
-
How do I become a graphics programmer? – A guide from AMD Game Engineering team
I started with putting pixels in MCGA to CPU rasterize phong shaded triangles, and I don’t recommend it.
Instead, I’d recommend
WebGPU is a pretty good starting point, that's what I did myself (with C++, not Rust though, which should be even more straightforward). You can even use it in the browser and skip all the native hassle.
Just learn the basic concepts like buffers, drawing, texture, light, perspective etc. from https://learnopengl.com/ then you can jump into WebGPU. Even though there's not that many WebGPU tutorial, applying the OpenGL tutorials to it is pretty straightforward once you understand the fundamentals.
-
How do I compile using cl.exe c++
they link it at that page at the bottom of the lesson but just for ease here is the source code from learnopengl.com
-
Exploring Computer Graphics: Weekly Chronicle #1
Learn OpenGL online book
What are some alternatives?
Folly - An open-source C++ library developed and used at Facebook.
Boost - Super-project for modularized Boost
raylib - A simple and easy-to-use library to enjoy videogames programming
bgfx - Cross-platform, graphics API agnostic, "Bring Your Own Engine/Framework" style rendering library.
imgui - Dear ImGui: Bloat-free Graphical User interface for C++ with minimal dependencies
spdlog - Fast C++ logging library.
Qt - Qt Base (Core, Gui, Widgets, Network, ...)
sokol - minimal cross-platform standalone C headers
EASTL - Obsolete repo, please go to: https://github.com/electronicarts/EASTL
bevy - A refreshingly simple data-driven game engine built in Rust
BDE - Basic Development Environment - a set of foundational C++ libraries used at Bloomberg.
SFML - Simple and Fast Multimedia Library