GLWidget class glwidget.h glwidget.cpp

#ifndef GLWIDGET_H_
#define GLWIDGET_H_

#include <QGLWidget>
#include <QTimer>

#include <GLC_Factory>
#include <GLC_Viewport>
#include <GLC_MoverController>
#include <GLC_Light>

class GLWidget : public QGLWidget

{
	Q_OBJECT

public:
	GLWidget(QWidget *p_parent);
	~GLWidget();

private:
	void initializeGL();
	void paintGL();
	void resizeGL(int width, int height);

	void createScene();
	//Mouse events
	void mousePressEvent(QMouseEvent * e);

	void mouseMoveEvent(QMouseEvent * e);
	void mouseReleaseEvent(QMouseEvent * e);

	inline double getRandomMinMax( double fMin, double fMax )
	{

	    double fRandNum = (double)qrand() / RAND_MAX;
	    return fMin + (fMax - fMin) * fRandNum;
	}

//////////////////////////////////////////////////////////////////////
// Private slots Functions
//////////////////////////////////////////////////////////////////////
private slots:
	//! Rotate the view
	void rotateView();

private:

	GLC_Factory* m_pFactory;
	GLC_Light m_Light;
	GLC_World m_World;
	GLC_Viewport m_GlView;

	GLC_MoverController m_MoverController;
	GLC_BoundingBox m_ShuttleBoundingBox;
	//! The timer used for motion
	QTimer m_MotionTimer;
};

#endif /*GLWIDGET_H_*/

Methods :

• Add the getRandomMinMax() to get a restricted random number.
• Add the private slot rotateView to turn around the star ship

Private members :

• Add a QTimer to rotate the view at a specified interval.

#include <QtDebug>
#include "glwidget.h"


// For VSYNC problem under Mac OS X
#if defined(Q_OS_MAC)
#include <OpenGL.h>
#endif

GLWidget::GLWidget(QWidget *p_parent)
: QGLWidget(p_parent)
, m_pFactory(GLC_Factory::instance(this->context()))
, m_Light()
, m_World()
, m_GlView(this)
, m_MoverController()
, m_ShuttleBoundingBox()
, m_MotionTimer()
{

	m_Light.setPosition(4000.0, 40000.0, 80000.0);
	//m_GlView.setBackgroundColor(Qt::white);
	m_Light.setAmbientColor(Qt::lightGray);

	m_GlView.cameraHandle()->setDefaultUpVector(glc::Z_AXIS);
	m_GlView.cameraHandle()->setIsoView();

	QColor repColor;
	repColor.setRgbF(1.0, 0.11372, 0.11372, 0.0);

	m_MoverController= m_pFactory->createDefaultMoverController(repColor, &m_GlView);

	createScene();

	// Signal and slot connection
	connect(&m_MotionTimer, SIGNAL(timeout()), this, SLOT(rotateView()));


}

GLWidget::~GLWidget()
{
	delete m_pFactory;
}

void GLWidget::initializeGL()
{

	// For VSYNC problem under Mac OS X
	#if defined(Q_OS_MAC)
	const GLint swapInterval = 1;
	CGLSetParameter(CGLGetCurrentContext(), kCGLCPSwapInterval, &swapInterval);

	#endif

	// OpenGL initialisation from NEHE production
	m_GlView.initGl();
	// Reframe the scene
	m_GlView.reframe(m_ShuttleBoundingBox);

	// Calculate camera depth of view
	m_GlView.setDistMinAndMax(m_World.boundingBox());

	glEnable(GL_NORMALIZE);

	m_MotionTimer.start(60);


}

void GLWidget::paintGL()
{

	// Clear screen
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	// Load identity matrix
	glLoadIdentity();

	// define the light
	m_Light.enable();

	// define view matrix
	m_GlView.glExecuteCam();

	m_Light.glExecute();

	// Display the Point Sprite
	m_World.glExecute(0 ,false);

	// Display UI Info (orbit circle)
	m_MoverController.drawActiveMoverRep();

}

void GLWidget::resizeGL(int width, int height)
{

	m_GlView.setWinGLSize(width, height);	// Compute window aspect ratio

}

void GLWidget::createScene()
{

	// Load the 3DXML
	QFile democles(":Democles.dae");

	GLC_World* pWorld= m_pFactory->createWorld(democles);

	m_World= *pWorld;
	delete pWorld;

	m_ShuttleBoundingBox= m_World.boundingBox();

	GLC_StructOccurence* pRoot= m_World.rootOccurence();

	QImage texture(QString(":particle.png"));

	GLC_3DRep pointSprite;
	const float min= -20000.0f;
	const float max= 20000.0f;

	for (int i= 0; i < 300; ++i)
	{

		QColor currentColor;
		currentColor.setRedF(getRandomMinMax(0.4, 1.0));

		currentColor.setGreenF(getRandomMinMax(0.4, 0.7));
		currentColor.setBlueF(getRandomMinMax(0.4, 1.0));

		GLC_Material* pMaterial= m_pFactory->createMaterial(texture);
		pMaterial->setDiffuseColor(currentColor);

		pointSprite= m_pFactory->createPointSprite(getRandomMinMax(5.0f, 10.0f), pMaterial);

		GLC_StructReference* pStructReference= new GLC_StructReference(new GLC_3DRep(pointSprite));

		GLC_StructInstance* pStructInstance= new GLC_StructInstance(pStructReference);

		GLC_Point4d position(getRandomMinMax(min, max), getRandomMinMax(min, max), getRandomMinMax(min, max));

		const double norm= position.norm();
		if ((norm > max) or (norm < (max / 2))) position.setNormal(max);

		pStructInstance->translate(position);

		pRoot->addChild(pStructInstance);
	}

}

void GLWidget::mousePressEvent(QMouseEvent *e)
{
	if (m_MoverController.hasActiveMover()) return;

	switch (e->button())
	{
	case (Qt::LeftButton):

		m_MotionTimer.stop();
		m_MoverController.setActiveMover(GLC_MoverController::TurnTable, e->x(), e->y());

		updateGL();
		break;
	default:
		break;
	}
}

void GLWidget::mouseMoveEvent(QMouseEvent * e)
{
	if (not m_MoverController.hasActiveMover()) return;

	m_MoverController.move(e->x(), e->y());
	m_GlView.setDistMinAndMax(m_World.boundingBox());

	updateGL();
}

void GLWidget::mouseReleaseEvent(QMouseEvent*)
{
	if (not m_MoverController.hasActiveMover()) return;

	m_MoverController.setNoMover();
	m_MotionTimer.start();
	updateGL();
}

//////////////////////////////////////////////////////////////////////
// Private slots Functions
//////////////////////////////////////////////////////////////////////
// Rotate the view
void GLWidget::rotateView()
{
	m_GlView.cameraHandle()->rotateAroundTarget(glc::Z_AXIS, 2.0 * glc::PI / static_cast<double>(200));

	updateGL();
}

createScene :

Use GLC_Factory to construct a GLC_World with a Collada File and Store the GLC_World's bounding Box.

Use GLC_Factory to construct some GLC_3DRep which contains GLC_PointSprite

Create GLC_StructReference, GLC_StructInstance to add point Sprite has child of GLC_World's root GLC_StructOccurence.