Using Direct3D with Qt

One day, I had the need to use Direct3D with Qt. After several days of searching the Internet, I found just some scraps of information. There was no complete description of the mechanism for using Direct3D anywhere. As a result, after much research, I achieved what I wanted :)

Under the cat there is an instruction “approaching“ Direct3D and Qt, as well as a widget code that can be used as is



When writing this article, the following tools were used:

1. Qt 4.5.0
2. VS2008 SP1
3. DirectX SDK August 2008

If you use another. IDE, the assembly time will be slightly different. I give an example of the assembly, only for VS2008. If you are sure that your build has direct3d engine support, then skip the Qt configuration and build step.

Qt configuration and build

• The first step is to set up environment variables for DirectX, for this we run the following command in the console:
  
  > "% DXSDK_DIR% \ Utilities \ Bin \ dx_setenv.cmd“
• 
  
  Go to the Qt directory and configure it. In my case, it looked like this> configure -direct3d -platform win32-msvc2008
  
  -direct3d can be omitted, this parameter must be calculated by the configurator.
  
  If everything went well, then the configurator's output will appear: Direct3D support ... yes
  
  
  
  
• We do nmake, and if there are no problems, then we wait for the end of the assembly. I ran into a problem, during the build there was an unresolved external Direct3D related error. To fix it, go to % QTDIR% \ src \ gui \ and in both Makefiles (release and debug) change dxguid.lib to "% DXSDK_DIR% \ Lib \ x86 \ dxguid.lib" (or x64, depending on , under what platform you are collecting). After this, the problem should disappear, so we wait until the end of the assembly.

Widget code

Direct3DWidget.h

1. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif
2. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif
4. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif
5. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif
6. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif
8. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif
9. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif
10. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif
12. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif
13. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif
14. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif
15. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif
16. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif
17. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif
18. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif
19. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif
20. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif
21. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif
22. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif
24. #ifndef DIRECT3DWIDGET_H #define DIRECT3DWIDGET_H #include <QtGui/QWidget> #include <d3d9.h> #include <atlbase.h> class Direct3DWidget : public QWidget { Q_OBJECT CComPtr < IDirect3D9 > m_pD3D ; CComPtr < IDirect3DDevice9 > m_pd3dDevice ; public : Direct3DWidget ( QWidget * parent = 0 ) ; ~Direct3DWidget ( ) ; bool InitDirect3D ( ) ; public slots : bool Rendering ( ) ; private : void paintEvent ( QPaintEvent * pEvent ) ; } ; #endif

')

Direct3DWidget.cpp

1. #include "Direct3DWidget.h"
3. Direct3DWidget :: Direct3DWidget ( QWidget * parent / * = 0 * / ) : QWidget ( parent )
4. {
5. setAttribute ( Qt :: WA_PaintOnScreen ) ;
6. }
7. Direct3DWidget :: ~ Direct3DWidget ( )
8. {
9. }
10. bool Direct3DWidget :: InitDirect3D ( )
11. {
12. m_pD3D = Direct3DCreate9 ( D3D_SDK_VERSION ) ;
13. if ( ! m_pD3D )
14. return false ;
15. D3DPRESENT_PARAMETERS d3dpp = { 0 } ;
16. d3dpp. Windowed = TRUE ;
17. d3dpp. SwapEffect = D3DSWAPEFFECT_DISCARD ;
18. d3dpp. BackBufferFormat = D3DFMT_UNKNOWN ;
19. d3dpp. FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT ;
20. d3dpp. PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE ;
21. d3dpp. SwapEffect = D3DSWAPEFFECT_DISCARD ;
22. d3dpp. EnableAutoDepthStencil = TRUE ;
23. d3dpp. AutoDepthStencilFormat = D3DFMT_D16 ;
24. HRESULT hrResult = m_pD3D -> CreateDevice ( D3DADAPTER_DEFAULT , D3DDEVTYPE_HAL , winId ( ) ,
25. D3DCREATE_HARDWARE_VERTEXPROCESSING ,
26. & d3dpp , & m_pd3dDevice ) ;
27. if ( FAILED ( hrResult ) )
28. return false ;
29. return true ;
30. }
31. bool Direct3DWidget :: Rendering ( )
32. {
33. if ( m_pd3dDevice == 0 )
34. return false ;
35. m_pd3dDevice -> Clear ( 0 , 0 , D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER , D3DCOLOR_XRGB ( 255 , 255 , 0 ) , 1.0f , 0 ) ;
36. if ( SUCCEEDED ( m_pd3dDevice -> BeginScene ( ) ) )
37. {
38. m_pd3dDevice -> EndScene ( ) ;
39. }
40. m_pd3dDevice -> Present ( 0 , 0 , 0 , 0 ) ;
41. return true ;
42. }
44. void Direct3DWidget :: paintEvent ( QPaintEvent * pEvent )
45. {
46. Q_UNUSED ( pEvent ) ;
47. Rendering ( ) ;
48. }

