From f7a98554a3d0d229397757a2865f43207f367860 Mon Sep 17 00:00:00 2001 From: Jakob Odersky Date: Wed, 4 May 2011 15:13:27 +0000 Subject: Migration de la gestion des evenements clavier de Stage a KeyManager --- src/gui/KeyManager.cc | 64 ++++++++++++++++++++++ src/gui/KeyManager.h | 36 +++++++++++++ src/gui/Main.cc | 2 +- src/gui/ParticleRenderer.cc | 19 ++++--- src/gui/ParticleRenderer.h | 4 +- src/gui/Stage.cc | 129 ++++++++++++++------------------------------ src/gui/Stage.h | 18 +++++-- src/gui/gui.pro | 4 +- src/main/Accelerator.h | 78 +++++++++++++-------------- 9 files changed, 213 insertions(+), 141 deletions(-) create mode 100644 src/gui/KeyManager.cc create mode 100644 src/gui/KeyManager.h (limited to 'src') diff --git a/src/gui/KeyManager.cc b/src/gui/KeyManager.cc new file mode 100644 index 0000000..c7ccca0 --- /dev/null +++ b/src/gui/KeyManager.cc @@ -0,0 +1,64 @@ +/* + * KeyManager.cc + * + * Created on: May 4, 2011 + * Author: jakob + */ + +#include "KeyManager.h" +#include "Stage.h" +#include "util.h" +#include + +using namespace vhc::util; + +namespace vhc { + + +KeyManager::KeyManager(Stage& stage): stage(stage), keys() { + +} + +KeyManager::~KeyManager() {} + +void KeyManager::press(int key) { + std::set::iterator it = keys.begin(); + + keys.insert(it, key); + + switch(key) { + case Qt::Key_Escape: + QApplication::exit(0); + break; + case Qt::Key_1: + stage.setDisplayMode(FILL); + break; + case Qt::Key_2: + stage.setDisplayMode(WIREFRAME); + break; + case Qt::Key_3: + stage.setDisplayMode(POINTS); + break; + case Qt::Key_Space: + stage.setRunning(!stage.isRunning()); + break; + case Qt::Key_QuoteLeft: + stage.getParticleRenderer().enableDrawSpheres(!stage.getParticleRenderer().isDrawSpheresEnabled()); + break; + default: + break; + } + +}; + +void KeyManager::release(int key) { + keys.erase(key); +} + +bool KeyManager::isPressed(int key) const { + return (keys.find(key) != keys.end()); +} + + + +} diff --git a/src/gui/KeyManager.h b/src/gui/KeyManager.h new file mode 100644 index 0000000..1f5f54d --- /dev/null +++ b/src/gui/KeyManager.h @@ -0,0 +1,36 @@ +/* + * KeyManager.h + * + * Created on: May 4, 2011 + * Author: jakob + */ + +#ifndef KEYMANAGER_H_ +#define KEYMANAGER_H_ + +#include + +namespace vhc { + +class Stage; + +class KeyManager { + +public: + KeyManager(Stage& stage); + virtual ~KeyManager(); + + void press(int key); + void release(int key); + bool isPressed(int key) const; + +private: + Stage& stage; + + std::set keys; + +}; + +} + +#endif /* KEYMANAGER_H_ */ diff --git a/src/gui/Main.cc b/src/gui/Main.cc index 3925f61..6ae9c67 100644 --- a/src/gui/Main.cc +++ b/src/gui/Main.cc @@ -225,7 +225,7 @@ int main(int argc, char *argv[]) window.show(); - window.showFullScreen(); + //window.showFullScreen(); //app.setActiveWindow(&window); return app.exec(); diff --git a/src/gui/ParticleRenderer.cc b/src/gui/ParticleRenderer.cc index 05f1b63..6e1cc59 100644 --- a/src/gui/ParticleRenderer.cc +++ b/src/gui/ParticleRenderer.cc @@ -22,22 +22,29 @@ ParticleRenderer::~ParticleRenderer() { } void ParticleRenderer::render(const Particle& particle) const { - glPushMatrix(); - glTranslated(particle.getPosition().getX(), particle.getPosition().getY(), particle.getPosition().getZ()); - if (_drawSpheres) { + double pos[] = {particle.getPosition().getX(), particle.getPosition().getY(), particle.getPosition().getZ()}; + + if (!_drawSpheres) { glBegin(GL_POINTS); - glVertex3d(0, 0, 0); + glVertex3dv(pos); glEnd(); } else { + glPushMatrix(); + glTranslated(pos[0], pos[1], pos[2]); util::sphere(0.01); + glPopMatrix(); } - glPopMatrix(); + } -void ParticleRenderer::drawSpheres(bool value) { +void ParticleRenderer::enableDrawSpheres(bool value) { _drawSpheres = value; } +bool ParticleRenderer::isDrawSpheresEnabled() const { + return _drawSpheres; +} + } diff --git a/src/gui/ParticleRenderer.h b/src/gui/ParticleRenderer.h index ffa6707..216c869 100644 --- a/src/gui/ParticleRenderer.h +++ b/src/gui/ParticleRenderer.h @@ -25,7 +25,9 @@ public: virtual ~ParticleRenderer(); void render(const Particle& particle) const; - void drawSpheres(bool value); + void enableDrawSpheres(bool value); + + bool isDrawSpheresEnabled() const; }; diff --git a/src/gui/Stage.cc b/src/gui/Stage.cc index b3f054a..4b9e5e7 100644 --- a/src/gui/Stage.cc +++ b/src/gui/Stage.cc @@ -18,12 +18,12 @@ namespace vhc { Stage::Stage(QWidget* parent): QGLWidget (parent), - accelerator(NULL), camera(), + keyManager(*this), + accelerator(NULL), elementRenderer(), particleRenderer(), displayMode(FILL), - keys(0), frameTime(0), h(1E-11), paused(true) { @@ -130,18 +130,17 @@ void Stage::paintGL() { } } - if (keys != 0) { double dt = frameTime; double s = 0.002; - Vector3D mv = Vector3D::Null; - if (keys & 1) mv = mv - Vector3D::j * dt * s; - if (keys & 2) mv = mv - Vector3D::i * dt * s; - if (keys & 4) mv = mv + Vector3D::j * dt * s; - if (keys & 8) mv = mv + Vector3D::i * dt * s; - if (keys & 16) mv = mv + Vector3D::k * dt * s; - if (keys & 32) mv = mv - Vector3D::k * dt * s; + MutableVector3D mv = Vector3D::Null; + if (keyManager.isPressed(Qt::Key_A)) mv -= Vector3D::j * dt * s; + if (keyManager.isPressed(Qt::Key_W)) mv -= Vector3D::i * dt * s; + if (keyManager.isPressed(Qt::Key_D)) mv += Vector3D::j * dt * s; + if (keyManager.isPressed(Qt::Key_S)) mv += Vector3D::i * dt * s; + if (keyManager.isPressed(Qt::Key_PageUp)) mv += Vector3D::k * dt * s; + if (keyManager.isPressed(Qt::Key_PageDown)) mv -= Vector3D::k * dt * s; camera.move(mv); - } + if (!paused) accelerator->step(h); @@ -158,90 +157,42 @@ void Stage::mouseMoveEvent(QMouseEvent* event) { camera.addHeading(1.0 * dheading * frameTime / 4000); camera.addPitch(1.0 * dpitch * frameTime / 4000); QCursor::setPos(QWidget::mapToGlobal(center)); - update(); } void Stage::keyPressEvent (QKeyEvent* event) { - switch (event->key()) { - case Qt::Key_Escape: - qApp->quit(); - break; - case Qt::Key_A: - keys |= 1; - break; - case Qt::Key_W: - keys |= 2; - break; - case Qt::Key_D: - keys |= 4; - break; - case Qt::Key_S: - keys |= 8; - break; - case Qt::Key_PageUp: - keys |= 16; - break; - case Qt::Key_PageDown: - keys |= 32; - break; - case Qt::Key_Up: - camera.addPitch(2 * M_PI / 100); - break; - case Qt::Key_Down: - camera.addPitch(-2 * M_PI / 100); - break; - case Qt::Key_Right: - camera.addHeading(-2 * M_PI / 100); - break; - case Qt::Key_Left: - camera.addHeading(2 * M_PI / 100); - break; - case Qt::Key_R: - break; - case Qt::Key_1: - displayMode = FILL; - break; - case Qt::Key_2: - displayMode = WIREFRAME; - break; - case Qt::Key_3: - displayMode = POINTS; - break; - case Qt::Key_Return: - accelerator->step(h); - break; - case Qt::Key_Space: - paused = !paused; - break; - default: - break; - } - update(); + keyManager.press(event->key()); } void Stage::keyReleaseEvent (QKeyEvent* event) { - switch (event->key()) { - case Qt::Key_A: - keys &= ~1; - break; - case Qt::Key_W: - keys &= ~2; - break; - case Qt::Key_D: - keys &= ~4; - break; - case Qt::Key_S: - keys &= ~8; - break; - case Qt::Key_PageUp: - keys &= ~16; - break; - case Qt::Key_PageDown: - keys &= ~32; - break; - default: - break; - } + keyManager.release(event->key()); +} + +Camera& Stage::getCamera() { + return camera; +} + +DisplayMode Stage::getDisplayMode() const { + return displayMode; +} + +void Stage::setDisplayMode(DisplayMode value) { + displayMode = value; +} + +bool Stage::isRunning() const { + return !paused; +} + +void Stage::setRunning(bool value) { + paused = !value; +} + +ElementRenderer& Stage::getElementRenderer(){ + return elementRenderer; +} + +ParticleRenderer& Stage::getParticleRenderer() {; + return particleRenderer; } } diff --git a/src/gui/Stage.h b/src/gui/Stage.h index 7eba62a..04cb1da 100644 --- a/src/gui/Stage.h +++ b/src/gui/Stage.h @@ -12,6 +12,7 @@ #include #include #include "Camera.h" +#include "KeyManager.h" #include "ElementRenderer.h" #include "ParticleRenderer.h" #include "Element.h" @@ -30,6 +31,18 @@ public: Stage(QWidget* parent = NULL); virtual ~Stage(); + Camera& getCamera(); + + void setDisplayMode(util::DisplayMode value); + util::DisplayMode getDisplayMode() const; + + bool isRunning() const; + void setRunning(bool value); + + ElementRenderer& getElementRenderer(); + ParticleRenderer& getParticleRenderer(); + + //TODO !!! temporary Accelerator* accelerator; @@ -48,9 +61,9 @@ protected: void mouseMoveEvent(QMouseEvent* event); private: - - Camera camera; + KeyManager keyManager; + QTimer* timer; QTime time; int frameTime; //ms @@ -63,7 +76,6 @@ private: util::DisplayMode displayMode; - int keys; QPoint center; }; diff --git a/src/gui/gui.pro b/src/gui/gui.pro index 0a73f23..74c6a72 100644 --- a/src/gui/gui.pro +++ b/src/gui/gui.pro @@ -15,5 +15,5 @@ QT += opengl # Input -HEADERS += Camera.h ElementRenderer.h util.h Stage.h ParticleRenderer.h Renderer.h -SOURCES += Camera.cc ElementRenderer.cc util.cc Stage.cc ParticleRenderer.cc Main.cc +HEADERS += Camera.h ElementRenderer.h util.h KeyManager.h Stage.h ParticleRenderer.h Renderer.h +SOURCES += Camera.cc ElementRenderer.cc util.cc KeyManager.cc Stage.cc ParticleRenderer.cc Main.cc diff --git a/src/main/Accelerator.h b/src/main/Accelerator.h index 310c26d..4c40cef 100644 --- a/src/main/Accelerator.h +++ b/src/main/Accelerator.h @@ -17,15 +17,8 @@ namespace vhc { /** Représente un accélérateur. Cette classe contient en particulier une méthode * qui fait évoluer les particules qu'elle contient. */ class Accelerator: public Printable { -private: - - /** Constructeur de copie ne faisant rien. */ - Accelerator (Accelerator const& other) {} - - /** Opérateur '=' ne faisant rien. */ - void operator= (Accelerator const& other) {} -protected: +public: typedef std::list ParticleCollection; typedef std::list ElementCollection; @@ -33,37 +26,6 @@ protected: typedef ParticleCollection::iterator ParticleIterator; typedef ElementCollection::iterator ElementIterator; - - /** Collection d'elements contenus dans cet accelerateur. */ - ElementCollection elementCollec; - - /** Collection de particules contenus danc cet accelerateur. */ - ParticleCollection particleCollec; - - /** Autorise les accelerateurs lineaires. - * @see enableLinear */ - bool allowLinear; - - /** Indique l'etat ferme de l'accelarateur. - * @see close */ - bool closed; - - /** Initialize les particules en leur attribuant l'element dans lequel ils sont contenus. - * Les particules non-contenus sont supprimes de l'accelerateur. */ - void initializeParticles(); - - /** Met a jour les particules en leur attribuant l'element dans lequel ils sont contenus. - * Contrairement a initializeParticles(), les elements consideres sont: - * - l'element actuel de la particule - * - l'element precedent - * - l'element suivant - * Si la particule se situe a cote de son element, elle est supprimee de l'accelerateur. - * Attention: si la particule saute un element, elle est tout de meme consideree comme etant dans l'element suivant (ou precedent)! Ceci - * peut survenir si un element est trop petit ou si la simulation est faite avec des pas de temps trop grands. */ - void updateParticles(); - -public: - /** Cree un nouveau accelerateur vide. * */ Accelerator (); @@ -105,6 +67,44 @@ public: /** Retourne une représentation en chaîne de caractères de cet accélérateur. */ virtual std::string toString() const; + +private: + + /** Constructeur de copie ne faisant rien. */ + Accelerator (Accelerator const& other) {} + + /** Opérateur '=' ne faisant rien. */ + void operator= (Accelerator const& other) {} + +protected: + + /** Collection d'elements contenus dans cet accelerateur. */ + ElementCollection elementCollec; + + /** Collection de particules contenus danc cet accelerateur. */ + ParticleCollection particleCollec; + + /** Autorise les accelerateurs lineaires. + * @see enableLinear */ + bool allowLinear; + + /** Indique l'etat ferme de l'accelarateur. + * @see close */ + bool closed; + + /** Initialize les particules en leur attribuant l'element dans lequel ils sont contenus. + * Les particules non-contenus sont supprimes de l'accelerateur. */ + void initializeParticles(); + + /** Met a jour les particules en leur attribuant l'element dans lequel ils sont contenus. + * Contrairement a initializeParticles(), les elements consideres sont: + * - l'element actuel de la particule + * - l'element precedent + * - l'element suivant + * Si la particule se situe a cote de son element, elle est supprimee de l'accelerateur. + * Attention: si la particule saute un element, elle est tout de meme consideree comme etant dans l'element suivant (ou precedent)! Ceci + * peut survenir si un element est trop petit ou si la simulation est faite avec des pas de temps trop grands. */ + void updateParticles(); }; } -- cgit v1.2.3