Discussion :

[shams]

bon je te met ce que j'ai compris (et qui ne marche toujours pas...)

dans OgreWidget, j'ai commenté tout ce qui concerne update(). Le code qu'il y avait dedans, je l'ai mis dans le paintEvent de maClasse. ce qui me donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void maClasse::paintEvent(QPaintEvent *) 
{
	if(!m_renderWindow) 
	{
		createRenderWindow();
		setupResources();
		setupScene();
	}
 
	if (m_renderWindow) 
	{
		m_ogreRoot->_fireFrameStarted();
		m_renderWindow->update();
		m_ogreRoot->_fireFrameEnded();
	}
 
	std::cout << "PAINT EVENT" << std::endl;
}

Le timer, je l'ai changé en :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void maClasse::timerEvent(QTimerEvent *) 
{	
	if (isVisible())
	{	
		//cout << "le timer marche" << endl;
		traitementDeplacement();
		testPosCam();
		updateStat();
		update();
		cout << "on affiche" << endl;
	}
	else
		cout << "on affiche pas" << endl;
}

C'est bien ce que tu me conseillais de faire?

Je te met un extrait de la console pour que tu vois ce qui s'affiche quand je change d'onglet :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
PAINT EVENT
on affiche
PAINT EVENT
on affiche
PAINT EVENT
on affiche
PAINT EVENT
 
changement onglet
 
on affiche pas
on affiche pas
on affiche pas
on affiche pas

