Top products from r/GraphicsProgramming

We found 36 product mentions on r/GraphicsProgramming. We ranked the 26 resulting products by number of redditors who mentioned them. Here are the top 20.

Next page

Top comments that mention products on r/GraphicsProgramming:

u/Nihilus84 · 9 pointsr/GraphicsProgramming

Professional graphics programmer here with an MSc in related Comp Sci degree.

First ditch the idea of using JavaScript or any off the shelf graphics libraries like SDL. Also forget making a game. If you want to learn rendering/graphics techniques then make that your focus. The key to this plan is that you learn by doing, not just reading. I make it a point to myself that I never fully understand something unless I’ve implemented it myself from scratch.

  1. Starting from a blank c++ solution write a working offline ray tracer/pathtracer on the CPU that writes out to an image file. See https://www.amazon.co.uk/Ray-Tracing-Weekend-Minibooks-Book-ebook/dp/B01B5AODD8. This book was free online a bit ago, not sure if it still is. Writing a ray tracer will teach you fundamental rendering principles that underpin everything without the verbosity and boilerplate of the modern forward rendering pipeline used for real-time applications.

  2. Write an win32 application with a window context (a lot of helpful examples online). Then implement a simple Directx 11 forward renderer (plenty of books/tutorials out there). First get a triangle rendering in your window with vertex colours and then using some simple procedural meshes like a cube/sphere/cylinder etc get a moving camera with your matrix transforms all working using very basic vertex/pixel shaders. Then add a model/mesh loader for obj files or even you’re own format with help of a model converter/parser that is easy to write. Start to add more complex lighting in your shaders and start creating a 3D demo scene to show off your various rendering techniques:

    Blinn-phong reflectance, texture mapping and directional, point and spot lights will get you a long way. Add a sky using a cube map. Move onto static/dynamic environment mapping to create some reflections on a model. Then start implementing normal bump mapping/parallax mapping on something like a brick wall etc. Then look at shadow mapping and adding a moving directional light (sun) to showcase your shadows. Add some alpha blended transparent and alpha test materials to the scene. Maybe then also add basic animations on your meshes using simple vertex displacement techniques in the shader. From here there’s much much more you could add but you have an adequate if basic demo to add to your portfolio that shows an understanding of fundamental 3D principles (importantly from scratch in your own renderer).

    From here you could add bump mapped water with planar reflections and refraction, height mapped terrain, a particle system effect (maybe via the geometry shader), the list is endless really.

    I’ll add here that a lightweight off the shelf GUI library will help with demoing it all. Also take the opportunity to familiarise yourself with graphics capture analysis tools such as RenderDoc, Pix or intel GPA. A godsend For debugging graphics issues and used widely in industry.

  3. Look into more advanced rendering techniques such as cascaded shadow maps and implementing a deferred renderer (will allow you to showcase many hundred lights).

  4. Add post processing techniques such as bloom, HDR tone mapping, FXAA and maybe even some depth based fx such as SSAO or depth of field.

  5. More complex contemporary illumination techniques using PBR (physically based rendering) such as GGX specular model and global illumination using light/reflection probes.

    If you get anywhere near all of that in your portfolio you will easily land a graphics programmer job!

    Hopefully this was of some help 🙂.
u/FAtBall00n · 6 pointsr/GraphicsProgramming

I'm not a professional graphics programmer, but I am a CS grad and a senior developer for about 10 years. I haven't yet had the time to dive into fully committing myself, however, here was my personal plan for when that moment came.

This gave some great advice and was my starting point:

https://interplayoflight.wordpress.com/2018/07/08/how-to-start-learn-graphics-programming/

​

Then I was going to read this to learn about game engine architecture:

https://www.amazon.com/Engine-Architecture-Third-Jason-Gregory/dp/1138035459/ref=sr_1_3?s=books&ie=UTF8&qid=1539093840&sr=1-3&keywords=game+engine

​

I have heard that this book is the actual implementation of a game engine and a good follow up to reading game engine architecture:

https://www.amazon.com/SFML-Development-Example-Raimondas-Pupius/dp/1785287346/ref=sr_1_1?s=books&ie=UTF8&qid=1539093789&sr=1-1&keywords=SFML

https://www.amazon.com/Mastering-SFML-Development-Raimondas-Pupius/dp/178646988X/ref=sr_1_2?s=books&ie=UTF8&qid=1539093813&sr=1-2&keywords=SFML

