wxWidget+osg

农民工学编程

1. #include <iostream>
   
2. #include <string>
   
3. #include <wx/wx.h>
   
4. #include <wx/glcanvas.h>
   
5. #include <wx/cursor.h>
   
6. #include <osgViewer/Viewer>
   
7. #include <osg/GraphicsContext>
   
8. #include <osgDB/ReadFile>
   
9. #include <osgViewer/ViewerEventHandlers>
   
10. #include <osgGA/TrackballManipulator>
    
11. 
    
12. class MyGraphicsWindow;
    
13. class MyCanvas : public wxGLCanvas
    
14. {
    
15. public:
    
16.         MyCanvas(wxWindow * parent, wxWindowID id = wxID_ANY, int * attributeList = 0);
    
17.         virtual ~MyCanvas();
    
18. public:
    
19.         DECLARE_EVENT_TABLE()
    
20. 
    
21.     void OnPaint(wxPaintEvent& event);
    
22.     void OnSize(wxSizeEvent& event);
    
23.     void OnEraseBackground(wxEraseEvent& event);
    
24. 
    
25.     void OnChar(wxKeyEvent &event);
    
26.     void OnKeyUp(wxKeyEvent &event);
    
27. 
    
28.     void OnMouseEnter(wxMouseEvent &event);
    
29.     void OnMouseDown(wxMouseEvent &event);
    
30.     void OnMouseUp(wxMouseEvent &event);
    
31.     void OnMouseMotion(wxMouseEvent &event);
    
32.     void OnMouseWheel(wxMouseEvent &event);
    
33. public:
    
34.         void SetGraphicsWindow(osgViewer::GraphicsWindow * gw);
    
35.         void UseCursor(bool value);
    
36. private:
    
37.         osg::ref_ptr<osgViewer::GraphicsWindow> _graphics_window;
    
38.         wxCursor _oldCursor;
    
39. };
    
40. 
    
41. MyCanvas::MyCanvas(wxWindow * parent, wxWindowID id, int * attributeList)
    
42.         :wxGLCanvas(parent, id, attributeList)
    
43. {
    
44.         _oldCursor = *wxSTANDARD_CURSOR;
    
45. }
    
46. 
    
47. MyCanvas::~MyCanvas()
    
48. {
    
49. 
    
50. }
    
51. BEGIN_EVENT_TABLE(MyCanvas, wxGLCanvas)
    
52.         EVT_SIZE                (MyCanvas::OnSize)
    
53.     EVT_PAINT               (MyCanvas::OnPaint)
    
54.     EVT_ERASE_BACKGROUND    (MyCanvas::OnEraseBackground)
    
55. 
    
56.     EVT_CHAR                (MyCanvas::OnChar)
    
57.     EVT_KEY_UP              (MyCanvas::OnKeyUp)
    
58. 
    
59.     EVT_ENTER_WINDOW        (MyCanvas::OnMouseEnter)
    
60.     EVT_LEFT_DOWN           (MyCanvas::OnMouseDown)
    
61.     EVT_MIDDLE_DOWN         (MyCanvas::OnMouseDown)
    
62.     EVT_RIGHT_DOWN          (MyCanvas::OnMouseDown)
    
63.     EVT_LEFT_UP             (MyCanvas::OnMouseUp)
    
64.     EVT_MIDDLE_UP           (MyCanvas::OnMouseUp)
    
65.     EVT_RIGHT_UP            (MyCanvas::OnMouseUp)
    
66.     EVT_MOTION              (MyCanvas::OnMouseMotion)
    
67.     EVT_MOUSEWHEEL          (MyCanvas::OnMouseWheel)
    
68. END_EVENT_TABLE()
    
69. 
    
70. void MyCanvas::OnPaint(wxPaintEvent & evnet)
    
71. {
    
72.         wxPaintDC dc(this);
    
73. }
    
74. 
    
75. void MyCanvas::OnSize(wxSizeEvent& event)
    
76. {
    
77.         wxGLCanvas::OnSize(event);
    
78.     int width, height;
    
79.     GetClientSize(&width, &height);
    
80. 
    
81.     if (_graphics_window.valid())
    
82.     {
    
83.         _graphics_window->getEventQueue()->windowResize(0, 0, width, height);
    
84.         _graphics_window->resized(0,0,width,height);
    
85.     }
    
86. }
    
87. 
    
88. void MyCanvas::OnEraseBackground(wxEraseEvent& WXUNUSED(event))
    
89. {
    
90. }
    
91. 
    
92. void MyCanvas::OnChar(wxKeyEvent &event)
    
93. {
    
94. #if wxUSE_UNICODE
    
95.     int key = event.GetUnicodeKey();
    
96. #else
    
97.     int key = event.GetKeyCode();
    
98. #endif
    
99. 
    
100.     if (_graphics_window.valid())
     
101.         _graphics_window->getEventQueue()->keyPress(key);
     
102. }
     