je detecte le changement d'onglet avec un signal and slot :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
O_MainWidget::O_MainWidget(QWidget *parent)
		  : QWidget(parent)
{
	std::cout << "\nConstruction de la Main Widget\n" << std::endl;
	ui.setupUi(this);
	previousIndex = ui.tabWidget->currentIndex();
 
	// CONNECT
	connect(ui.tabWidget, SIGNAL(currentChanged(int)), this, SLOT(hideOgreView(int)));
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
void O_MainWidget::hideOgreView(int index)
{
	std::cout << "\nchangement onglet\n" << std::endl;
 
}

[yan]

C'est bien ce que tu me conseillais de faire?

oui... Et vue la console ça semble bien faire ce qu'il faut...
Là j'ai plus d'idée...
peut être à la création de ta widget faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
setAttribute(Qt::WA_OpaquePaintEvent);
setAttribute(Qt::WA_PaintOnScreen);

Mais je ne pense pas que cela change grand chose.

Juste un détaille, pour le timer j'aurai plutôt fait un slot que de passer par

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void maClasse::timerEvent(QTimerEvent *)

Peut tu essayer le code du tuto avec la correction pour mac? en mettant la widget dans un onglet voir si ça marche?

[shams]

j'avais deja mis les attributs...

Bon, après bien des galères pour compiler le code du tuto, qui ne marche pas très bien (resize ne fonctionne pas, pas de mise a jour de la couleur), par contre, si je change d'onglet, la fenetre ogre a l'air de disparaitre!!!

je comprend plus rien ...

Est ce que ca pourrait venir d'un truc à la con genre un setFocusPolicy mal réglé?

voici le code complet de mon QogreWidget pris sur le site de ogre, au cas où tu vois un truc qui cloche... :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
/*!
 * \file QOgreWidget.cpp
 * \brief un widget Ogre
 * \author moi
 * \version 1.0
 * \date Mercredi 23 Avril 2008
 *
 * Ce widget a été trouvé sur le forum officiel de Ogre. Nous l'avons modifié pour qu'il réponde Ã* nos attentes
 *
 */
 
 
///////////////////////////////
// INCLUDE 
/////////////////////////////
#include "QOgreWidget.h"
#if defined(Q_WS_MAC)
#include <Carbon/Carbon.h>
#include <Ogre/OgreOSXContext.h>
#include <AGL/agl.h>
#elif !defined(Q_WS_WIN)
#include <QX11Info>
#endif
//___________________________
 
using namespace std;
 
 
//
// --- Functions ---
//
///
/// Default constructor
///
QOgreWidget::QOgreWidget(QWidget *parent) : QWidget(parent) {
	setAttribute(Qt::WA_PaintOnScreen);
	//setAttribute(Qt::WA_NoBackground);
	setAttribute(Qt::WA_OpaquePaintEvent);
	m_renderWindow = NULL;
	m_ogreRoot = NULL;
}
///
/// Destructor
///
QOgreWidget::~QOgreWidget(void) 
{
	cout << "Destruction QOgreWidget" << endl;
	if(m_renderWindow)
    {
        m_renderWindow->removeAllViewports();
    }
 
    if(m_ogreRoot)
    {
        m_ogreRoot->detachRenderTarget(m_renderWindow);
    }
 
    delete m_ogreRoot;
    cout << "Fin Destruction QOgreWidget" << endl;
}
///
/// \name Misc
/// Miscellaneous functions of this class
///
//@{
///
/// Render a frame
///
/*void QOgreWidget::update(void) {
	if (m_renderWindow) {
		m_ogreRoot->_fireFrameStarted();
		m_renderWindow->update();
		m_ogreRoot->_fireFrameEnded();
	}
}*/
///
/// Give the minimum size for this widget
/// \return Returns a size
/// \warning Needs to be big enough so that ogre doesn't crash (50 50 looks big enough)
///
QSize QOgreWidget::minimumSizeHint(void) const {
	return QSize(50, 50);
}
//@}
///
/// \name Protected functions
/// Protected helper functions
///
//@{
///
/// Handle a resize event (pass it along to the render window)
/// \param e The event data
///
void QOgreWidget::resizeEvent(QResizeEvent *) {
	if (m_renderWindow)
		resizeRenderWindow();
}
///
/// Handle a paint event (just render again, if needed create render window)
/// \param e The event data
///
void QOgreWidget::paintEvent(QPaintEvent *) {
	if (!m_renderWindow)
		createRenderWindow();
 
	if (m_renderWindow) {
		m_ogreRoot->_fireFrameStarted();
		m_renderWindow->update();
		m_ogreRoot->_fireFrameEnded();
	}
}
//@}
///
/// \name Private functions
/// Private helper functions
///
//@{
///
/// Create the Ogre render window
///
void QOgreWidget::createRenderWindow(void) {
	Ogre::NameValuePairList params;
 
	if (m_renderWindow)
		return;
	if (!m_ogreRoot)
		configure();
 
 
#if defined(Q_WS_MAC) || defined(Q_WS_WIN)
	params["externalWindowHandle"] = Ogre::StringConverter::toString((size_t) winId());
#else
    QX11Info info = x11Info();
	Ogre::String winHandle;
	winHandle  = Ogre::StringConverter::toString((unsigned long)(info.display()));
	winHandle += ":";
	winHandle += Ogre::StringConverter::toString((unsigned int)(info.screen()));
	winHandle += ":";
	winHandle += Ogre::StringConverter::toString((unsigned long)(this->parentWidget()->winId()));
	params["parentWindowHandle"] = winHandle;
#endif
 
	m_renderWindow = m_ogreRoot->createRenderWindow("View" + Ogre::StringConverter::toString((unsigned long) this),
													width(), height(), false, &params);
 
#if defined(Q_WS_MAC)
	// store context for hack
	Ogre::OSXContext *context;
	m_renderWindow->getCustomAttribute("GLCONTEXT", &context);
	context->setCurrent();
	m_aglContext = aglGetCurrentContext();
	resizeRenderWindow();
#endif
 
	// take over ogre window
#if !defined(Q_WS_MAC)
	WId ogreWinId = 0x0;
	m_renderWindow->getCustomAttribute("WINDOW", &ogreWinId);
	assert(ogreWinId);
	create(ogreWinId);
#endif
}
///
/// Configure Ogre
/// \todo This really needs to be moved somewhere else (singleton?)
///
void QOgreWidget::configure(void) {
	if (m_ogreRoot)
		return;
#if defined(Q_WS_MAC)	
	m_ogreRoot = new Ogre::Root("Data/config/plugins_mac.cfg", "Data/config/ogre.cfg", "Data/config/ogre.log");
#elif defined (Q_WS_WIN)
	m_ogreRoot = new Ogre::Root("Data/config/plugins_win.cfg", "Data/config/ogre.cfg", "Data/config/ogre.log");
#else
	m_ogreRoot = new Ogre::Root("Data/config/plugins_linux.cfg", "Data/config/ogre.cfg", "Data/config/ogre.log");
#endif
	if (!m_ogreRoot->restoreConfig()) {
		// setup a renderer
		Ogre::RenderSystemList *renderers = m_ogreRoot->getAvailableRenderers();
		assert(!renderers->empty()); // we need at least one renderer to do anything useful
 
		//Ogre::RenderSystem *renderSystem = chooseRenderer(renderers);
		Ogre::RenderSystem *renderSystem = *renderers->begin();
		assert(renderSystem); // user might pass back a null renderer, which would be bad!
 
		m_ogreRoot->setRenderSystem(renderSystem);
		QString dimensions = QString("%1x%2").arg(this->width()).arg(this->height());
		renderSystem->setConfigOption("Video Mode", dimensions.toStdString());
 
		// initialize without creating window
		m_ogreRoot->getRenderSystem()->setConfigOption("Full Screen", "No");
		m_ogreRoot->saveConfig();
	}
	m_ogreRoot->initialise(false);
}
///
/// Resize the render window (when the widget was resized)
///
void QOgreWidget::resizeRenderWindow(void) {
	if (!m_renderWindow)
		return;
 
#if !defined(Q_WS_MAC)
	m_renderWindow->resize(width(), height());
	m_renderWindow->windowMovedOrResized();
#else
	GLint bufferRect[4];
	HIViewRef mView = HIViewRef(winId());
 
	m_renderWindow->windowMovedOrResized();
 
	// reposition our drawing region
	HIRect viewBounds, winBounds;
	HIViewGetBounds(mView, &viewBounds);
	HIViewRef root = HIViewGetRoot(HIViewGetWindow(mView));
	HIViewRef content_root;
	HIViewFindByID(root, kHIViewWindowContentID, &content_root);
 
	HIViewGetBounds(content_root, &winBounds);
	HIViewConvertRect(&viewBounds, mView, content_root);
 
	bufferRect[0] = x();
	bufferRect[1] = GLint((winBounds.size.height) - (viewBounds.origin.y + viewBounds.size.height));
	bufferRect[2] = width();
	bufferRect[3] = height();
 
	aglSetInteger(m_aglContext, AGL_BUFFER_RECT, bufferRect);
	aglEnable (m_aglContext, AGL_BUFFER_RECT);
#endif
}
//@}
///
/// \name Protected variables
/// Protected variables this class uses
///
//@{
///
/// The Ogre root
///
Ogre::Root * QOgreWidget::m_ogreRoot = NULL;
//@}
//
//

[yan]

voici le code complet de mon QogreWidget pris sur le site de ogre, au cas où tu vois un truc qui cloche... :

Ben ou est le timer que tu utilise??
Peut tu mettre ta class?
Si ca marche avec le tuto, c'est bon signe, c'est surement pas grand chose

[shams]

le timer est dans maClasse qui derive de ogreWidget.
attention, je te met tout le code, c'est un peu long (tu veux jeter un coup d'oeil ou .h aussi?) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
 
 
///////////////////////////////
// INCLUDE 
/////////////////////////////
#include "sceneOgre.h"
#include <QMouseEvent>
//___________________________
 