​

Then I was going to start diving into the 3D and mathematics

Read first:

https://www.amazon.com/Math-Primer-Graphics-Game-Development/dp/1568817231/ref=sr_1_1?ie=UTF8&qid=1539094027&sr=8-1&keywords=3d+math

Read next:

https://learnopengl.com/

Then I was just going to try and build my own 3D engine and figure it out as I went along.

I've also heard that implementing actual siggraph papers is super helpful and once you're at that point, you've kind of arrived as far as graphics programming is concerned.

I think what you're experiencing with the analysis paralysis is very normal. I'm going to say that you have this fear because you're thinking about all the things you're going to have to do and it freaks you out. Don't think about all the books and all the work you're going to have to do to reach your destination. Simply sit down each day and work on something. Just improve upon what you did the day before and have a weekly goal or something in mind. This breaks up what you're trying to accomplish into smaller steps and isn't nearly as intimidating. Don't look at everything on the horizon. Just start writing code.

John Carmack said it best when he gave someone advice on becoming a programmer "You should write hundreds of programs".

Link: http://d3dvortex.blogspot.com/2005/07/programming-advice-from-john-carmack-i.html

​

​

​

​

​

u/vingt-2 · 2 pointsr/GraphicsProgramming

Computer Graphics is a very broad field. There are subfields, such as the various types of rendering, animation, physically based animation, computational fabrication, human computer interaction and so on... It even has a very blurry interface with robotics !

What I understand you are interested in is a summarized theory of real-time rendering techniques.
Unfortunately, I don't know of any good book, besides RTR (which is awfully outdated) that will go through it all in details, up to how games do rendering these days. What I found particularly confusing when I started learning, is that nothing is really ever told as a story, but rather a multitude of short novels, and for that GPU PROs are the absolute best, written by the absolute best in the industry.

What should really help you, is to ramp up on the mathematics behind game rendering, as that is the absolute core that will unlock everything.
For that, this book should be very helpful.

edit #38:
What I would really suggest is you commit on buying RTR in August and in the meantime less legal way to access that knowledge online. Not that the previous suggestions still stand as RTR will not teach you all you need to learn in enough details (imho).

u/phatgreen · 2 pointsr/GraphicsProgramming

https://www.youtube.com/user/ChiliTomatoNoodle/playlists

That guys youtube channel has DirectX 11 C++ tutorials. He has a beginner series, intermediate, and advanced. He still adds to the advanced occasionally, like SSE explanations and so on.

His videos are long, you really get to know him and his personality. His beginner videos teach you C++ too, he doesn't expect you to know anything going in. He swears fairly often, I thought it was funny back in high school when I watched these, but others might not.

These videos are where I started from in the very beginning, and I wouldn't be where I am programming wise if it weren't for Chilli. He has allowed me to educate myself on my own time, for free. After I had done the beginner and intermediate tutorials I went and read this.

http://www.amazon.com/Introduction-3D-Game-Programming-DirectX/dp/1936420228

That will teach you the basics of 3D Programming.

http://www.amazon.com/Practical-Rendering-Computation-Direct3D-11/dp/1568817207

And that will teach you how to really understand the pipeline. Both books have their merits and both have very useful information for someone learning all this stuff. I'm currently making my own 3d game engine at the moment, so that's what understanding the information above can do for you. Takes time, though.

u/Aeiorg · 1 pointr/GraphicsProgramming

1 ) Real-time rendering is the go-to bible for every graphic programmer. It's starting to get pretty old tho but still relevant. Then you have a lot of different books for different topics, like Real-time shadows, VR, etc. In fact what you are looking for is a Computer Graphics course/book, not an OpenGL one (or you can try OpenGL SuperBible). OpenGL is a tool (you can learn this one, or DirectX, or Vulkan ...), Computer Graphics is the science ( you learn it one time, and you use an API to apply it). You have tons of books for computer graphics, some are more into mathematics , some are more into specifics techniques, etc

2 ) OpenGL is just an API, it doesn't do anything in itself. Therefore, "the rest" is just a superset of functions that passes data differently on GPU and give you more control of your app. If you want to begin to understand why/how OpenGL is evolving, you can have a look at this supa great talk

Have fun learning !

