source: flair-src/trunk/lib/FlairSimulator/src/Gui_impl.cpp @ 70

Last change on this file since 70 was 70, checked in by Sanahuja Guillaume, 5 years ago

simu cameras

File size: 11.6 KB
Line 
1// %flair:license{
2// This file is part of the Flair framework distributed under the
3// CECILL-C License, Version 1.0.
4// %flair:license}
5//  created:    2013/03/27
6//  filename:   Gui.cpp
7//
8//  author:     Guillaume Sanahuja
9//              Copyright Heudiasyc UMR UTC/CNRS 7253
10//
11//  version:    $Id: $
12//
13//  purpose:    classe definissant une Gui
14//
15/*********************************************************************/
16#ifdef GL
17
18#include "Gui_impl.h"
19#include "Gui.h"
20#include "Simulator.h"
21#include "GenericObject.h"
22#include "Model.h"
23#include "Model_impl.h"
24#include <Object.h>
25#include <Euler.h>
26#include <irrlicht.h>
27#include <unistd.h>
28#include <sstream>
29
30using namespace irr;
31using namespace irr::video;
32using namespace irr::core;
33using namespace irr::scene;
34using namespace irr::gui;
35using namespace flair::core;
36using namespace flair::simulator;
37
38class MyEventReceiver : public IEventReceiver {
39public:
40  // This is the one method that we have to implement
41  bool OnEvent(const SEvent &event) {
42    // Remember whether each key is down or up
43    if (event.EventType == EET_KEY_INPUT_EVENT)
44      KeyIsDown[event.KeyInput.Key] = event.KeyInput.PressedDown;
45
46    if (model)
47      return model->OnEvent(event);
48
49    return false;
50  }
51
52  // This is used to check whether a key is being held down
53  bool IsKeyDown(EKEY_CODE keyCode) {
54    if (KeyIsDown[keyCode] == true) {
55      KeyIsDown[keyCode] = false;
56      return true;
57    } else {
58      return false;
59    }
60  }
61
62  MyEventReceiver(void) {
63    model = NULL;
64    for (u32 i = 0; i < KEY_KEY_CODES_COUNT; ++i)
65      KeyIsDown[i] = false;
66  }
67  void SetModel(Model *model) { this->model = model; }
68
69private:
70  // We use this array to store the current state of each key
71  bool KeyIsDown[KEY_KEY_CODES_COUNT];
72  Model *model;
73};
74
75Gui_impl::Gui_impl(Gui *self, int app_width, int app_height, int scene_width,
76                   int scene_height, std::string media_path,
77                   E_DRIVER_TYPE driver_type) {
78  this->self = self;
79  dbtFile_w = NULL;
80  dbtFile_r = NULL;
81  this->media_path = media_path;
82  this->scene_width = scene_width;
83  this->scene_height = scene_height;
84
85  device = createDevice(driver_type, dimension2d<u32>(app_width, app_height),
86                        16, false, false, false);
87  receiver = new MyEventReceiver();
88  device->setEventReceiver(receiver);
89  device->getLogger()->setLogLevel(ELL_NONE);
90
91  device->getCursorControl()->setVisible(false);
92  device->setResizable(false);
93
94  // font = device->getGUIEnvironment()->getBuiltInFont();
95  driver = device->getVideoDriver();
96  smgr = device->getSceneManager();
97
98  smgr->setAmbientLight(video::SColorf(1, 1, 1));
99
100  /*
101env = device->getGUIEnvironment();
102IGUISkin* skin = env->getSkin();
103  font = env->getFont("./fonthaettenschweiler.bmp");
104
105  if (font)
106          skin->setFont(font);
107
108  // create menu
109
110  IGUIContextMenu* menu = env->addMenu();
111  menu->setMinSize(core::dimension2du(640,20));
112  menu->addItem(L"File", -1, true, true);
113  menu->addItem(L"View", -1, true, true);
114  menu->addItem(L"Camera", -1, true, true);
115  menu->addItem(L"Help", -1, true, true);
116
117  // disable alpha
118
119  for (s32 i=0; i<gui::EGDC_COUNT ; ++i)
120  {
121          video::SColor col =
122env->getSkin()->getColor((gui::EGUI_DEFAULT_COLOR)i);
123          col.setAlpha(255);
124          env->getSkin()->setColor((gui::EGUI_DEFAULT_COLOR)i, col);
125  }
126   */
127}
128
129Gui_impl::~Gui_impl() {
130  // printf("del Gui_impl\n");
131  device->drop();
132
133  delete receiver;
134  // printf("del Gui_impl ok\n");
135}
136
137void Gui_impl::AddVisualizationCamera(VisualizationCamera* camera) {
138  cameras.push_back(camera);
139}
140
141void Gui_impl::setMesh(std::string file, vector3df position, vector3df rotation,
142                       vector3df scale) {
143  IAnimatedMesh *mesh = smgr->getMesh(file.c_str());
144
145  if (!mesh) {
146    // model could not be loaded
147    self->Err("Model %s could not be loaded\n", file.c_str());
148    return;
149  }
150
151  node = smgr->addOctreeSceneNode(mesh->getMesh(0), 0, -1, 1024);
152  node->setPosition(position);
153  rotation +=
154      irr::core::vector3df(90, 0, Euler::ToDegree(getSimulator()->Yaw()));
155  node->setRotation(rotation);
156  for (int i = 0; i < node->getMaterialCount(); i++) {
157    node->getMaterial(i).TextureLayer->TextureWrapU = video::ETC_REPEAT;
158    node->getMaterial(i).TextureLayer->TextureWrapV = video::ETC_REPEAT;
159  }
160  // Ceillig
161  // node->getMaterial(0).getTextureMatrix(0).setTextureScale(scale.X/2.0,scale.Z/2.0);
162  // Walls
163  node->getMaterial(1).getTextureMatrix(0).setTextureScale(1 / (scale.Y / 2.5),
164                                                           1 / (scale.Z / 2.5));
165  // Floor
166  node->getMaterial(2).getTextureMatrix(0).setTextureScale(
167      1 / (scale.X / 20.0), 1 / (scale.Z / 20.0));
168
169  node->setScale(scale);
170  // selector
171  selector = smgr->createOctreeTriangleSelector(node->getMesh(), node, 128);
172  node->setTriangleSelector(selector);
173}
174
175void Gui_impl::RunGui(std::vector<Model *> models,
176                      std::vector<GenericObject *> objects) {
177  int lastFPS = -1;
178  int cam_id = 0;
179
180  receiver->SetModel(models.at(0));
181
182  for (size_t i = 0; i < models.size(); i++) {
183    models.at(i)->Draw();
184  }
185
186  for (size_t i = 0; i < models.size(); i++) {
187    models.at(i)->pimpl_->MetaTriangleSelector()->addTriangleSelector(selector);
188    for (size_t j = 0; j < objects.size(); j++) {
189      models.at(i)->pimpl_->MetaTriangleSelector()->addTriangleSelector(
190          objects.at(j)->TriangleSelector());
191    }
192    for (size_t j = 0; j < models.size(); j++) {
193      if (i == j) continue;
194      models.at(i)->pimpl_->MetaTriangleSelector()->addTriangleSelector(
195          models.at(j)->pimpl_->TriangleSelector());
196    }
197  }
198
199  selector->drop(); // As soon as we're done with the selector, drop it.*/
200
201  // wait all models to be started
202  for (size_t i = 0; i < models.size(); i++) {
203    models.at(i)->pimpl_->SynchronizationPoint();
204  }
205
206  setWindowCaption(0, 0);
207
208  while (device->run()) {
209    if (dbtFile_r != NULL) // rejeu
210    {
211      takeScreenshot(); // on enregistre l'image precedente
212      road_time_t time;
213      road_timerange_t tr = 0;
214      if (read_hdfile(dbtFile_r, (void *)dbtbuf, &time, &tr) != 0) {
215        vector3df vect;
216        char *buf = dbtbuf;
217        for (size_t i = 0; i < models.size(); i++) {
218          models.at(i)->ReaddbtBuf(buf);
219          buf += models.at(i)->dbtSize();
220        }
221      } else {
222        // Printf("fin play\n");
223        close_hdfile(dbtFile_r);
224        dbtFile_r = NULL;
225        free(dbtbuf);
226        for (size_t i = 0; i < models.size(); i++) {
227          models.at(i)->pimpl_->Resume();
228        }
229      }
230    } else // mode normal
231    {
232      for (size_t i = 0; i < models.size(); i++) {
233        models.at(i)->pimpl_->UpdatePos();
234      }
235    }
236
237    driver->beginScene(true, true, video::SColor(255, 200, 200, 200));
238
239    // vue poursuite
240    //smgr->setActiveCamera(models.at(cam_id)->getFollowMeCamera()->getCameraSceneNode());
241    smgr->setActiveCamera(cameras.at(cam_id)->getCameraSceneNode());
242    driver->setViewPort(core::rect<s32>(0, 0, scene_width, scene_height));
243    smgr->drawAll(); // commente voir plus bas
244                     /*
245                 env->drawAll();
246                 if (font)
247                 {
248                                     font->draw(L"This demo shows that Irrlicht is also capable
249                 of drawing 2D graphics.",
250                                             core::rect<s32>(130,10,300,50),
251                                             video::SColor(255,255,255,255));
252                 }
253                 else
254                 {
255                 printf("err\n");
256                 }
257                 device->setWindowCaption(L"toto");*/
258
259    if (dbtFile_r == NULL) // mode normal
260    {
261      for (size_t i = 0; i < models.size(); i++) {
262        models.at(i)->pimpl_->CheckCollision();
263      }
264    }
265
266    for (size_t i = 0; i < models.size(); i++) {
267      models.at(i)->ProcessUpdate(NULL);
268    }
269
270    // on fait ca ici, devrait etre un peu plus haut
271    // mais a priori souci avec models.at(i)->pimpl_->CheckCollision();
272    // (setelipsoid?)
273    //smgr->setActiveCamera(models.at(cam_id)->getFollowMeCamera()->getCameraSceneNode());
274    smgr->setActiveCamera(cameras.at(cam_id)->getCameraSceneNode());
275    driver->setViewPort(core::rect<s32>(0, 0, scene_width, scene_height));
276    smgr->drawAll();
277
278    driver->endScene();
279
280    int fps = driver->getFPS();
281
282    if (lastFPS != fps) {
283      setWindowCaption(cam_id, fps);
284      lastFPS = fps;
285    }
286
287    if (receiver->IsKeyDown(KEY_PRIOR)) {
288      cam_id++;
289      if (cam_id >= (int)cameras.size()) cam_id = 0;
290      receiver->SetModel(getModelFromVisualizationCamera(models,cameras.at(cam_id)));
291      setWindowCaption(cam_id, fps);
292    }
293    if (receiver->IsKeyDown(KEY_NEXT)) {
294      cam_id--;
295      if (cam_id < 0) cam_id = cameras.size() - 1;
296      receiver->SetModel(getModelFromVisualizationCamera(models,cameras.at(cam_id)));
297      setWindowCaption(cam_id, fps);
298    }
299
300    // enregistrement DBT
301    if (receiver->IsKeyDown(KEY_KEY_R) && dbtFile_w == NULL) {
302      dbtFile_w = inithdFile((char *)"./record.dbt", UAV, dbtSize(models));
303      dbtbuf = (char *)malloc(dbtSize(models));
304    }
305    if (receiver->IsKeyDown(KEY_KEY_S) && dbtFile_w != NULL) {
306      close_hdfile(dbtFile_w);
307      dbtFile_w = NULL;
308      free(dbtbuf);
309      // rt_printf("stop rec\n");
310    }
311    if (dbtFile_w != NULL) {
312      Time time = GetTime();
313      vector3df vect;
314      char *buf = dbtbuf;
315
316      for (size_t i = 0; i < models.size(); i++) {
317        models.at(i)->WritedbtBuf(buf);
318        buf += models.at(i)->dbtSize();
319      }
320
321      write_hdfile(dbtFile_w, dbtbuf, (road_time_t)(time / 1000),
322                   (road_timerange_t)(time % 1000), dbtSize(models));
323    }
324
325    // lecture dbt
326    if (receiver->IsKeyDown(KEY_KEY_P) && dbtFile_r == NULL) {
327      dbtFile_r = open_hdfile((char *)"./record.dbt", READ_MODE);
328      dbtbuf = (char *)malloc(dbtSize(models));
329      // on suspend les models pour ne pas interferer
330      for (size_t i = 0; i < models.size(); i++) {
331        models.at(i)->pimpl_->Suspend();
332      }
333    }
334    if (receiver->IsKeyDown(KEY_KEY_S) && dbtFile_r != NULL) {
335      // rt_printf("stop play\n");
336      close_hdfile(dbtFile_r);
337      dbtFile_r = NULL;
338      free(dbtbuf);
339      // on resume les models
340      for (size_t i = 0; i < models.size(); i++) {
341        models.at(i)->pimpl_->Resume();
342      }
343    }
344  }
345
346  receiver->SetModel(NULL);
347}
348
349Model *Gui_impl::getModelFromVisualizationCamera(std::vector<Model *> models,VisualizationCamera *camera) {
350  for (size_t i = 0; i < models.size(); i++) {
351      if(models.at(i)->getFollowMeCamera()==camera) return models.at(i);
352  }
353  return NULL;
354}
355
356void Gui_impl::setWindowCaption(int cam_id, int fps) {
357  std::ostringstream text;
358
359  text << "Cam: " << cameras.at(cam_id)->getName().c_str()
360     << ", FPS: " << fps;
361
362  device->setWindowCaption(stringw(text.str().c_str()).c_str());
363}
364
365void Gui_impl::takeScreenshot(void) {
366  static int cpt = 0;
367  // get image from the last rendered frame
368  IImage *const image = driver->createScreenShot();
369  if (image) // should always be true, but you never know. ;)
370  {
371    // construct a filename, consisting of local time and file extension
372    c8 filename[64];
373    // snprintf(filename, 64, "screenshot_%u.png",
374    // device->getTimer()->getRealTime());
375    snprintf(filename, 64, "screenshot_%u.png", cpt);
376    cpt++;
377    // write screenshot to file
378    if (!driver->writeImageToFile(image, filename))
379      device->getLogger()->log(L"Failed to take screenshot.", ELL_WARNING);
380
381    // Don't forget to drop image since we don't need it anymore.
382    image->drop();
383  }
384}
385
386size_t Gui_impl::dbtSize(std::vector<Model *> models) {
387  size_t size = 0;
388  for (size_t i = 0; i < models.size(); i++) {
389    size += models.at(i)->dbtSize();
390  }
391
392  return size;
393}
394#endif // GL
Note: See TracBrowser for help on using the repository browser.