using namespace std;
 
 
//-----------------------------------------------------------------
maClasse::maClasse(QWidget *parent) : QOgreWidget(parent) 
	,	m_mousePressed ( false )
	,	m_LMBDown ( false )
	,	m_RMBDown ( false )
	,	m_processMovement ( false )
	,	m_updateMovement ( false )
	,	m_moveFast ( false )
	,	m_moveFwd ( false )
	,	m_moveBck ( false )
	,	m_moveLeft ( false )
	,	m_moveRight ( false )
	,	m_translateVector ( Ogre::Vector3::ZERO )
	,	m_moveSpeed ( NORMALSPEED )
	,	m_rotX ( 0 )
	,	m_rotY ( 0 )
	, m_terrainSizeX(0)
	, m_terrainSizeZ(0)
 
{
	cout << "Construction de SceneOgre" << endl;
 
	m_vp = NULL;
	m_sceneMgr = NULL;
	m_raySceneQuery = NULL;
 
	//pour que les événements clavier et souris soient captés par ce widget
	setFocusPolicy(Qt::ClickFocus);
}
 
//-----------------------------------------------------------------
maClasse::~maClasse(void) 
{
	cout << "Destruction SceneOgre" << endl;
	if(m_ogreRoot)
	{
		if(m_sceneMgr)
		{
			m_sceneMgr->destroyQuery(m_raySceneQuery);
			m_ogreRoot->destroySceneManager(m_sceneMgr);
		}
	}
	cout << "Fin destruction SceneOgre" << endl;
}
 
 
//-----------------------------------------------------------------
void maClasse::resizeEvent(QResizeEvent *e) 
{
	QOgreWidget::resizeEvent(e);
 
	if (m_renderWindow) 
	{
		// Alter the camera aspect ratio to match the viewport
		m_camera->setAspectRatio(Ogre::Real(width()) / Ogre::Real(height()));
		m_vp->update();
	}
}
 
 
//-----------------------------------------------------------------
void maClasse::paintEvent(QPaintEvent *) 
{
	if(!m_renderWindow) 
	{
		createRenderWindow();
		setupResources();
		setupScene();
	}
	else 
	{
		m_ogreRoot->_fireFrameStarted();
		m_renderWindow->update();
		m_ogreRoot->_fireFrameEnded();
	}
 
	std::cout << "PAINT EVENT" << std::endl;
}
 
 
//-----------------------------------------------------------------
void maClasse::timerEvent(QTimerEvent *) 
{	
	if (isVisible())
	{	
		//cout << "le timer marche" << endl;
		traitementDeplacement();
		testPosCam();
		updateStat();
		update();
		cout << "on affiche" << endl;
	}
	else
		cout << "on affiche pas" << endl;
}
 
 
//-----------------------------------------------------------------
void maClasse::keyPressEvent(QKeyEvent *e)
{
	//cout << "on appuie sur une touche " << e->key() <<endl;
 
	// on traite les touches pour le mouvement
	checkMovementKeys( e , true);
 
	switch  ( e->key())
	{
		case  Qt::Key_V : 
			cout << "j'appuie sur v" << endl;
			break;
 
		default:
			break;
	}
}
 
 
//-----------------------------------------------------------------
void maClasse::keyReleaseEvent(QKeyEvent *e)
{
	// on traite les touches pour le mouvement
	checkMovementKeys( e , false);
 
	//cout << "on appuie plus sur les touches" << endl;
 
}
 
 
//-----------------------------------------------------------------
void maClasse::checkMovementKeys(QKeyEvent *e, bool state)	
{
	switch ( e->key())
	{
		case Qt::Key_Left :
		case Qt::Key_Q:
			m_moveLeft = state;
			break;
 
		case Qt::Key_Right :
		case Qt::Key_D:
			m_moveRight = state;
			break;
 
		case Qt::Key_Down :
		case Qt::Key_S:
			m_moveBck = state;
			break;
 
		case Qt::Key_Up :
		case Qt::Key_Z:
			m_moveFwd = state;
			break;
 
		case Qt::Key_Space :
			m_moveFast = state;
			break;
 
        default:
            break;
 
	}
	m_processMovement = m_moveLeft || m_moveRight || m_moveFwd || m_moveBck;
}
 
 
//-----------------------------------------------------------------
void maClasse::mousePressEvent(QMouseEvent *e) 
{
	m_mousePressPos = e->pos();
	m_mouseLastPos = m_mousePressPos;
	m_mousePressed = true;
	//cout << "on appuie sur la souris en " << m_mousePressPos.x()  <<  "," << m_mousePressPos.y() << endl;
 
	switch (e->button())
	{
		case Qt::LeftButton :
			//cout << "on clique gauche" << endl;
			m_LMBDown = true;
			break;
 
		case Qt::RightButton : 
			//cout << "on clique droit"  << endl;
			m_RMBDown = true;
			break;
 
		case Qt::MidButton : 
			//cout << "on clique milieu" << endl;
			break;
 
		default :
			break;
	}
 
 
	if (m_mainNode)
		m_orientationPressed = m_mainNode->getOrientation();
 
}
 
 
//-----------------------------------------------------------------
void maClasse::mouseReleaseEvent(QMouseEvent *e) 
{
	//cout << "on appuie plus sur la souris" << endl;
	switch (e->button())
	{
		case Qt::LeftButton :
			//cout << "on clique plus gauche" << endl;
			m_LMBDown = false;
			break;
 
		case Qt::RightButton : 
			//cout << "on clique plus droit"  << endl;
			m_RMBDown = false;
			break;
 
		case Qt::MidButton : 
			//cout << "on clique plus milieu" << endl;
			break;
 
		default :
			break;
	}
    m_mousePressed = false;
}
 
 
//-----------------------------------------------------------------
void maClasse::mouseMoveEvent(QMouseEvent *e) 
{
	// on enregistre la position de la souris en cours
	m_mousePressPos = e->pos();
	//cout << "on bouge la souris en " << m_mousePressPos.x()  <<  "," << m_mousePressPos.y() << "alors qu'avant elle etait en "<<  m_mouseLastPos.x() << "," << m_mouseLastPos.y() << endl;
	// CLIC GAUCHE =============================
	if( m_LMBDown && !m_RMBDown)
	{
		// on calcul le deplacement de la souris avec l'ancienne position enregistree
		m_rotX += - (m_mousePressPos.x()-m_mouseLastPos.x())  * 0.15;
		m_rotY += - (m_mousePressPos.y()-m_mouseLastPos.y())  * 0.15;
		//cout <<  "on devrait bouger la cam de " << m_rotX << "," << m_rotY << endl;
		// rotate camera
		//TODO : je ne comprends pas l'utilisation des sceneNode, m_camera fonctionne mieux sans...
		//m_sceneNode->yaw(Ogre::Angle(m_rotX));
		//m_sceneNode->pitch(Ogre::Angle(m_rotY));
		m_camera->yaw(Ogre::Angle(m_rotX));
		m_camera->pitch(Ogre::Angle(m_rotY));
		//m_camera->moveRelative(m_translateVector);
 
	}
 
	// on enregistre la position actuelle de la souris en tant que ancienne position parce qu'on va revenir dans cette fonction
	m_mouseLastPos = m_mousePressPos;
 
}
 
 
 
