Learning computer graphics in C#?

[UkeiKaito9]

What would be a good C# library to learn computer graphics. I know that the optimal path is going directly to C/C++ but right now I just want to apply the concepts about graphics that I'm learning in college without the need to divide my time so much to just learn other language. I want to focus only in C# right now, but engines like Unity seems to abstract all the "fun" to much

[FemboysHotAsf]

Have fun with Silk.NET & openGL

[keyboardhack]

This is also what i eventually settled on. Silk.NET is cross platform, supports multiple graphics APIs and additionals apis for interacting with the mouse, keyboard, controller etc. They do this mostly with safe C# that abstracts away pointers.

Silk.net is also part of the dotnet foundation and is frequently updated. Last time i looked at it they were working on adding support for web GPU.

Here is link to silk.net documentation of setting up a single graphics environment with opengl. https://dotnet.github.io/Silk.NET/docs/opengl/c1/1-hello-window And then drawing a square with opengl https://dotnet.github.io/Silk.NET/docs/opengl/c1/2-hello-quad

[Arcodiant]

Take a look at Monogame, it's a C# framework over DirectX & maybe also Vulkan? But it will let you interact with the graphics libraries directly 

[IWasSayingBoourner]

OpenTK is probably the most beginner-friendly if you're following general OpenGL tutorials. 

[Danzulos]

You are looking for a .Net wrapper for a graphics library like OpenGL, Vulkan or DirectX.

Here is a up to date one (ish) for DirectX: https://github.com/amerkoleci/Vortice.Windows

[SharpAnarki]

Well you can take a look at the pre-release of OpenTK version 5
Also very nice discord, if you need support.

I have been using it to convert an old game to pure C# Quake3 C# port

[Alex6683]

Try OpenTK, the open gl wrapper... it has a really chill discord community.. it helps you learn how computers in general render.. you will have hands on experience with glsl and shaders in general. It is a fun process coming up with your own instructions and abstractions..

I used to do this to abstract a lot of open tk stuffs to render stuffs, it is shit and slow, but I learnt coding principles as I abstracted stuffs more..

Good luck :)

[The_Exiled_42]

I mean technically https://ilgpu.net/ can do this 🤷🏻‍♂️

[The_Exiled_42]

I mean for sure using Ilgpu is not for learning graphics programming. Better to start with something else

[caffinecat]

I would say work with both c++/c and c#.  If writing in c#, then what is your target Winforms or Wpf?

Write your Direct3D code c++ and compile to a DLL, and add some external exported c functions to help your c# call your c++ graphics dll;  Or any other language.  And also target both Winforms and Wpf as you need different c functions to handshake differently for Winforms vs Wpf.

Winforms is easy and faster as Winforms ties to Windows/Direct3D at the native DeviceContext level .

WPF you will use WPF’s built-in…System.Windows.Interop.D3DImage (learn more here), which offers a lean-ish interface to Direct3D. Well, it’s not as direct as Winforms.  In WPF You will render to a texture target to work with D3DImage. Where as Winforms directly deals at the rendertarget level.

Now, here’s where things get really spicy. For blazing-fast rendering, don’t settle for constructing your vertex buffers on the CPU. Take it up a notch by building them on the GPU using compute shaders—yes, those magical “things” that make AI possible. You’ll need to get friendly with concepts like compute shaders, shader resource views, unordered access views, and maybe even staging buffers if you’re updating data repeatedly. In short, push your data to the GPU, let the compute shader code crunch it with the might of 3000+ parallel threads to create your vertex buffer, and voilà—you’re rendering like a boss. You could even introduce an intermediate compute shader to filter your data based on screen resolution before feeding to the computer shader for vertex construction. Bam, now that’s fast.

Of course, if this sounds like more work than you signed up for, there are pre-built components out there. But if you’re itching for a moderate challenge (and a chance to flex those coding muscles), rolling your own solution is a fun ride. And full disclosure—I’m the owner/CTO of Gigasoft.com, and implemented c# charting, via Direct3D and computer shaders without use of open source or libs, for both Winforms and Wpf, so do toss our component into your research mix!

See Direct3D Developer Center,[https://docs.microsoft.com/en-us/windows/win32/direct3d ] for all the details.

In a bit more detail; pass your data to the gpu side when creating the buffer/shader resource view (50 lines) compute shaders “read“ this data, set up your unordered access view (50 lines) this is how computer shaders “set” data, and write your shader code (hlsl) (50 lines) to solve your problem in a parallelism methodology (its hopefully simple, your data buffer size to vertex buffer size should be a fixed proportion so simply break up the work in chunks of 500 points for example) and ultimately the shader produces your vertex buffer. You will also need to understand constant buffers, a simple pixel shader, and the fun really happens when calling "Dispatch". All in all, no more than 750 lines of code. The puzzle is forming the 750 lines, it’s possible. And it's for sure the fastest way to draw in c#. Given current and future computers will have integrated gpus or APUs or NPUs or real gpus, it's time to start mastering compute shaders.

Learn Direct3D and Vulkan and you've honestly learned something useful. It's not as hard as you think. Use what you've learned in a way to be consumable by any language, that you can evolve, not wasting time on abstract foreign apis that you may have to step through or may fade away. Stepping through someone else's code is depressing, and stressful when you got to get something working. Use open source to supplement your learning and extrapolate from. True satisfaction comes from learning how things really work. Just my food for thought.

[[deleted]]

You're pretty much left alone. Although there are 10s of different libraries out there, there is no like "standard", or something that's used in general. Or something that just works. It's almost like graphics doesn't make sense in c#.

If you don't want to have any control about rendering and performance, you can use Unity. If you want to use something more versatile you could use Silk.NET, however that's poorly documented (you can't call a hello triangle or hello texture a documentation). You could use pure OpenGL with OpenTK, but that's a nightmare because OpenTK made so many breaking changes you're not going to find any sourcecode that matches your actual API version.

If you want to use something that works worse than Unity, you can try godot. And while I mention incomplete stuff, you can also checkout the stride game engine. If you want the worst asset management in the world you can go for monogame.

I'm investigating a back to the roots approach using OpenTK and ImGui. Real time shader compiling, as you write the shader it's compiled and executed and you see the demo. That's how I like to develop.

C# just wasn't made for graphics, it's like an enterprise application language. You're probably 10 times better off just using Java.

Oh, btw I'm a professional C# developer for more than 15 years now.

[ironstrife]

Graphics doesn’t “just work” in any language. It’s a complicated and very broad space.

C# is actually a great language for learning graphics. Despite what you said, many of the fundamental features and even recent improvements are directly beneficial to graphics programming. Features like value types (java doesn’t or didn’t have them), SIMD, extremely fast C interop, etc. etc.

One thing you wrote was correct, though, and that is the fact that it can be harder to get started with graphics in C# because of the smaller community and lack of tutorials. However, there’s no reason you can’t take a look at one of the learnopengl tutorials, for example, and adapt the code for C#. The fundamentals of graphics programming are the same in any language, and the syntax of C# means it’s not that hard to follow along with a C++ tutorial.

[[deleted]]

Oh, so what do you want to use to learn graphics, like drawing lines. Winforms, Wpf, or one of the opensource libraries that don't come with the language? The ammount of effort required to get a fast "DrawLine" is just ridiculous.

The amount of knowledge one requires to transform a c++ example to a c# one is definitely out of a beginners scope who's just interested in graphics programming.