103. 
     
104. void MyCanvas::OnKeyUp(wxKeyEvent &event)
     
105. {
     
106. #if wxUSE_UNICODE
     
107.     int key = event.GetUnicodeKey();
     
108. #else
     
109.     int key = event.GetKeyCode();
     
110. #endif
     
111. 
     
112.     if (_graphics_window.valid())
     
113.         _graphics_window->getEventQueue()->keyRelease(key);
     
114. }
     
115. 
     
116. void MyCanvas::OnMouseEnter(wxMouseEvent &event)
     
117. {
     
118.     SetFocus();
     
119. }
     
120. 
     
121. void MyCanvas::OnMouseDown(wxMouseEvent &event)
     
122. {
     
123.     if (_graphics_window.valid())
     
124.     {
     
125.         _graphics_window->getEventQueue()->mouseButtonPress(event.GetX(), event.GetY(),
     
126.             event.GetButton());
     
127.     }
     
128. }
     
129. 
     
130. void MyCanvas::OnMouseUp(wxMouseEvent &event)
     
131. {
     
132.     if (_graphics_window.valid())
     
133.     {
     
134.         _graphics_window->getEventQueue()->mouseButtonRelease(event.GetX(), event.GetY(),
     
135.             event.GetButton());
     
136.     }
     
137. }
     
138. 
     
139. void MyCanvas::OnMouseMotion(wxMouseEvent &event)
     
140. {
     
141.     if (_graphics_window.valid())
     
142.         _graphics_window->getEventQueue()->mouseMotion(event.GetX(), event.GetY());
     
143. }
     
144. 
     
145. void MyCanvas::OnMouseWheel(wxMouseEvent &event)
     
146. {
     
147.     int delta = event.GetWheelRotation() / event.GetWheelDelta() * event.GetLinesPerAction();
     
148. 
     
149.     if (_graphics_window.valid()) {
     
150.         _graphics_window->getEventQueue()->mouseScroll(
     
151.             delta>0 ?
     
152.             osgGA::GUIEventAdapter::SCROLL_UP :
     
153.             osgGA::GUIEventAdapter::SCROLL_DOWN);
     
154.     }
     
155. }
     
156. void MyCanvas::UseCursor(bool value)
     
157. {
     
158.         if (value) {
     
159.                 SetCursor(_oldCursor);
     
160.         } else {
     
161.                 _oldCursor = GetCursor();
     
162. 
     
163.                 wxImage image(1, 1);
     
164.                 image.SetMask(true);
     
165.                 image.SetMaskColour(0, 0, 0);
     
166.                 wxCursor cursor(image);
     
167.                 SetCursor(cursor);
     
168. 
     
169.         }
     
170. }
     
171. 
     
172. void MyCanvas::SetGraphicsWindow(osgViewer::GraphicsWindow * gw)
     
173. {
     
174.         _graphics_window = gw;
     
175. }
     
176. 
     
177. class MyGraphicsWindow : public osgViewer::GraphicsWindow
     
178. {
     
179. 
     
180. public:
     
181.         MyGraphicsWindow(MyCanvas * canvas);
     
182.         virtual ~MyGraphicsWindow();
     
183.         void init();
     
184. 
     
185.         void grabFocus();
     
186.         void grabFocusIfPointerInWindow();
     
187.         void useCursor(bool cursorOn);
     
188. 
     
189.         bool makeCurrentImplementation();
     
190.         void swapBuffersImplementation();
     
191. 
     
192.     virtual bool valid() const { return true; }
     
193.     virtual bool realizeImplementation() { return true; }
     
194.     virtual bool isRealizedImplementation() const  { return _canvas->IsShownOnScreen(); }
     
195.     virtual void closeImplementation() {}
     
196.     virtual bool releaseContextImplementation() { return true; }
     
197. private:
     
198.         MyCanvas * _canvas;
     
199.         wxGLContext * _glContext;
     
200. };
     
201. 
     
202. MyGraphicsWindow::MyGraphicsWindow(MyCanvas * canvas)
     
203. {
     
204.     _canvas = canvas;
     
205. 
     
206.     this->_traits = new GraphicsContext::Traits;
     
207.         _glContext = new wxGLContext(_canvas);
     
208.     wxPoint pos = _canvas->GetPosition();
     
209.     wxSize  size = _canvas->GetSize();
     
210. 
     
211.     this->_traits->x = pos.x;
     
212.     this->_traits->y = pos.y;
     
213.     this->_traits->width = size.x;
     
214.     this->_traits->height = size.y;
     
215. 
     
216.     init();
     
217. }
     
218. 
     
219. MyGraphicsWindow::~MyGraphicsWindow()
     