//------------------------------------------------------------------------
void maClasse::wheelEvent(QWheelEvent *e)
{
	//cout << "molette " << e->orientation() << endl;
 
	int numDegrees = e->delta() / 8;
	int numSteps = numDegrees / 15;
	e->accept();
	m_translateVector.y += numSteps * m_avgFrameTime * m_moveSpeed;
}
 
 
 
//--------------------------------------------------------------------------
void maClasse::traitementDeplacement ()
{
	if (m_moveFast) m_moveSpeed = MAXSPEED;
	else	m_moveSpeed = NORMALSPEED;
 
	m_translateVector.x += m_moveLeft ? m_avgFrameTime * -m_moveSpeed : 0;
	m_translateVector.x += m_moveRight ? m_avgFrameTime * m_moveSpeed : 0;
	m_translateVector.z += m_moveFwd ? m_avgFrameTime * -m_moveSpeed : 0;
	m_translateVector.z += m_moveBck ? m_avgFrameTime * m_moveSpeed : 0;
	if (!m_RMBDown)	m_camera->moveRelative(m_translateVector);
 
	// on reinitialise les compteurs et autres trucs...
	m_updateMovement = false;
	m_rotX = 0;
	m_rotY = 0;
	m_translateVector = Ogre::Vector3::ZERO;
}
 
 
 
