What are
/r/GraphicsProgramming's
favorite Products & Services?
From 3.5 billion Reddit comments
The most popular Products mentioned in /r/GraphicsProgramming:
The most popular Services mentioned in /r/GraphicsProgramming:
Processing
Udacity
Unreal Engine
hastebin
Mitsuba
Godot Engine
GLFW
Paper.js
Stride Game Engine
JS Bin
Vulkan
HackMD
Blender Game Engine
Houdini
Stack Overflow
The most popular reviews in /r/GraphicsProgramming:
Hello, as one of the two presenters in the video I would love to try to answer any potential questions you might have, assuming it doesn't break NDA of course. ;)
Here is a link to the slides as well: https://www.slideshare.net/QLOC
I went and read some of the shaders and it pretty much just looks like HLSL. They wanted some more features I’m guessing that HLSL was lacking, AZSL just gets transpired to HLSL — it’s an open source extension of it, from here: https://o3de.org/docs/atom-guide/dev-guide/shaders/
I always recommend this course... https://www.udacity.com/course/interactive-3d-graphics--cs291
Great for practicing math and fundamentals in real time computer graphics. The course is written and narrated by one of the authors of Real-Time Rending (http://erich.realtimerendering.com/).
All for the great price of free!
I'm not sure the framebuffer is the low-level thing you are looking for.
It's just an abstraction layer over a very small subset of generic graphics operations (throw this bitmap on the screen). It doesn't even do hardware accelerated 2d operations, let alone 3d. I'm not sure if you need much more than the linux readme.
What kind of low-level graphics programming are you wanting to do?
For a general overview of how modern GPUs work Fabian Giesen's A trip though the graphics pipeline is very good.
Check out Ray Tracing Gems.
https://www.amazon.com/Ray-Tracing-Gems-High-Quality-Real-Time-ebook/dp/B07P5QV1Z5/
No, it's purely a CPU-based renderer, mostly for academic purposes. However, most of the core components and a couple of the integrators can be implemented on the GPU.
You should check out LuxCore (formerly LuxRender), which was originally based off of PBRTv1, and includes GPU acceleration.
Nobody has said Mitsuba yet? It's a reseach-grade GNU physically-based renderer. A lot new rendering algorithms are implemented there because it provides a robust/easy comparison to the state-of-the-art.
At a glance I found this tutorial. If you want to look into other frameworks, GLFW is better maintained and has a slightly more modern API style.
Yeah, not the right subreddit as it seems but still willing to help.
Does he have a favourite video game? There are often art books for those with a mix of renderings and concept arts.
Or maybe look for a cool pop up book, it is more '3D' than just prints but might be difficult to find one for adults. I mean something like this (Amazon link) or this (Amazon link).
There's also Eric Haines'(author of Real Time Rendering) Interactive Graphics course from Udacity, which is free with an optional payment for a certificate
https://www.udacity.com/course/interactive-3d-graphics--cs291
Just last week I was reading a book about symmetry (by Henri Bacry) which talked about durer and used this picture. I'm curious too.
ps: duckduckgo was nice enough to answer an ancient renderer made modern with
Computer Graphics: Principles and Practice, Third Edition
by Kurt Akeley, Steven K. Feiner, James D. Foley, David F. Sklar, Morgan McGuire, Andries van Dam, John F. Hughes
Publisher: Addison-Wesley Professional
Release Date: July 2013
ISBN: 9780133373721
Preview here: https://www.safaribooksonline.com/library/view/computer-graphics-principles/9780133373721/ch03.html
I would say the learning linear algebra will always pay off, especially if you are interested in graphics. No doubt many books on graphics will start out assuming you are well versed in linear algebra which will certainly be overwhelming at first. Doesn't your school have a class on it?
I've had a copy of "Elementary Linear Algebra" on my bookshelf my entire career, and I've been doing graphics since they were just 1D :) I don't know why the current editions are so expensive, but look for used older editions, the math doesn't change: https://www.amazon.com/Elementary-linear-algebra-Howard-Anton-dp-0471053384/dp/0471053384/ref=mt\_other?\_encoding=UTF8&me=&qid=
I have an earlier edition of this book: "Mathematics for 3D Game Programming & Computer Graphics" - it starts out with a good introduction to vectors, matrices etc. Take a look at the table of contents or "Look Inside" at Amazon and see if you like the presentation. https://www.amazon.com/Mathematics-Programming-Computer-Graphics-Third/dp/1435458869
For 3D to 2D, happened accross this image (scroll down one page): Essentials of Interactive Computer Graphics: Concepts and Implementation page 437-440
I always recommend this course... https://www.udacity.com/course/interactive-3d-graphics--cs291
Great for practicing math and fundamentals in real time computer graphics. The course is written and narrated by one of the authors of Real-Time Rending (http://erich.realtimerendering.com/).
All for the great price of free!
Hello Kevin,
Everyone learns at their own pace, so it would really be hard to say how long it would take you. Additionally, real-time rendering is so broad that it is impossible to know it all. As you learn more, you will likely find a sub-area that you'd like to specialize in.
Right now, the majority of work that is done in 3D graphics game programming is usually in C++. That being said, there is a lot that is done in JavaScript via WebGL. Don't worry too much about programming language or API as you start out. There are a lot of concepts to learn first.
To get you started, may I recommend this free online course by Eric Haines, one of the authors of Real-Time Rendering?
It is geared toward beginners and has plenty of exercises to test yourself.
If you find yourself having trouble with the mathematics, check out the book 3D Math Primer for Graphics and Game Development
Perhaps this? Use the Chromium code maybe (it's under a BSD style license)
But I suggest you use some library like SDL (it works with either OpenGL or Direct3D -- SDL just sets up your window and handles user input)
32-bit bitwise and integer operations are largely the performance as float performance on GPUs, at least according to this Stack Overflow. That answer is a few years old, but I can't imagine things have gotten worse since then. If anything, GPUs are even more generic than they were in '12.
Sidefx houdini has an exporter for this with their labs tools. I believe you'd need to pay for an indie license in order to use it though. https://www.sidefx.com/tutorials/game-tools-vertex-animation-textures/
http://norman3d.com/TextureMorphTargets/Vertex-count-agnostic_Morph_Targets.pdf is one of the original papers on the subject I believe. I'm not sure if there is a script for this for 3dsmax (and this also shows UE only)... but I'm sure you can find one for any 3d software at this point.
I do not really know if there are books about that specifically but i personally really enjoined reading the first chapter of this book. Only the first chapter is about the history all others are about programming. I read the 2nd edition with the green cacti on it, so maybe you should first check what they have changed in the 3th and 4th versions. The original C version and 2nd Opengl version where pretty similar https://www.amazon.com/Computer-Graphics-Open-GL-4th/dp/0136053580
Ok! So, for generations the primary reference for 2D/3D graphics had been "Computer Graphics: Principles and Practice" and it's an academic handful. Computer Graphics Not recommend that you buy that, but wanted to give you a heads-up on how deep the graphics field goes.
Knowing that, what OS and graphics system are you interested in working in? Say for OpenGL or Direct 3D the documentation will include basic shaders, and will cover the simpler math required to understand what each shader does.
Do you have any 3D math knowledge of vectors, matrix dot and cross products? Or early color theory of RGB and how colors are stored?
Regarding code structure, this is an issue I struggled with for the first few years of programming. Most of my large or complicated programs were very hard to modify without causing more bugs than I solved.
I recommend practice with building large systems (starting small and working my way up did not help me), and to analyze afterwards what is wrong, what works with regards to structure and how well different parts fit together, and where to put functional/structural boundaries. You will get an intuition as to how to structure large systems such that you can easily modify them without breaking anything else.
The second recommendation is to read the book Code Complete 2 by Steve McConnell. 6/5 stars; should be read more than once by every professional programmer.
> Shirley's minibooks
I assume you are talking about this book ? I'm not familiar with it but any resources are good!
Learning D3D12 is good just be aware that it is easy to get bogged down in the "weeds" if you don't understand the full pipeline. The D3D samples are good to look at.
Linear algebra, trig and calculus in that level of importance are your bread and butter in graphics programming. There are elements of physics in some topics related to photo realism but that's not as important and can be picked up on a per topic basis.
I highly recommend this book https://www.amazon.com/Math-Primer-Graphics-Game-Development/dp/1568817231/ref=sr_1_2?crid=OW0QBP2M4ISN&keywords=graphics+math&qid=1656646341&sprefix=graphics+mach%2Caps%2C336&sr=8-2
Not sure what you mean with bloggish alternative except for your own blogging website. I just know 2 Markdown editors with Latex support that you could use to link. One is Hackmd, the other is Snip Notes
Before starting with the APIs like openGL or so, i recommend you this book:
https://www.amazon.com/Math-Primer-Graphics-Game-Development/dp/1568817231/ref=nodl_
With that you will get a good understanding of linear algebra applied to CG. I came across with similar posts and i don't know why this book doesn't get recommended. Also, make a raytracer from scratch to apply all the concepts that you learnt from the book. They already recommended you the peter shirley's book. Here is another option: https://pragprog.com/titles/jbtracer/the-ray-tracer-challenge/
Have fun!
Don't use an SSBO like a UBO.
UBOs are specifically for the case where virtually all of its contents will be used by the shader(s) and thus put into faster local storage.
Ideally you roll up all of your object UBOs into aligned (glGetIntegerv(GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT, ...)) portions of a single super-buffer and then use glBindBufferRange(...), which will be miles better than all of the glUniform___ calls you're making right now. (bufferpool code)
It's also stupid trivial to sort when you're literally sorting on "which UBO and at what address are you using?"
---
Also, check your resolution of course, none of the Intel GPUs can handle 1080p on much of anything. You normally have to use 720p. It's usually fragment costs that eat the time.
Ought to work so long as you're using `glBindBufferRange`. You'll have to take care regarding alignment, but that's not a big deal really (one of the packers I use on all APIs: https://hastebin.com/ulinukuhek.cpp).
Sure you could use the pointer/offset part of `glVertexAttribPointer` while relying on indices being first in the buffer but I really feel that's going to make your life hell. Keeping the meta information regarding what is where and living with `glBindBufferRange` will be consistent and map cleanly over to w/e compute-shader work you might find yourself doing in the future speaking of which ...
... all of this will probably turn any future compute-shader work you'd intend to do for things like programmable-vertex-pulling, GPU culling, etc into a complete nightmare. You'd end up just saying "fuck it, everything is read+write!"
I don't know of a tutorial for coding a sculpting editor. You may need to break down the problem and look for tutorials at each step.
Off the top of my head you need a few things. My advice is add one feature at a time and get it working before tackling the next one. Don't be afraid to skip difficult features and circle back later.
- render a mesh
- shading (light source?)
- pan, rotate, zoom
- convert "mouse XY" to "mesh XYZ" (track sculpt tool location)
- mesh modification (similar to terrain modification -- raise, lower, smooth, ...)
- global mesh subdivision (increase detail everywhere)
- local mesh subdivision (increase detail in just one area)
- save mesh data (some kind of 3d object file format)
Here is a finished product to investigate the UI and features you might want: https://stephaneginier.com/sculptgl/
So, like the corner of paper curling? That would be pretty complex as you have not just displacement in the z, but also the rotational component. If you really want the geometry to bent, then you would need to map the flat surface of the rectangle strip to some kind of cylinder. But I wouldn't know how to do this from the top of my head.
If it is just supposed to be like a slope, you also have to displace it in the x-y plane, but it will be easier to find a conversion for it. But if you just need a slope, it would be easier to just to rotate the rectangle strip. If you just displace it in the z-direction (so just color it blue with something like the colorize option in GIMP), it will change its surface area (aka it will looked stretched).
I searched for that for a long time back in the day and couldn't find anything comparable. I think you just need to use multiple sources to supplement each other. My go to sources became
In depth 3d knowledge rather than specific apis www.scratchpixel.com
General good source for brushing up on linear algebra khanacademy.com
Maps are often stored in a structured data format, take a look at open street map data, download an area from there. It comes in as xml (but that can be reduced further to a binary format), just lists of buildings, areas, roads etc, as lists of lat lon coordinate points, That data is usually rendered to svg with each zoom/movement. So google or someone don't store images they just send down the mapping data and render the image dynamically as you move/zoom about.
Yeah I completely agree that this is probably the biggest issue with C++. They need a standard, easy to use package manager. I think the only good answer right now is to ignore the current package managers (because they are all bad), and do everything with bespoke CMAKE builds. Yes this sucks and is bad, but I still think that the tradeoffs of using other languages aren't worth it. Once you get your build working, it should generally just keep working. But the limitations of other languages are things you'll have to be dealing with every day.
If you are still dedicated to finding a new language, I might recommend D. The idea of it is that its a kind of C++ redux and is cleaner and less bloated, with its own package manager called DUB. Its similar enough to C++ that you can often translate C++ examples into D without too much trouble. Its compiler can also generate debug symbols compatible with Visual Studio or GDB. It has a garbage collector, but you can choose when to turn it off for performance critical code. There are enough people who use D for graphics programming that the big popular libraries that you will want are indeed available. The main tradeoff is that D is not terribly popular, so when you have a question it will be more difficult to find answers. I actually do prefer D, but this final point is what makes C++ easier to live with.
> Did you start coding and such before you went to uni ?
I was lucky enough to have a Pascal and C class in high school.
> What specifically didn’t pay well ?
You can sell tools on https://assetstore.unity.com/ and https://www.unrealengine.com/marketplace/en-US/store but the price competition is ridiculous. It's a market made of customers with no money demand the world from producers selling code they mostly wrote for themselves for fun.
> Is there a lot of math involved with the work you did ?
Not a ton. Just very basic linear algebra.
> Do you even need to know how to code to make a game now since you can use blueprints ?
Blueprints is great for prototyping. But, you still need a whole lot of code to make a game.
These seem to work really well for top-down projection (sphere, mask), but there's some really big distortions for the Head and Venus meshes. Is it possible to use different projection types? (I guess that would be sphere or cylinder, respectively)
I've never used it for any graph plotting purposes myself so might not actually be a good idea but have you considered using blender?
It does 3D, it does crisp line rendering and it's offering a python api for customization and automation of all features mentioned so shouldn't be too far fetched to for example do the calculations with numpy or pandas or other python math libs and move the output over to blender for rendering.
This is just a guess from me but also considering the huge community around it might be possible that there's also blender plugins for chart rendering available somewhere out there already.
Also processing and js libraries like p5.js come to mind.
People may disagree with me here but IMO the browser is the sort of "standard" environment these days for most chart/data visualization so might be worth having a look around different js-paths before completely discarding the idea of using something browser based. (Not sure if you meant it should just work without you having to be online or if you just really don't like web browsers for some reason...)
Processing and blender would solve both those concerns, using p5 or similar js-library would still keep you in a browser for rendering but still allow you to be offline or stand-alone if you prefer so maybe good enough?
Browsers also support everything on your list, including linux support and 3d rendering capabilities etc
Maybe try its 'father', the original Processing. It's written in Java, so it should be faster.
If that's not performant enough, maybe switch to C++ creative coding environment like Cinder.
Get him started with Processing. The biggest barrier to entry with this sort of shit is people becoming despondent from looking at a black screen all day.
Something like processing will allow him to get some results on the screen very quickly, but after a while he'll hit performance bottlenecks which will naturally make him research more optimal ways of performing certain tasks. Having an actual problem to solve makes learning about these sorts of things much easier in my experience.
A 12 year old mightn't necessarily have developed the stamina it takes to stare at a GL_INVALID_ENUM error and a blank screen all day without just giving up so I find something that provides lots of little wins as a much better way of learning.
If he'd rather start with a more performant language, cinder is a professional level toolkit that will remove a lot of the boring OS boilerplate. It's C++/OpenGL so has no real upper bound in terms of how low level he wants to get. I've shipped 100+ major public installations on top of it, so it's no toy.
Good luck!
Godot's SDFGI implementation may be like that?
Here's an article explaining their approach, and the code is open source, using Vulkan.
Would perhaps Godot be an interesting project to hack on?
However, if you want to learn Vulkan and how to run a graphics pipeline, I think you may want to start your own tiny pet project instead. The other replies have great resources for that :)
Removed for Violation of Rule 1: Posts should be about Graphics Programming
It's cool, it has a rendering, but neither this post nor the source code talk about the implementation of the rendering. Looks like this just utilizes [Paper.js](http://paperjs.org/).
I couldn't tell you how to implement one, but the theory behind raytracing is that you're working backwards to render a scene as to how it's normally displayed in nature. In the real world, light from a source (the Sun, a lamp, etc.) casts a ray of photons to an object and that ray is then reflected off the object to your eye. Raytracing goes the other way. The color and intensity of each pixel on your screen is determined by tracing a path from that pixel to the object and then to the light source. POV-Ray is a raytracer that's been around for decades. I remember my brother-in-law playing with this on his 386. It would literally take days back then to render a scene with more than a few objects, reflections and light sources. The source code is available so maybe you can get some ideas about how it works by looking at it. All that stuff is way over my head. I just know the ELI5 bit. :)
Sorry, I completely forgot to answer that.
It's definitely possible to get an internship in any of those.
I also forgot to list a company that does really good stuff in france: Allegorithmic. They work on Substance painter, which you may know about. It's basically a texturing software but extremly advanced, and integrating nice visualization too. They have skills for sure.
The French startups I know are mostly in Paris, Allegorithmic is in Clermont-Ferrand I think. There is always the remote working possibility, but I wouldn't advise it. At least personnally I get bored working home and unproductive.
I would highly recommend three.js. You could probably build some cool things very quickly with your existing knowledge of the graphics pipeline.
http://threejs.org/docs/index.html#Manual/Introduction/Creating_a_scene
I just hacked the gif by about 10 command line calls that were variations of this gegl -i t9.png -o t10.png -- layer src=lilI.png x=150 y=150 which places an 150x150 pattern (lilI.png) over the previous image (t9.png; 450x450) at different locations ( x=150 y=150; this placed the centre tile ). Then I used a webapp (ezgif.com) to do the fades and the set the timing.
I'm trying to figure if it would be worth it to write a dedicated snippet to do it all together.
I think if someone were to say, I might use it, if you wrote it, or something to that effect, I would make it a script.
As protestor said, it's best to use a windowing toolkit for this stuff unless you're interested in implementing it manually.
The one I use for my OpenGL projects is GLFW. I highly recommend you check it out. And since it's open source, if you want to find out how it's done, you can!
Cinder. It's C++ and comes with a shitload of demos so you can get something on the screen quickly. This is important because looking at a black screen for days debugging obscure OpenGL errors can be discouraging to people just starting out.
There's lots of good answers about how to dive in to graphics APIs, and I want to suggest an alternative that still lets him make stuff that's clearly a game: MonoGame (which is based on Microsoft's canceled XNA framework).
It's a great, programmer-focused API for making games in C#. I used it before working on games professionally, and it was a really helpful level of abstraction that helped get me ready to do this full-time. It also handles (but doesn't hide) some of the complicated work of game dev like asset management, which is the sort of stuff that could be exciting or joy-killing, depending entirely on your son's reaction.
You could use a free and open-source 3d engine, such as https://stride3d.net which uses an easy to use entity-component system.
Then the drawing part is just a few lines of code, even with high quality shading and you can concentrate on the simulation code...
Well a lot of the core matrix math is still entirely relevant in 2D and processing does have some 3D features. A transform is still a transform a translate is a translate. You also mentioned in your post that you are more interested in interesting graphics like fractals/art display stuff and getting your feet wet with 2D and processing is probably going to be a lot more fun. These books seem closer to what you are actually looking for!
Like I mentioned before- 3D can sometimes be a massive bear to work with. Depending on the frameworks or tools you are using just getting to the point where you can write text to the screen is very hard. Assets with normal maps, textures and models themselves is hard while bitmaps are easy. 3D file formats and animation stored in those formats are hard, file formats and animation in 2D (via tile swapping or some programmed mechanism) is easy. I'm not saying hard as impossible just hard as in 'may be a nontrivial amount of time.' The infrastructure for a 3D pipeline is very time consuming where 2D pipelines are not as bad.
Once you get your feet wet and you know what you want there is plenty to do and to learn but having a strong toolkit to just play around in (which is what processing gives you) is never a bad thing.
I am only a beginner myself, but I’ve been working through these books and find them excellent.
Foundations of Game Engine Development, Volume 1: Mathematics https://www.amazon.ca/dp/0985811749/ref=cm_sw_r_cp_api_fabc_kEI6FbHJJGAJS
Foundations of Game Engine Development, Volume 2: Rendering https://www.amazon.ca/dp/0985811757/ref=cm_sw_r_cp_api_fabc_KFI6Fb5NECG31?_encoding=UTF8&psc=1
I have an M.S. degree in CS from a UC but that is besides the point. Going to grad school is a life changing decision. Aside from that, you can be a rendering engineer without it. Start with MIT OCW Linear algebra, OpenCL and this book : https://www.amazon.com/Mathematics-Programming-Computer-Graphics-Third/dp/1435458869/ref=sr_1_3?crid=1NFW0SK1S02GF&dchild=1&keywords=mathematics+for+3d+game+programming+and+computer+graphics&qid=1607452304&sprefix=mathematics+for+3d%2Cvideogames%2C225&sr=8-3
Check out the book "production pipeline fundamentals for film and games" it's worth the read:
Unfortunately even the most famous work on VFX pipelines in IMO, quite lacking. Although the issue is that in my opinion it's just too thin, but it might work for you. This one is the one people usually recommend.
As usual, PhD is commonly asked, but it's not like everybody at Pixar (or Disney or whatever) has PhD.
People working in the field take a long education to learn this stuff, and you want to learn it quickly with little to no effort? Sorry if I misunderstood something. But yeah, there is plenty of "how to do X" tutorials online, but you won't really learn much from them without knowing the fundamentals.
Learning takes studying and effort. Beginner friendly books would be Dunn's book 3d primer for graphics and game development and maybe Michael Abrash black book. The "Graphics Gems" book series is also great.
Studying linear algebra, some calculus and real analysis doesn't hurt either. Having an intuition for how different coordinate systems and projections work is important.
I mean the "Amazon eTextbook" version, at least on the product listing they call it the "Kindle Edition".
Don't know about the 3rd edition, but the 2nd edition is probably published in 1987, and 3rd edition from amazon is completely different. https://www.amazon.com/Computer-Graphics-Principles-Practice-3rd/dp/0321399528/ref=sr_1_1?ie=UTF8&qid=1530000672&sr=8-1&keywords=computer+graphics+principles+and+practice
I learned from the infamous "Red Book". But, that was long, long ago in a university far, far away. Even the 7th edition of that book only covers OGL 3.1... These days, any of the tutorials in the sidebar of r/OpenGL would be good.
I recommend this book if you really interested in terrain rendering especially for globes. It covers some techniques to implement it such as geometry clipmap and chunked LOD.
http://www.amazon.com/3D-Engine-Design-Virtual-Globes/dp/1568817118
I highly recommend Frank Luna as well. His DX11 book is excellent. Some of the DirectX specific code is a bit outdated now, (for example fx files aren't a thing anymore and D3DX was killed off), but the graphics theory is still very good.