220. {
     
221.         delete _glContext;
     
222. }
     
223. 
     
224. void MyGraphicsWindow::init()
     
225. {
     
226.          if (valid())
     
227.     {
     
228.         setState( new osg::State );
     
229.         getState()->setGraphicsContext(this);
     
230. 
     
231.         if (_traits.valid() && _traits->sharedContext)
     
232.         {
     
233.             getState()->setContextID( _traits->sharedContext->getState()->getContextID() );
     
234.             incrementContextIDUsageCount( getState()->getContextID() );
     
235.         }
     
236.         else
     
237.         {
     
238.             getState()->setContextID( osg::GraphicsContext::createNewContextID() );
     
239.         }
     
240.     }
     
241. }
     
242. 
     
243. void MyGraphicsWindow::grabFocus()
     
244. {
     
245.         _canvas->SetFocus();
     
246. }
     
247. 
     
248. void MyGraphicsWindow::grabFocusIfPointerInWindow()
     
249. {
     
250.         wxPoint pos = wxGetMousePosition();
     
251.         if (wxFindWindowAtPoint(pos) == _canvas)
     
252.                 _canvas->SetFocus();
     
253. }
     
254. 
     
255. void MyGraphicsWindow::useCursor(bool cursorOn)
     
256. {
     
257.         _canvas->UseCursor(cursorOn);
     
258. }
     
259. 
     
260. bool MyGraphicsWindow::makeCurrentImplementation()
     
261. {
     
262.         _canvas->SetCurrent(*_glContext);
     
263.        
     
264.         return true;
     
265. }
     
266. 
     
267. void MyGraphicsWindow::swapBuffersImplementation()
     
268. {
     
269.         _canvas->SwapBuffers();
     
270. }
     
271. 
     
272. class MyFrame : public wxFrame
     
273. {
     
274. 
     
275. public:
     
276.         MyFrame(const wxString& title = wxT("我的窗口"));
     
277.         virtual ~MyFrame();
     
278. private:
     
279.         DECLARE_EVENT_TABLE()
     
280.         void OnIdle(wxIdleEvent &event);
     
281. public:
     
282.         osg::ref_ptr<osgViewer::Viewer> _viewer;
     
283.         MyCanvas * _canvas;
     
284.         MyGraphicsWindow * _myGraphicsWindow;
     
285.         osg::ref_ptr<osg::Node> loadedModel;
     
286. };
     
287. 
     
288. MyFrame::MyFrame(const wxString & title)
     
289.     :wxFrame(NULL, wxID_ANY, title, wxPoint(0, 0), wxSize(1024, 768))
     
290. {
     
291.        
     
292.         _canvas = new MyCanvas(this);
     
293.         _myGraphicsWindow = new MyGraphicsWindow(_canvas);
     
294.         _canvas->SetGraphicsWindow(_myGraphicsWindow);
     
295.        
     
296.         _viewer = new osgViewer::Viewer;
     
297.         _viewer->getCamera()->setGraphicsContext(_myGraphicsWindow);
     
298.         _viewer->getCamera()->setViewport(0,0,1024,768);
     
299.     _viewer->addEventHandler(new osgViewer::StatsHandler);
     
300.     _viewer->setThreadingModel(osgViewer::Viewer::SingleThreaded);
     
301.         loadedModel= osgDB::readNodeFile(std::string("cow.osg"));
     
302.        
     
303.         _viewer->setSceneData(loadedModel.get());
     
304.         _viewer->setCameraManipulator(new osgGA::TrackballManipulator);
     
305. }
     
306. 
     
307. MyFrame::~MyFrame()
     
308. {
     
309. }
     
310. 
     
311. BEGIN_EVENT_TABLE(MyFrame, wxFrame)
     
312.     EVT_IDLE(MyFrame::OnIdle)
     
313. END_EVENT_TABLE()
     
314. 
     
315. 
     
316. void MyFrame::OnIdle(wxIdleEvent &event)
     
317. {
     
318.     if (!_viewer->isRealized())
     
319.         return;
     
320. 
     
321.         _viewer->frame();
     
322.     event.RequestMore();
     
323. }
     
324. 
     
325. class MyApp : public wxApp
     
326. {
     
327. private:
     
328.         virtual bool OnInit()
     
329.         {
     
330.                 MyFrame * f = new MyFrame;
     
331.                 f->Show(true);
     
332.                 return true;
     
333.         }
     
334. };
     
335. 
     
336. DECLARE_APP(MyApp)
     
337. IMPLEMENT_APP(MyApp)
     

复制代码

wxWidgets-2.9.3对于OPENGL提供的接口略有改动，经过几天的研究终于弄好了。。。

农民工学编程

wxWidgets-2.9.3 中必须显式创建wxGLContext * _glContext;

在以前的版本中则不需要，详情看wxWidgets最新的API文档