//------------------------------------------------------------------
void maClasse::testPosCam(void)
{
	//test si la caméra sort de la "zone" 
	//TODO : définir une variable d'init : vertor3 ZONE
	Ogre::Vector3 posCam = m_camera->getPosition();
 
	if (posCam.x <= 100) posCam.x = 101;
	if (posCam.z <= 100) posCam.z = 101;
	if (posCam.x >= (m_terrainSizeX - 100)) posCam.x = (m_terrainSizeX - 101);
	if (posCam.z >= (m_terrainSizeX - 100)) posCam.z = (m_terrainSizeX - 101);
	if (posCam.y >= 1000) posCam.y = 999;
 
	// Paramétrage du scene query
  Ogre::Ray cameraRay(Ogre::Vector3(posCam.x, 5000.0f, posCam.z), Ogre::Vector3::NEGATIVE_UNIT_Y);
  m_raySceneQuery->setRay(cameraRay);
 
  // Perform the scene query
  Ogre::RaySceneQueryResult &result = m_raySceneQuery->execute();
  Ogre::RaySceneQueryResult::iterator itr = result.begin();
 
  // Enregistrement des résultats et et de la hauteur de la caméra
  if (itr != result.end() && itr->worldFragment)
  {
      Ogre::Real terrainHeight = itr->worldFragment->singleIntersection.y;
      if ((terrainHeight + 2.0f) > posCam.y )
      		posCam.y = terrainHeight + 2.0f;
          //mCamera->setPosition( posCam.x, terrainHeight + 10.0f, posCam.z );
  }
 
  //Et finalement On positionne la caméra avec les nouvelles coordonnées
	m_camera->setPosition(posCam.x,posCam.y,posCam.z);
}
 
 
 