Example of use:

1. #include <QtGui / QWidget>
2. #include <QtGui / QApplication>
3. #include <QtGui / QHBoxLayout>
4. #include "Direct3DWidget.h"
6. int main ( int argc , char * argv [ ] )
7. {
8. // ------------------------------ Start initialization
9. // Additional parameters, just add a parameter separated by comma
10. std :: string aAdditionalParameters [ ] = { "-direct3d" } ;
11. int iRealArgumentAmount = argc + sizeof ( aAdditionalParameters ) / sizeof ( std :: string ) ;
12. // This double pointer will contain parameters from argv and
13. // statical parameters which necessary for this application
14. char ** pArguments = new char * [ iRealArgumentAmount ] ;
15. // Copy all source (from the command line) parameters
16. for ( int i = 0 ; i < argc ; ++ i )
17. {
18. * ( pArguments + i ) = new char [ strlen ( argv [ i ] ) + 1 ] ;
19. strcpy ( * ( pArguments + i ) , argv [ i ] ) ;
20. }
21. // Append parameters we want to add
22. for ( int i = argc , j = 0 ; i < iRealArgumentAmount ; ++ i , ++ j )
23. {
24. * ( pArguments + i ) = new char [ aAdditionalParameters [ j ] . size ( ) + 1 ] ;
25. strcpy ( * ( pArguments + i ) , aAdditionalParameters [ j ] . c_str ( ) ) ;
26. }
27. QApplication xApplication ( iRealArgumentAmount , pArguments ) ;
28. for ( int i = 0 ; i < iRealArgumentAmount ; ++ i )
29. delete [ ] * ( pArguments + i ) ;
30. delete [ ] pArguments ;
31. // -------------------------------- Initialization complete
32. QWidget xMainWindow ;
33. Direct3DWidget * xScene = new Direct3DWidget ( & xMainWindow ) ;
34. QHBoxLayout * xMainLayout = new QHBoxLayout ;
35. xMainLayout -> addWidget ( xScene ) ;
36. xMainWindow. setLayout ( xMainLayout ) ;
37. // It is important to get the Direct3d after the widget
38. xScene -> InitDirect3D ( ) ;
39. xMainWindow. show ( ) ;
41. return xApplication. exec ( ) ;
42. }

The result of the execution of this code will be such a window (if you stretch it):





It would seem that now there is everything to calmly use direct3d with an excellent Qt framework, but, unfortunately, I discovered some pitfalls.

After I started using Direct3d, on some computers, instead of the picture drawn by Direct3d, there was a screen, painted with the background color. I went through all combinations of attributes, but I could not remove this defect. It was also not possible to identify the cause of the incorrect operation of the direct3d engine on some machines. Because Qt documentation states that “ This functionality is experimental. , Then we can assume that the matter is in the dampness of support direct3d.



But, this disadvantage can not be a reason for not using Direct3D :). While trolltech finishes direct3d to a stable state, you can use the following workaround:

Comment out the Rendering () call in paintEvent:

1. void Direct3DWidget :: paintEvent ( QPaintEvent * pEvent )
2. {
3. Q_UNUSED ( pEvent ) ;
4. // Rendering ();
5. }

and add the following code to the place of use:

1. ...
2. // It is important to get the Direct3d after the widget
3. xScene -> InitDirect3D ( ) ;
4. xMainWindow. show ( ) ;
6. QTimer xTimer ;
7. QWidget :: connect ( & xTimer , SIGNAL ( timeout ( ) ) , xScene , SLOT ( Rendering ( ) ) ) ;
8. xTimer. start ( 100 ) ;
10. return xApplication. exec ( ) ;
11. ...

I added this code to the code of the example I gave above.

Don't forget to include the QTimer header.



Enjoy your use of Direct3d API in Qt, and do not forget that the application should be launched with the -direct3d option, I have included this option in the code of my usage example.