Anyone who has experimented with Qt QML and 3D OpenGL, I am interested in 2 frameworks I've read about, but it is not clear to me if in fact they are the same framework. The most interesting of the two is outlined in this Qt Developer Days 2013 video presentation by Krzysztof Krzewniak:
http://www.youtube.com/watch?v=29wCpA0DBZI
While very interesting, unfortunately I cannot find anywhere else online some source code for this, or even the name of the framework discussed.
There is QtQuick3d:
http://doc.qt.digia.com/qt-quick3d-snapshot/
However, I cannot tell if in fact this is describing the same framework from Dev Days or if they are separate (and apparently somewhat similar) frameworks? My initial look at the API in comparison to the video suggests they are different, which seems rather redundant to have 2 significant projects in the Qt community attempting to do the same thing.
Can anyone with some knowledge in this area of QML provide some pointers here?
Right, so let us start with some history behind...
Qt was initially a 2D framework for rendering computer graphics UI for simple desktop applications.
Qt3D was developed earlier than qml became mature as an extension to the 2D world provided by the QtGui module, or even QtOpenGL.
It was a 3D Qt api for rendering 3D content on the screen. It had different aspects to deal with 3D objects, build them, put them on the screen, compute intersection, and so on.
The idea was to bring easy to create application concept into Qt rather than always going through QtOpenGL or lower-level API for creating games, simulators, cad applications, and so on.
Right, when QML came out and kept maturing, the Qt3D contributors in Brisbane thought that it would be nice to put a QML API on top of the existing Qt3D C++ API for easy use in QML application. That is how we come to QtQuick3D.
When Nokia decided to shut the Brisbane office done, the Qt3D module pretty much became unmaintained and abandoned only getting a few bugfixes from the community every now and then.
There is some work in progress by KDAB to re-architecture and re-design the module, but it is not mature yet, and it can be found in a separate branch.
The video you are referring to is not dealing with the unmaintained Qt3D module. Rather, it tries to build 3D based on the new scene graph introduced in Qt. Since, there is no Qt3D module working nicely with the new SG in Qt 5, people become pragmatic and move on. That is what you see in the video.
Now, as you can see this is not quite a duplication, but... In the future, the new Qt3D architecture might be acting better with the new scene graph. In fact, KDAB has put a lot of effort into bringing the OpenGL support into QtGui up to real world.
That was the foundation for the Qt3D module which will probably be used in the future (hopefully) by 3D applications written based on Qt, but in the meantime... the video shows how to build hardware accelerated 3D UI based on what we have today.
These two 3d libraries are not the same, you are correct.
There is plenty of reference information you've already linked to online regarding Qt3d 1.0 and QtQuick 3d which are similar and related.
The OpenGL work in the video presentation is something much newer. It is directly laid on top of the QSceneGraph and QQuickWindow functionality.
My recommendation is to not use the approach in this video or the Qt3d/QtQuick3d library. Instead, wait for the KDAB to finish Qt3d 2.0 (which may already be out, you should check). Qt3d 2.0 is a full library for QML that will let you do what is demonstrated in this video.
(http://qt-project.org/wiki/Qt3D-wip-newapi-Overview, http://prezi.com/u-ewejoqxqj2/qt3d-20/)
There are quite a lot of outdated info floating around wikis, and finding useful info and a non-obsolete repository was a pain. So here's what I learned a few months back:
The correct and, as far as I know, the only currently valid git repo is this:
git://gitorious.org/qt/qt3d.git
The "There is some work in progress by KDAB...not mature yet...found in a separate branch." paragraph of Laszlo Papp's answer seems to refer to wip/newapi branch, while master branch seems to be maintained in compilable state (meaning, I have been able to compile it the few times I've tried, YMMV). Master branch should be fine for playing around with Qt3D, but looks like API is going to change.
I played with it a few months ago on Windows 8.0, the MinGW toolchain that is installed with SDK, and using native full OpenGL drivers (which I had to fetch from ATI web site for my card, default Windows drivers are not enough). And looks like it has not broken to bit rot, an example still built and I have a moon rotating on this screen.
It has README file, which will tell you how to build it, starting with building Qt5. Here another good link for that, since the qt3d README is not very comprehensive. And if you're on Windows, just skip Webkit and its deps, unless you really need it, because those extra deps can be a bit of hassle.
Related
My situation
I want to build a cross platform application, with a gui, that displays a 3d view of some simple cubes, that the user can interact with. Qt seemed like a good tool for the job and I think I have the gui part sufficiently down for the most part. For the 3d part OpenGl or the qt/3d implementation seemed like the right tool, but it does not work. When I try to run the examples from Qt, that use a 3d view, they are unstable, they crash, show a black window and on the offchance, that I find one, that does work there is aggressive flickering and my entire system becomes unresponsive when I only try to resize it. I don't know what is wrong, I don't think I can do a better job, than the official examples and I don't think, that trying to debug the examples is the way to go. (If someone has an idea how to fix this tell me, but I don't even have an error message)
My question:
Is there a simple framework, that would allow me to display simple 3d shapes and include that in a Qt application. I don't need shadows, or reflections or transparency or anything more fancy, than ambient light. Just some solid coloured boxes I can rotate and click on. I think it would even be fine, if it ran on CPU rather than GPU. It would be nice, if I could keep using C++, but if it only exists in another language, what gives. I don't really want to build a framework from scratch. How could I include such a foreign framework in Qt?
I am using ubuntu 20.04 with intel graphics, but as I said, I want the resulting application to work on as many platforms as possible.
I am working on an application that uses Qt3D with then OpenGL renderer. Deploying the app to a handful of users, I found some severe issues with Intel Integrated Graphics, ranging from crash to rendering bugs like flickering. This unfortunately doesn't comes from Qt or OpenGL itself but more from how Intel implements their OpenGL drivers.
The crash bug seems to impact older intel chips, very few references of that apart some random minecraft FAQ on reddit: https://www.reddit.com/r/Minecraft/comments/48ktct/19_faqs/
But what is claimed there seem to align with what my users are experiencing.
The flickering bug has only been reported recently and I unfortunately don't have the right hardware to replicate it yet...
I know it's like random, not sourced information but I thought that personnal experience might help.
I used osgQt many years ago. It looks active still. I know the military likes them.
https://github.com/openscenegraph/osgQt
I have a project that involves OpenCV among some other media related functionality and after playing with OpenFrameworks it seems to be perfect for the task, well nearly perfect ;)
This project is actually a Flash project and I have a working connection to C++ for all the image processing for speed. The problem is that OpenFrameworks require the following code to init before the ofRunApp:
ofAppGlutWindow window;
ofSetupOpenGL(&window, 1024,768, OF_WINDOW); // <-------- setup the GL context
Is there an easy way to use the OpenCV related functionality in OpenFrameworks without opening any window? Just for the record I would prefer to use OpenFrameworks rather than vanilla OpenCV for the flexibility of OF and it's other features.
Thanks in advance,
a.
There is no 'official' way to do this with openFrameworks.
Since openFrameworks has swappable renderers, you could write one to do this. But this seems to be a lot of work because many openFrameworks internal rely on a window and GL context.
You can find he most promising attempts to solve this problem here and here. Maybe you can search the openFrameworks on your own to find probably more. Even better: feel free to start a new topic to get people see that there is a need for headless rendering.
Besides Qt, GTK, wxWidgets... What are the recommendations for a cross platform, open source GUI framework library that works with OpenGL?
Its not quite a GUI framework. But GLFW is good for an OpenGL window with some extra features like keyboard and joystick handling.
I found the other framework I was looking for. It is SFML. I only used it briefly but I do remember liking it very much. It does contain a lot of nice extras going a step further than GLFW. If I recall correctly the documentation was stellar.
For a full featured cross-platform GUI framework I think you would be hard pressed to beat QT, GTK, or wx.
I'm not sure, but at a guess, the other framework mfperzel was trying to think of might have been fltk (the "fast light tool kit"). Where glfw is mostly an OpenGL window with some ability to read the mouse and keyboard, fltk is a GUI framework that supports OpenGL (but as the name implies it's still quite a bit smaller and faster than most GUI frameworks). I haven't tried it yet, but there's a new GUI builder program for it (FLUID) that looks fairly promising as well. One warning though: FLTK uses its own widgets, which tend to look at least a little foreign to most users.
I am exploring a possibility to write a kind of a notebook analogue that would reproduce the look and feel of using a traditional notebook, but with the added benefit of customizing the page in ways you can't do on paper - ask the program to lay ruled paper here, grid paper there, paste an image, insert a recording from the built-in camera, try to do handwriting recognition on the tablet input, insert some latex for neat formulas and so on. I'm pretty interested in developing it just to see if writing notes on computer can come anywhere close to the comfort plain paper + pencil offer (hard to do IMO) and can always turn it in as a university C++ project, so double gain there.
Coming from the type of project there are certain requirements for the user interface:
the user will be able to zoom, move and rotate the notebook as he wishes and I think it's pretty sensible delegate it to OpenGL, so the prospective GUI needs to work well with OGL (preferably being rendered in it)
the interface should be navigable with as little of keyboard input as user wishes (incorporating some sort of gestures maybe) up to limiting the keyboard keys as modifiers to the pen movements and taps; this includes tablet and possible multitouch support
the interface should keep out of the way where not needed and come up where needed and be easily layerable
the notebook sheet itself will be a container for objects representing the notebook blurbs, so it would be nice if the GUI would be able to overlay some frames over the exact parts of the OpenGL-drawn sheet to signify what can be done with given part (like moving, rotating, deleting, copying, editing etc.) and it's extents
In terms of interface it's probably going to end up similar to Alias' Sketch Book Pro:
picture.
As far as toolkits go I'm considering Qt and nui, but I'm not really aware how well would they match up the requirements and how well would they handle such an application.
As far as I know you can somehow coerce Qt into doing widget drawing with OpenGL, but on the other hand I heard voices it's slot-signal framework isn't exactly optimal and requires it's own preprocessor and I don't know how hard would be to do all the custom widgets I would need (say color-wheel, ruler, blurb frames, blurb selection, tablet-targeted pop-up menu etc.) in the constraints of Qt. Also quite a few Qt programs I've had on my machine seemed really sluggish, but it may be attributed to me having old PC or programmers using Qt suboptimally rather to the framework itself.
As for nui (http://www.libnui.net/) I know it's also cross-platform and all of the basic things you would require of a GUI toolkit and what is the biggest plus it is OpenGL-enabled from the start, but I don't know how it is with custom widgets and other facets and it certainly has smaller userbase and less elaborate documentation than Qt.
The question goes as this:
Does any of these toolkits fulfill (preferably all of) the requirements or there is a well fitting toolkit I haven't come across or maybe I should just roll up my sleeves, get SFML (or maybe Clutter would be more suited to this?) and something like FastDelegates or libsigc++ and program the GUI framework from the ground up myself?
I would be very glad if anyone had experience with a similar GUI project and can offer some comments on how well these toolkits hold up or is it worthwhile to pursue own GUI toolkit in this case.
Sorry for longwindedness, duh.
Have you tried FLTK? It is made with 3D graphics programming in mind and has interfaces to OpenGL. I wrote some FLTK->Scheme bindings and found the API to be real fun to work with.
OpenGL font support is terrible, in my experience. It sounds like you're going to have to develop all your own custom widgets anyway so don't even bother with a toolkit. You'll spend more time learning the toolkit, trying to figure out how to get that toolkit to work with OpenGL, and and trying to figure out how to make your special widgets in that toolkit than you will just rolling your own. I wouldn't give this advice in just any situation but it sounds like your application and your widget set is going to be very unique. Make a superclass for all widgets, define a draw method, even handler methods, etc., for override, and you've already done most of what those frameworks would do for you.
Also I'm sure you know this but this is an enormous project so you should initially narrow it down to a few simple objectives for a first iteration.
So, I'm going to develop a Pac-Man clone with Qt. The problem is that I do not really know where to start.
I quickly take a look at the documentation and some demo. I also downloaded some game sources on qt-apps.org. And it seems that there is a lot of ways to develop a game with Qt!
In your experience, which part of Qt should I consider to develop a Pac-Mac clone ?
The Animation Framework
The Graphics View Framework
The Paint System
Qt Declarative
Any help would be appreciated.
I think that QGraphicsView framework is the best way. Create a QGraphicsScene, some QGraphicsItems for the elements of the game. You have collision detection for free.
Most of KDE games are based on the QGraphicsView framework. It is a good fit for simple game development.
I'm currently working on a project providing gaming-specific Qt Quick Components for cross-platform game development, might be of interest: http://v-play.net :)
At the very minimum you will want to look at QGLWidget. You can get an OpenGL program up in a few minutes by deriving from QGLWidget, it will create the window, context, handle mouse and keyboard input, etc. Create a QTimer to trigger updateGL() every 10-15 ms or so and your good to go. I think there is a demo somewhere for setting this up, but it has been awhile since I saw it.
If you want to embed widgets into the window, I would look at QGraphicsView. There is a demo of this called boxes. Just beware the demo is a tad hard to learn from as several classes are thrown into the same file and it might take a few moments of tracing to figure out where the flow is.
Since you are doing a 2d game, you might want to look at using QPainter on top of OpenGL. This allows you to draw primitives easily instead of doing them with OpenGL calls. I never could get this to stop flickering in fullscreen though.
There's a book about game development in Qt here, it's a bit old, but it might give you some ideas. But IMHO, Qt is widget based and is a bit slow for a game, you might consider using SDL or OpenGL.
I'm developing a simulation of rigid bodies with Qt and OpenGL using the PhysX API from Nvidia. If you want to see this approach, look at my project at github: http://github.com/lucassimao/Simulacao-Estereologica
Well, one place to look could be the Gluon game development framework, which is currently under development. It depends on what you're really aiming for with your PacMan clone, but Gluon may well be what you're after: https://github.com/KDE/gluon
If anyone else is interested in learning how to make GAMES using C++ and Qt, have a look at my YouTube tutorial series. It explains the graphics view framework through a series of videos which build upon a single game that we start in tutorial 1.
C++ Qt Game Tutorial 8 - Adding Graphics
If you are not comfortable with Qt yet, then I REALLY loved VoidRealm's Qt tutorial series, also on youtube (C++ Qt 1 - Introduction to QT programming).
A good start would be:
Qt Examples And Tutorials
Perhaps if you need to cheat you may want to look here
xpacman.tar.gz