//-----------------------------------------------------------------
void maClasse::createScene(void) 
{
	m_sceneMgr->setAmbientLight(Ogre::ColourValue(0.6, 0.6, 0.6));
 
	//Lancé de rayon
	m_raySceneQuery = m_sceneMgr->createRayQuery(Ogre::Ray());
 
	//skyBox
	m_sceneMgr->setSkyBox( true, "Examples/SpaceSkyBox", 5000, false);
 
	// Setup the actual scene
	Ogre::Light* l = m_sceneMgr->createLight("MainLight");
	l->setPosition(0, 100, 500);
 
	std::string terrain_cfg("Data/config/terrain.cfg");
	m_sceneMgr->setWorldGeometry( terrain_cfg );
	if (m_ogreRoot->getRenderSystem()->getCapabilities()->hasCapability(Ogre::RSC_INFINITE_FAR_PLANE))
	{
    m_camera->setFarClipDistance(0);
	}
 
	//Récupération des infos de dimension du terrain dans le fichier terrain.cfg
	//TODO : mettre une constante TERRAIN = "fourmigues" dans le define.h
	Ogre::ConfigFile cf;
	cf.load( "Data/config/terrain.cfg" );
	m_terrainSizeX = atof( cf.getSetting( "PageWorldX" ).c_str() );
	m_terrainSizeZ = atof( cf.getSetting( "PageWorldZ" ).c_str() );
	//std::cout << "X " << m_terrainSizeX << "** Z " << m_terrainSizeZ << std::endl;
}
 
 
//-----------------------------------------------------------------
void maClasse::setupResources(void) 
{
	// Load resource paths from config file
	Ogre::ConfigFile config;
	config.load("Data/config/resources.cfg");
 
	// Go through all sections & settings in the file
	Ogre::ConfigFile::SectionIterator it = config.getSectionIterator();
 
	Ogre::String secName, typeName, archName;
	while (it.hasMoreElements()) 
	{
		secName = it.peekNextKey();
		Ogre::ConfigFile::SettingsMultiMap *settings = it.getNext();
		Ogre::ConfigFile::SettingsMultiMap::iterator i;
 
		for (i = settings->begin(); i != settings->end(); ++i) 
		{
			typeName = i->first;
			archName = i->second;
			Ogre::ResourceGroupManager::getSingleton().addResourceLocation(archName, typeName, secName);
		}
    }
}
 
 
//-----------------------------------------------------------------
void maClasse::setupScene(void) 
{
	m_sceneMgr = m_ogreRoot->createSceneManager(Ogre::ST_EXTERIOR_CLOSE);
 
	// Create the camera
	m_camera = m_sceneMgr->createCamera("PlayerCam");
 
	// Look back along -Z
	m_camera->lookAt(Ogre::Vector3(0, 0, 0));
	m_camera->setNearClipDistance(1);
	//Orientation par défaut de la caméra
	//m_camera->pitch(Ogre::Angle(-60.0));
	m_camera->yaw(Ogre::Angle(-145.0));
 
	//création du camNode0
	m_sceneNode = m_sceneMgr->getRootSceneNode()->createChildSceneNode("camNode0", Ogre::Vector3(0, 0, 0));
	m_camera->setPosition(300,300,300);
 
	//création du pitch de la caméra
	m_sceneNode = m_sceneNode->createChildSceneNode( "PitchNode0" );
	m_sceneNode->attachObject( m_camera );
 
	// Create one viewport, entire window
	m_vp = m_renderWindow->addViewport(m_camera);
	m_vp->setBackgroundColour(Ogre::ColourValue(5,10,200));
	m_vp->setClearEveryFrame(true);
 
	Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
 
	createScene();
 
	Ogre::MaterialManager::getSingleton().setDefaultTextureFiltering(Ogre::TFO_BILINEAR);
	Ogre::MaterialManager::getSingleton().setDefaultAnisotropy(1);
 
	// Alter the camera aspect ratio to match the viewport
	m_camera->setAspectRatio(Ogre::Real(m_vp->getActualWidth()) / Ogre::Real(m_vp->getActualHeight()));
 
	startTimer(20);
}
 
