I can't give you a direct comparison between C# and DirectX vs. C++ and OpenGL. I have never programmed in C# and my DirectX skills date back to version 7 and 8. But, I have used C++ and OpenGL extensively.

One of the most useful things about OpenGL in academia is that it uses a right-handed coordinate system vs. DirectX using a left-handed one. Most textbooks and formulas you'll find in computer graphics use right-handed coordinate systems. Furthermore, OpenGL will help you to get your software platform independent. You will only need a library to handle operating system specific parts (like windows and input). There are some special libraries for this just for OpenGL, but I prefer Qt for this purpose. As long as your licensing allows it I strongly suggest to use Qt. It will help to setup the correct OpenGL context and in version 5 it will also take the burden of loading certain OpenGL extensions off you.

Here, you see the problem: with DirectX and C# you are restricted to Windows and will certainly use Microsoft's own libraries for other things as well. (That is a point for DirectX and C#.) If you are using OpenGL there is a plethora of other options and there is definitely no single specific way how to do things or which library to choose. This will make it harder to find a good solution based on internet searches. I guess that in academia most people prefer Unix-based operating systems for application development. That is mostly why they are choosing OpenGL and C++ because DirectX and C# are not available on those platforms.

Now, here's the downside of using OpenGL and C++: Although the most current OpenGL version compares quite well with DirectX (using modern GPU features) most of the time your driver will not support this version (especially with Linux). This will probably change in the near future as Valve is pushing Steam onto Linux. Depending on supporting libraries it might be quite tedious to use features of newer OpenGL versions as you have to specify and load these features through extensions. Since you are using DirectX wrappers I guess that you are not working very close to the metal. In this case you will be fine. You might even try out some scene graph libraries.

As for C++: I really like C++ as a programming language and it really got better with the new 2011 standard. But coming from C# there will be some language features that you will miss with C++. Especially since C# is tightly integrated with the .NET framework you will miss many library functions. Again, I advise you to have a look at Qt. It will not solve all your problems, but is a good start. If you need some advanced data structures have look at the Boost libraries as well. You might even find things that you have missed with the .NET framework.

The advantages of OpenGL and C++? There aren't so many. First of all, both are open standards. Some people hate closed standards because they prevent certain developments. Then, there is portability. But, this is only an advantage if it is of concern to you. Another one is nice integration of OpenGL with OpenCL (which is also portable and does not only work with GPUs) if this is of interest to you. The advantage of C++ over C#? You can choose your compiler...

You see that my points for C++ and OpenGL are almost desperate. But nevertheless, I really like C++ and will never switch away from C++ and OpenGL. Certainly not to C# and DirectX. But this is only personal preference.

I agree with Simon. The portability is very interesting for academic purposes! Furthermore, you will find many others researchers that use the combo C++ with OpenGL, and the change of experience will be easier.

For other options, I've been investigating using iPython with Anaconda and notebooks. It appears to be rather powerful tool for collaborative research and science presentation.

http://ipython.org/install.html

Here's another opinion, I use DirectX (and SharpDX) because of the development environment. My focus is on 3D Interaction so the implementation part is often "just" key to something else such as user studies and the eventual paper writing. Thus, implementation speed is of paramount importance. One day lost hunting arcane C++ pointers is one day gained for writing the paper. Furthermore, DirectX has the advantage of being actively in development (DX 11.2 having just been announced) and has been revolutionised many times so it feels more "modern".

If you already know C# and DirectX then unless speed is a critical factor, I'd stay with DX otherwise you'll have to start over. Plus, DirectX is also used in academic contexts. I don't really think that Microsoft Research uses OpenGL :D

In the end it's a matter of opinion and personal preference..:)

Adalberto, I would guess that more people are using OpenGL in the academic environment. In many cases the reason is money: Linux+GCC+OpenGL is a lot cheaper than Windows+Visual Studio+DirectX. This is especially true a few years ago.

Concerning pointers in C++: That would be on you if you were hunting pointers a lot. I haven't had a problem with pointers in years. Mostly not because I'm experienced programmer, but because there is rarely a reason to use pointers (other than in the same way as references). I use 'new' and 'delete' almost only in constructors and destructors which makes it really save. Still I would agree that in some areas C# is superior. But in other areas C++ has the nicer solution.

It also seemed like you were implying that OpenGL is not under active development. Actually, OpenGL has been under constant development. In the past they have been really slow, but during the last couple of years they caught up to DirectX. From time to time you'll even find features in OpenGL that did not make their way into DirectX (yet). This is because every graphics cards manufacturer can add own extensions to OpenGL and some of them are eventually made a standard. DirectX on the other hand has only the features that Microsoft likes to include.

So the OpenGL standard is as "modern" as DirectX. The only problem are drivers. Those are not always up-to-date. I don't see that as a real problem when your area of research is visualization and not graphics cards. I guess there is no true advantage of C++&OpenGL over C#&DirectX or the other way around.

I am founding very interesting the use of Qt with OpenGL (GLSL). Details can be found on this tutorial:

@INPROCEEDINGS{6382715,

author={Gois, J.P. and Batagelo, H.C.},

booktitle={Graphics, Patterns and Images Tutorials (SIBGRAPI-T), 2012 25th

SIBGRAPI Conference on},

title={Interactive Graphics Applications with OpenGL Shading Language and Qt},

year={2012},

pages={1-20},

doi={10.1109/SIBGRAPI-T.2012.10},

url = {http://professor.ufabc.edu.br/~joao.gois/uploads/Courses/opengl_glsl_qt_gois_batagelo.pdf}

}

If you happen to like .NET framework, you could try the Mono framework, as that runs on Linux and OSX too. I'm a Mac user, so I avoid Windows-specific libraries and toolkits. It is put to real good use in Unity, a game authoring system, with integrated C# and Javascript scripts. The results can be published on almost any platform (Windows, OSX, Linux, iOS, Android, Windows Phone, …). The game authoring environment, though is limited to Windows and OSX.

I find OpenGL and C++ to be a bit better for your implementation. OpenGL is a bit more easily implemented if you're programming right from a textbook, and because of its openness it is compatible across all platforms and a much less expensive solution than the DirectX which costs more and binds you to microsoft libraries.

Sorry I can't understand how DirectX "costs" more. I am far from being related to Microsoft in any way, mind you.

What costs are you referring to? I am using SharpDX which is an open-source project. Is Visual Studio the cost? There are free alternatives like Visual C# Express, SharpDevelop or MonoDevelop. Mono especially opens you the possibility of targeting other operating systems.

Yes Windows is not free, but it can be used for other purposes too! :D

Adalberto, agreed about SharpDX and the open source alternatives to Visual Studio, but I still feel that the OpenGL would be a better fit for publishing research and the collaboration found in the academic setting. Since OpenGL doesn't really depend on any particular language features it can be called by a much larger range of programing languages which in my opinion makes it a bit more suitable for academia where so many students come in an out all with different programing backgrounds and strengths/weaknesses.