u/Tezza48 · 1 pointr/GraphicsProgramming

Look for Beginner OpenGL or DirectX11 tutorials, Follow them to a t, work from there.

I learned a little GL from some random tutorials and then by watching this series.

I first jumped into Graphics and got a real understanding of what was happeneing form this book Learning from a book is a really good idea, Video tutorials can have a number of bad practices.

Once you understand the basics then ask questions about Ambient Oclusion, LightMaps, Cubemaps, Reflection.... all maps, baking(map thing) and other stuff. I would say knowing C++ is a good idea however you can do this stuff in C# and Java as well asa number of other languages. Also, have a look at Makin Stuff Look Good In Unity to get a good intro to shaders without having to write a renderer from scratch.

u/VertexSoup · 5 pointsr/GraphicsProgramming

> don't make games. Implement complex rendering tech.

Great advice, this mirrors my experience.

>I though I was pretty good so I switched to Vulkan, which absolutely kicked my ass. It took me about a year to get back comfortable with Vulkan, during which I learned a ton about the intricacies of modern GPUs.

Same, but with D3D12 for me. A low-level API for the graphics pipeline and Professional CUDA Programming for the compute side is a great combination.

u/apfelstrudel · 2 pointsr/GraphicsProgramming

And I wanted to mention two books (for people who are interested) that so far are my favorite for 3D programming:

[Essential Mathematics for Games & Interactive Applications](
https://www.amazon.com/Essential-Mathematics-Games-Interactive-Applications/dp/1482250926/ref=sr_1_1?s=books&ie=UTF8&qid=1497612572&sr=1-1&keywords=essential+math+for+computer+games) by Van Verth and Bishop. I have the second edition and am very happy about the level of detail and perspective on the topics it covers.

The other book that changed my perception of how to do modeling and rendering is Texturing and Modeling: a procedural approach by Ebert, Musgrave, Perlin & al. This book has chapters on noise and signal that have no equivalent, and also makes it easier to understand where GLSL is coming from (as well as getting familiar with Renderman shaders).

u/soundslikeponies · 2 pointsr/GraphicsProgramming

Real-time: you'll be using an API such as OpenGL or DirectX. The first 400 or so pages of this book serve as a good introduction to real-time rendering with OpenGL. The rest of it serves as a good intermediate lesson.

In real-time graphics you mostly use an API to put data (position, UV mapping, surface normals, etc) into buffers which are sent to the GPU. You then write shader programs (vertex shader, pixel shader) which run on the GPU, process the data from the buffers, and output a result. That's a the basic summary of an update loop.

Non-real-time: you can write a ray tracer or other kinds of image-producing graphics programs from scratch. Ray Tracing in One Weekend is cheap and I've heard it's a pretty solid starting point. It also has sequels if you decide you want to take things further.

A ray tracer essentially sends out a ray for each pixel of the screen. You check to see if this ray collides with any surfaces, calculate the color at the location of that collision, then set that as the pixel's color.

You can also look at image processing, as an alternative to 3D computer graphics. A lot of image processing is signal processing, similar to audio, but on a 2D plane. Filters, edge detection, image manipulation or generation can be pretty interesting topics.

u/corysama · 2 pointsr/GraphicsProgramming

Nope. I'm Cory. (Check the comment at the top of the file.) Paul has been nice enough to host the code I posted to comp.graphics.algorithms for 20-something years now. Since then, I've watched it evolve through generations of people copying, pasting and editing it over and over.

So, I guess I read too much into the code below. It's neat that we ended up with such similar implementations. I didn't read the original Lorensen and Cline paper. I learned the technique from Foley & van Dam. But, F&vD's implementation was much more manually unrolled, so it didn't have this technique.

static const float offs[][3] = {
{0.0f, 0.0f, 0.0f},
{1.0f, 0.0f, 0.0f},
{1.0f, 1.0f, 0.0f},
{0.0f, 1.0f, 0.0f},
{0.0f, 0.0f, 1.0f},
{1.0f, 0.0f, 1.0f},
{1.0f, 1.0f, 1.0f},
{0.0f, 1.0f, 1.0f}
};

for(i=0; i<8; i++) {
p[i][0] = pos[0] + sz[0] offs[i][2];
p[i][1] = pos[1] + sz[1]
offs[i][1];
p[i][2] = pos[2] + sz[2] offs[i][0];

val[i] = ms->eval(ms, p[i][0], p[i][1], p[i][2]);
}
process_cube(ms, p, val);

vs

//a2fVertexOffset lists the positions, relative to vertex0, of each of the 8 vertices of a cube
static const GLfloat a2fVertexOffset[8][3] =
{
{0.0, 0.0, 0.0},{1.0, 0.0, 0.0},{1.0, 1.0, 0.0},{0.0, 1.0, 0.0},
{0.0, 0.0, 1.0},{1.0, 0.0, 1.0},{1.0, 1.0, 1.0},{0.0, 1.0, 1.0}
};

GLvoid vMarchCube1(GLfloat fX, GLfloat fY, GLfloat fZ, GLfloat fScale)
{
//Make a local copy of the values at the cube's corners
for(iVertex = 0; iVertex < 8; iVertex++)
{
afCubeValue[iVertex] = fSample(fX + a2fVertexOffset[iVertex][0]
fScale,
fY + a2fVertexOffset[iVertex][1]fScale,
fZ + a2fVertexOffset[iVertex][2]
fScale);
}

u/Daganar · 7 pointsr/GraphicsProgramming

.FBX is one of the most used formats in the industry, what usually happens is the artists output their work into .FBX files and either the engine loads it directly, or will convert it to a proprietary format that's most efficient for their engine. Unfortunately information on .FBX is not publicly available so you have to use their SDK.
http://usa.autodesk.com/adsk/servlet/pc/item?siteID=123112&id=10775847
http://docs.autodesk.com/FBX/2014/ENU/FBX-SDK-Documentation/

.OBJ is not a suitable format for animation it's only good for defining meshes and materials. A very good library that removes all the hassle of format loading is Assimp: http://www.assimp.org/

Lastly, animation formats don't store individual vertex positions, it will store matrix transformations. It's worth looking into how animation is done, I don't have any links but I would recommend looking at the following books:

https://www.amazon.co.uk/d/Books/Game-Engine-Architecture-Jason-Gregory/1568814135

https://www.amazon.co.uk/Game-Coding-Complete-Mike-McShaffry/dp/1133776574

u/RichieSams · 1 pointr/GraphicsProgramming

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.

u/aivenhoe · 2 pointsr/GraphicsProgramming

I can give you a book recommendation. Although not the newest book around, I still think it explains very understandable probably most of the topics you are interested in. You can follow the books line or you can just look up things.

have fun

u/nicolasgz · 4 pointsr/GraphicsProgramming

These books might be of interest:

Polygon Mesh Processing

u/the_grandmaster789 · 2 pointsr/GraphicsProgramming

My first though was to take a look at the Virtual Terrain Project (http://vterrain.org/). I'm not sure if it's up to date, but it does have a *lot* of information on that subject.

As for books, I recall that "Texturing and Modeling: a procedural approach" (https://www.amazon.com/Texturing-Modeling-Third-Procedural-Approach/dp/1558608486) has a chapter or two dedicated to vegetation

u/Clayman8000 · 2 pointsr/GraphicsProgramming

The sequel to ray tracing in one weekend has a chapter on sub surface scattering that is very easy to grasp. https://www.amazon.ca/Ray-Tracing-Next-Week-Minibooks-ebook/dp/B01CO7PQ8C

u/SouthernArrowwood · 2 pointsr/GraphicsProgramming

Real Time Rendering was recommended to me by a few professional graphics devs when I asked them the same question. This is NOT a light read, and it won't tell you how to use a specific API (DirectX, OpenGL), but it will give you the foundations to better understand an entire graphics pipeline and the various techniques used.

Other posters have mentioned starting with a software rasterizer. I'd highly suggest this as it helped me a lot when I had to do a very small one in college. There is a more recent version that is likely better(haven't looked yet), but this is the book we used and it can be picked up for dirt cheep!

u/vertexmachina · 5 pointsr/GraphicsProgramming

3D Math Primer for Graphics and Game Development is a great introduction to 3D math. It presents everything in a very approachable way (rather than a very rigorous mathematical way).

If you want to dive even deeper after that one, a good supplementary text is Essential Mathematics for Games and Interactive Applications. It goes deeper into the topics, but it isn't quite as approachable, so it's a good follow-up.

u/mickbeaver · 2 pointsr/GraphicsProgramming

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?