//-----------------------------------------------------------------
void maClasse::updateStat(void) 
{
	const Ogre::RenderTarget::FrameStats& stats = m_renderWindow->getStatistics();
	//cout << "STAT\nFPS : " << stats.lastFPS << "\nBEST : " << stats.bestFPS << endl;
	m_avgFrameTime = 1.0f/(stats.avgFPS + 1.0f);
	if (m_avgFrameTime > 0.1f) m_avgFrameTime = 0.1f;
	statusText = tr("FPS : ") + stats.lastFPS  + tr("  -  BEST : ") + stats.bestFPS + tr("  -  TRIANGLE : ") + stats.triangleCount;
}
 
 
//-----------------------------------------------------------------
const float maClasse::m_RADIUS = 0.8;

[yan]

attention, je te met tout le code, c'est un peu long (tu veux jeter un coup d'oeil ou .h aussi?) :

je veut bien, au cas ou.

[shams]

voilou!
Pour être complet, j'ai une mainWindow dans laquelle j'ai mis en centralWidget un widget créé avec le designer. Ce widget contient une tabBar et un des onglets de cette tabBar contient le widget Ogre (maClasse)
alors si tu trouves franchement, tu gagnes un coup à boire!

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
 
#ifndef __SCENEOGRE_H
#define __SCENEOGRE_H
 
 
 
///////////////////////////////
// INCLUDE 
/////////////////////////////
#include "QOgreWidget.h"
#include "define.h"
//___________________________
 
 
class maClasse : public QOgreWidget 
{
 
	Q_OBJECT
 
	public:
 
		maClasse(QWidget* parent);
		~maClasse(void);
 
 
	protected:
 
		void resizeEvent(QResizeEvent *e);
		void paintEvent(QPaintEvent *e);
		void timerEvent(QTimerEvent *e);
		void keyPressEvent(QKeyEvent *e);
		void keyReleaseEvent(QKeyEvent *e);
		void checkMovementKeys(QKeyEvent *e, bool state);
		void mousePressEvent(QMouseEvent *e);
		void mouseReleaseEvent(QMouseEvent *e);
		void mouseMoveEvent(QMouseEvent *e);
		void wheelEvent(QWheelEvent *e);
		void traitementDeplacement(void);
		void createScene(void);
		void setupResources(void);
		void setupScene(void);
		void updateStat(void); 
		void testPosCam(void);
 
		bool m_mousePressed;	
		bool m_LMBDown;
		bool m_RMBDown;
		bool m_processMovement;
		bool m_updateMovement;
		bool m_moveFast;
		bool m_moveFwd;
		bool m_moveBck;
		bool m_moveLeft;
		bool m_moveRight;
		QString statusText;
		Ogre::Vector3 m_translateVector;
		Ogre::Real m_avgFrameTime;	
		Ogre::Real m_moveSpeed;	
		Ogre::Real m_rotX;	
		Ogre::Real m_rotY;	
		QPoint m_mousePressPos;
		QPoint m_mouseLastPos;
		Ogre::Quaternion m_orientationPressed;
		Ogre::SceneNode *m_mainNode;
		Ogre::SceneManager *m_sceneMgr;
		Ogre::Camera *m_camera;
		Ogre::Viewport *m_vp;
		Ogre::SceneNode *m_sceneNode;
		Ogre::Real m_terrainSizeX;
		Ogre::Real m_terrainSizeZ;
		Ogre::RaySceneQuery *m_raySceneQuery;
 
		static const float m_RADIUS;
};
//
//
//
#endif

[yan]

Tu pourrais mettre le QOgreWidget que tu utilise?
y as plusieur version sur internet.

[shams]

je te l'ai mis 3 post au dessus!

[shams]

je relance un peu au cas où quelqu'un ait une idée pour résoudre mon problème... Je crois que j'ai trop embrouillé Mongaulois !

[yan]

je te l'ai mis 3 post au dessus!

Je voie pas du tout...
As tu essayer d'adapter ta widget avec celui du tuto?
Puis ce qu'il semble fonctionner?

[shams]

je suis en train, j'ai pas eu trop de temps hier....
C'est fou cette histoire, ca va être un truc à la con, je le sens gros comme une maison

[shams]

bon faire marcher le code du tuto revient a faire ce qu'il y avait dans mon code, donc pas très concluant comme essai....

Par contre, j'ai du NOUVEAU :
avec une compilation sous linux, ca marche!!!! enfin presque! La fenetre ogre disparait bien et reapparait bien quand on change d'onglet, mais par contre, quand on clique dans la fenetre ogre -> BOOM -> erreur de segmentation...

[yan]

J'ai vue que tu utilisais Qt3 sous mac.... sur un autre forum...
Peut tu passer à Qt4?

[shams]

en fait j'etais sous 4.3 pas Qt3... je m'etais trompé, et je trouve pas comment on change.

Bref, la maintenant je suis sous Qt 4.4.3 et c'est pas mieux...

[shams]

bon après avoir laissé de coté ce bug, je dois maintenant absolument trouver la solution!

A priori, je dirai bien que ca vient de la fonction dans QOgreWidget::createRenderWindow() avec les params à définir...

Please help me!!!

[yan]

tu as essayer d'utiliser cette version ?
http://www.ogre3d.org/wiki/index.php/QtOgre

[shams]

Je n'ai pas utilisé le code dans le lien que tu m'as fourni car il me semble qu'il n'est pas Mac compatible. Par contre, j'ai utilisé (et légérement modifié) le code donnée dans le lien qu'il y a au tout début de la page du wiki.