RigsofRods
Soft-body Physics Simulation
GUI_CollisionsDebug.cpp
Go to the documentation of this file.
1 /*
2  This source file is part of Rigs of Rods
3  Copyright 2005-2012 Pierre-Michel Ricordel
4  Copyright 2007-2012 Thomas Fischer
5  Copyright 2013-2022 Petr Ohlidal
6 
7  For more information, see http://www.rigsofrods.org/
8 
9  Rigs of Rods is free software: you can redistribute it and/or modify
10  it under the terms of the GNU General Public License version 3, as
11  published by the Free Software Foundation.
12 
13  Rigs of Rods is distributed in the hope that it will be useful,
14  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  GNU General Public License for more details.
17 
18  You should have received a copy of the GNU General Public License
19  along with Rigs of Rods. If not, see <http://www.gnu.org/licenses/>.
20 */
21 
22 #include "GUI_CollisionsDebug.h"
23 
24 #include "Application.h"
25 #include "Collisions.h"
26 #include "GameContext.h"
27 #include "GfxScene.h"
28 #include "GUIManager.h"
29 #include "GUIUtils.h"
30 #include "Language.h"
31 #include "RoRVersion.h"
32 #include "Terrain.h"
33 #include "Utils.h"
34 #include "RoRnet.h"
35 
36 #include "imgui_internal.h"
37 
38 using namespace RoR;
39 using namespace GUI;
40 using namespace Ogre;
41 
42 void CollisionsDebug::Draw()
43 {
44  GUIManager::GuiTheme const& theme = App::GetGuiManager()->GetTheme();
45 
46  ImGuiWindowFlags win_flags = ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize;
47  bool keep_open = true;
48  ImGui::Begin(_LC("About", "Static collision debug"), &keep_open, win_flags);
49 
50  ImGui::Text("Terrain name: %s", App::GetGameContext()->GetTerrain()->getTerrainName().c_str());
51  ImGui::Text("Terrain size: %.2fx%.2f meters", App::GetGameContext()->GetTerrain()->getMaxTerrainSize().x, App::GetGameContext()->GetTerrain()->getMaxTerrainSize().z);
52  ImGui::Checkbox("Draw labels", &m_draw_labels);
53  ImGui::Checkbox("Draw label types", &m_labels_draw_types);
54  ImGui::Checkbox("Sources on labels", &m_labels_draw_sources);
55  ImGui::Separator();
56 
57  // EVENTBOX
58  ImGui::PushID("EVENTBOX");
59  ImGui::TextColored(COLOR_EVENTBOX, "EVENTBOX");
60  ImGui::Text("Num event boxes: %d", (int)App::GetGameContext()->GetTerrain()->GetCollisions()->getCollisionBoxes().size());
61  if (ImGui::Checkbox("Show event boxes", &m_draw_collision_boxes))
62  {
63  this->SetDrawEventBoxes(m_draw_collision_boxes);
64  }
65  ImGui::SetNextItemWidth(WIDTH_DRAWDIST);
66  if (ImGui::InputFloat("Draw distance (meters, 0=unlimited)", &m_collision_box_draw_distance))
67  {
68  for (Ogre::SceneNode* snode : m_collision_boxes)
69  {
70  snode->getAttachedObject(0)->setRenderingDistance(m_collision_box_draw_distance);
71  }
72  }
73  if (m_collision_boxes.size() > 0)
74  {
75  if (ImGui::Button("Dump debug meshes (performance)."))
76  {
77  this->ClearEventBoxVisuals();
78  }
79  }
80  ImGui::Separator();
81  ImGui::PopID(); // EVENTBOX
82 
83  // COLLMESH
84  ImGui::PushID("COLLMESH");
85  ImGui::TextColored(COLOR_COLLMESH, "COLLMESH");
86  ImGui::Text("Num collision meshes: %d (%d tris)",
87  (int)App::GetGameContext()->GetTerrain()->GetCollisions()->getCollisionMeshes().size(),
88  (int)App::GetGameContext()->GetTerrain()->GetCollisions()->getCollisionTriangles().size());
89  if (ImGui::Checkbox("Show collision meshes", &m_draw_collision_meshes))
90  {
91  this->SetDrawCollisionMeshes(m_draw_collision_meshes);
92  }
93  ImGui::SetNextItemWidth(WIDTH_DRAWDIST);
94  if (ImGui::InputFloat("Draw distance (meters, 0=unlimited)", &m_collision_mesh_draw_distance))
95  {
96  for (Ogre::SceneNode* snode : m_collision_meshes)
97  {
98  snode->getAttachedObject(0)->setRenderingDistance(m_collision_mesh_draw_distance);
99  }
100  }
101  if (m_collision_meshes.size() > 0)
102  {
103  if (ImGui::Button("Dump debug meshes (performance)."))
104  {
105  this->ClearCollisionMeshVisuals();
106  }
107  }
108  ImGui::Separator();
109  ImGui::PopID(); // COLLMESH
110 
111  // CELL
112  ImGui::PushID("CELL");
113  ImGui::Text("CELL");
114  ImGui::Text("Occupancy: ");
115  for (int i = 0; i <= 10; i+=1)
116  {
117  ImGui::SameLine();
118  float f = i / 10.f;
119  ImVec4 color(f * 2.0, 2.0 * (1.0 - f), 0.2, 0.7);
120  int tris = static_cast<int>(f*Collisions::CELL_BLOCKSIZE);
121  ImGui::TextColored(color, "%d ", tris);
122  }
123  ImGui::SetNextItemWidth(WIDTH_DRAWDIST);
124  if (ImGui::InputInt("Debug area extent (around character)", &m_cell_generator_distance_limit));
125  ImGui::SameLine();
126  ImGui::TextDisabled("(?)");
127  if (ImGui::IsItemHovered())
128  {
129  ImGui::BeginTooltip();
130  ImGui::Text("To save memory and FPS, only cells around the characters will be visualized");
131  ImGui::EndTooltip();
132  }
133  if (ImGui::Checkbox("Show lookup cells (warning: slow!)", &m_draw_collision_cells))
134  {
135  this->SetDrawCollisionCells(m_draw_collision_cells);
136  }
137  ImGui::SetNextItemWidth(WIDTH_DRAWDIST);
138  if (ImGui::InputFloat("Draw distance (meters, 0=unlimited)", &m_collision_cell_draw_distance))
139  {
140  for (Ogre::SceneNode* snode : m_collision_cells)
141  {
142  snode->getAttachedObject(0)->setRenderingDistance(m_collision_cell_draw_distance);
143  }
144  }
145  if (m_collision_grid_root)
146  {
147  if (ImGui::Button("Dump debug meshes (performance)."))
148  {
149  this->ClearCollisionCellVisuals();
150  }
151  }
152  ImGui::PopID(); // CELL
153 
154  m_is_hovered = ImGui::IsWindowHovered(ImGuiHoveredFlags_RootAndChildWindows);
155  App::GetGuiManager()->RequestGuiCaptureKeyboard(m_is_hovered);
156 
157  ImGui::End();
158 
159  if (!keep_open)
160  {
161  this->SetVisible(false);
162  }
163 
164  // only draw reasonably close labels
165  const Ogre::Vector3 cam_pos = App::GetCameraManager()->GetCameraNode()->getPosition();
166 
167  if (m_draw_labels && m_draw_collision_boxes)
168  {
169  for (const collision_box_t& cbox : App::GetGameContext()->GetTerrain()->GetCollisions()->getCollisionBoxes())
170  {
171  if (IsDistanceWithin(cam_pos, this->GetCollBoxWorldPos(cbox), m_collision_box_draw_distance))
172  {
173  this->DrawCollisionBoxDebugText(cbox);
174  }
175  }
176  }
177 
178  if (m_draw_labels && m_draw_collision_meshes)
179  {
180  for (const collision_mesh_t& cmesh : App::GetGameContext()->GetTerrain()->GetCollisions()->getCollisionMeshes())
181  {
182  if (IsDistanceWithin(cam_pos, cmesh.position, m_collision_mesh_draw_distance))
183  {
184  this->DrawCollisionMeshDebugText(cmesh);
185  }
186  }
187  }
188 }
189 
190 void CollisionsDebug::AddCollisionMeshDebugMesh(collision_mesh_t const& coll_mesh)
191 {
192  // Gather data
193  const CollisionTriVec& ctris = App::GetGameContext()->GetTerrain()->GetCollisions()->getCollisionTriangles();
194 
195  // Create mesh
196  Ogre::ManualObject* debugmo = App::GetGfxScene()->GetSceneManager()->createManualObject();
197  debugmo->begin("tracks/debug/collision/triangle", RenderOperation::OT_TRIANGLE_LIST);
198  for (int i = 0; i < coll_mesh.collision_tri_count; i++)
199  {
200  collision_tri_t const& ctri = ctris[i + coll_mesh.collision_tri_start];
201  // The collision triangle vertices are in world coords, we want local coords.
202  debugmo->position(ctri.a - coll_mesh.position);
203  debugmo->position(ctri.b - coll_mesh.position);
204  debugmo->position(ctri.c - coll_mesh.position);
205  }
206  debugmo->end();
207  debugmo->setRenderingDistance(m_collision_mesh_draw_distance);
208  debugmo->setBoundingBox(AxisAlignedBox::BOX_INFINITE); // make infinite
209 
210  // Display mesh
211  SceneNode* debugsn = App::GetGfxScene()->GetSceneManager()->getRootSceneNode()->createChildSceneNode();
212  debugsn->setPosition(coll_mesh.position);
213  // NOTE: orientation and scale are already "baked" to the collision triangle positions, do not re-apply it here.
214  debugsn->attachObject(debugmo);
215 
216  // Submit mesh
217  m_collision_meshes.push_back(debugsn);
218 }
219 
220 void CollisionsDebug::AddCollisionBoxDebugMesh(collision_box_t const& coll_box)
221 {
222  int scripthandler = -1;
223  if (coll_box.eventsourcenum != -1)
224  scripthandler = App::GetGameContext()->GetTerrain()->GetCollisions()->getEventSource(coll_box.eventsourcenum).es_script_handler;
225 
226  SceneNode* debugsn = App::GetGfxScene()->GetSceneManager()->getRootSceneNode()->createChildSceneNode();
227 
228  debugsn->setPosition(coll_box.center);
229  // box content
230  ManualObject* mo = App::GetGfxScene()->GetSceneManager()->createManualObject();
231  String matName = "tracks/debug/collision/box";
232  if (coll_box.virt && scripthandler == -1)
233  matName = "tracks/debug/eventbox/unused";
234  else if (coll_box.virt)
235  matName = "tracks/debug/eventbox/used";
236  AxisAlignedBox aa;
237  for (int i = 0; i < 8; i++)
238  {
239  aa.merge(coll_box.debug_verts[i]);
240  }
241  mo->begin(matName, Ogre::RenderOperation::OT_TRIANGLE_LIST);
242  mo->position(coll_box.debug_verts[0]);
243  mo->position(coll_box.debug_verts[1]);
244  mo->position(coll_box.debug_verts[2]);
245  mo->position(coll_box.debug_verts[3]);
246  mo->position(coll_box.debug_verts[4]);
247  mo->position(coll_box.debug_verts[5]);
248  mo->position(coll_box.debug_verts[6]);
249  mo->position(coll_box.debug_verts[7]);
250 
251  // front
252  mo->triangle(0, 1, 2);
253  mo->triangle(1, 3, 2);
254  // right side
255  mo->triangle(3, 1, 5);
256  mo->triangle(5, 7, 3);
257  // left side
258  mo->triangle(6, 4, 0);
259  mo->triangle(0, 2, 6);
260  // back side
261  mo->triangle(7, 5, 4);
262  mo->triangle(4, 6, 7);
263  // bottom
264  mo->triangle(5, 4, 1);
265  mo->triangle(4, 0, 1);
266  // top
267  mo->triangle(2, 3, 6);
268  mo->triangle(3, 7, 6);
269 
270  mo->end();
271  mo->setBoundingBox(aa);
272  mo->setRenderingDistance(200);
273  debugsn->attachObject(mo);
274 
275  // the border
276  mo = App::GetGfxScene()->GetSceneManager()->createManualObject();
277  mo->begin(matName, Ogre::RenderOperation::OT_LINE_LIST);
278  mo->position(coll_box.debug_verts[0]);
279  mo->position(coll_box.debug_verts[1]);
280  mo->position(coll_box.debug_verts[2]);
281  mo->position(coll_box.debug_verts[3]);
282  mo->position(coll_box.debug_verts[4]);
283  mo->position(coll_box.debug_verts[5]);
284  mo->position(coll_box.debug_verts[6]);
285  mo->position(coll_box.debug_verts[7]);
286  //front
287  mo->index(0); mo->index(1); mo->index(1); mo->index(3); mo->index(3); mo->index(2); mo->index(2); mo->index(0);
288  // right side
289  mo->index(1); mo->index(5); mo->index(5); mo->index(7); mo->index(7); mo->index(3); mo->index(3); mo->index(1);
290  // left side
291  mo->index(0); mo->index(2); mo->index(2); mo->index(6); mo->index(6); mo->index(4); mo->index(4); mo->index(0);
292  // back side
293  mo->index(5); mo->index(4); mo->index(4); mo->index(6); mo->index(6); mo->index(7); mo->index(7); mo->index(5);
294  // bottom and top not needed
295  mo->end();
296  mo->setBoundingBox(aa);
297  debugsn->attachObject(mo);
298  mo->setRenderingDistance(200);
299 
300  m_collision_boxes.push_back(debugsn);
301 }
302 
303 Ogre::Vector3 CollisionsDebug::GetCollBoxWorldPos(collision_box_t const& coll_box)
304 {
305  return Vector3(coll_box.lo + (coll_box.hi - coll_box.lo) * 0.5f);
306 }
307 
308 void CollisionsDebug::DrawCollisionMeshDebugText(collision_mesh_t const& coll_mesh)
309 {
310  const char* label_type_str = (m_labels_draw_types) ? "COLLMESH\n" : "";
311  const char* ground_model_str = (coll_mesh.ground_model) ? coll_mesh.ground_model->name : "(multiple)";
312 
313  std::string caption = fmt::format("{}meshname:{}\ngroundmodel:{}",
314  label_type_str, coll_mesh.mesh_name, ground_model_str);
315  if (m_labels_draw_sources)
316  {
317  caption += fmt::format("\nsource:{}", coll_mesh.source_name);
318  }
319 
320  this->DrawLabelAtWorldPos(caption, coll_mesh.position, COLOR_COLLMESH);
321 }
322 
323 void CollisionsDebug::DrawCollisionBoxDebugText(collision_box_t const& coll_box)
324 {
325  if (!coll_box.virt || coll_box.eventsourcenum == -1)
326  return;
327 
328  eventsource_t const& eventsource = App::GetGameContext()->GetTerrain()->GetCollisions()->getEventSource(coll_box.eventsourcenum);
329  const char* type_str = (m_labels_draw_types) ? "EVENTBOX\n" : "";
330 
331  this->DrawLabelAtWorldPos(
332  fmt::format("{}event:{}\ninstance:{}\nhandler:{}", type_str,
333  eventsource.es_box_name, eventsource.es_instance_name, eventsource.es_script_handler),
334  this->GetCollBoxWorldPos(coll_box), COLOR_EVENTBOX);
335 }
336 
337 void CollisionsDebug::DrawLabelAtWorldPos(std::string const& caption, Ogre::Vector3 const& world_pos, ImVec4 const& text_color)
338 {
339  // ----- BEGIN COPYPASTE FROM GfxScene::DrawNetLabel ----
340 
341  ImVec2 screen_size = ImGui::GetIO().DisplaySize;
342  World2ScreenConverter world2screen(
343  App::GetCameraManager()->GetCamera()->getViewMatrix(true), App::GetCameraManager()->GetCamera()->getProjectionMatrix(), Ogre::Vector2(screen_size.x, screen_size.y));
344 
345  Ogre::Vector3 pos_xyz = world2screen.Convert(world_pos);
346 
347  // only draw when in front of camera
348  if (pos_xyz.z < 0.f)
349  {
350  // Align position to whole pixels, to minimize jitter.
351  ImVec2 pos((int)pos_xyz.x + 0.5, (int)pos_xyz.y + 0.5);
352 
353  ImVec2 text_size = ImGui::CalcTextSize(caption.c_str());
354  GUIManager::GuiTheme const& theme = App::GetGuiManager()->GetTheme();
355 
356  ImDrawList* drawlist = GetImDummyFullscreenWindow();
357  ImGuiContext* g = ImGui::GetCurrentContext();
358 
359  ImVec2 text_pos(pos.x - ((text_size.x / 2)), pos.y - ((text_size.y / 2)));
360 
361  // Draw background rectangle
362  const float PADDING = 4.f;
363  drawlist->AddRectFilled(
364  text_pos - ImVec2(PADDING, PADDING),
365  text_pos + text_size + ImVec2(PADDING, PADDING),
366  ImColor(theme.semitransparent_window_bg),
367  ImGui::GetStyle().WindowRounding);
368 
369  // draw colored text
370  drawlist->AddText(g->Font, g->FontSize, text_pos, ImColor(text_color), caption.c_str());
371  }
372  // ---- END COPYPASTE ----
373 }
374 
375 void CollisionsDebug::CleanUp()
376 {
377  // EVENTBOX
378  this->ClearEventBoxVisuals();
379 
380  // COLLMESH
381  this->ClearCollisionMeshVisuals();
382 
383  // CELLS
384  this->ClearCollisionCellVisuals();
385 }
386 
387 void CollisionsDebug::GenerateCellDebugMaterials()
388 {
389  if (MaterialManager::getSingleton().getByName("mat-coll-dbg-0", ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME))
390  {
391  return; // already generated before
392  }
393 
394  // create materials
395  int i = 0;
396  char bname[256];
397  for (i = 0; i <= 100; i++)
398  {
399  // register a material for skeleton view
400  sprintf(bname, "mat-coll-dbg-%d", i);
401  MaterialPtr mat = (MaterialPtr)(MaterialManager::getSingleton().create(bname, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME));
402  float f = fabs(((float)i) / 100);
403  Pass* p = mat->getTechnique(0)->getPass(0); //
404  p->createTextureUnitState()->setColourOperationEx(LBX_MODULATE, LBS_MANUAL, LBS_CURRENT, ColourValue(f * 2.0, 2.0 * (1.0 - f), 0.2, 0.7));
405  p->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
406  p->setLightingEnabled(false);
407  p->setDepthWriteEnabled(false);
408  p->setDepthBias(3, 3);
409  p->setCullingMode(Ogre::CULL_NONE);
410 
411  Pass* p2 = mat->getTechnique(0)->createPass();
412  p2->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
413  p2->setLightingEnabled(false);
414  p2->setDepthWriteEnabled(false);
415  p2->setDepthBias(3, 3);
416  p2->setCullingMode(Ogre::CULL_NONE);
417  p2->setSceneBlending(Ogre::SBT_TRANSPARENT_ALPHA);
418  TextureUnitState* tus2 = p2->createTextureUnitState();
419  tus2->setTextureName("tile.png");
420 
421 
422  mat->setLightingEnabled(false);
423  mat->setReceiveShadows(false);
424  }
425 }
426 
427 void CollisionsDebug::SetDrawEventBoxes(bool val)
428 {
429  m_draw_collision_boxes = val;
430 
431  // Initial fill
432  if (m_draw_collision_boxes && m_collision_boxes.size() == 0)
433  {
434  for (const collision_box_t& cbox : App::GetGameContext()->GetTerrain()->GetCollisions()->getCollisionBoxes())
435  {
436  this->AddCollisionBoxDebugMesh(cbox);
437  }
438  }
439  // Update visibility
440  for (Ogre::SceneNode* snode : m_collision_boxes)
441  {
442  snode->setVisible(m_draw_collision_boxes);
443  }
444 }
445 
446 void CollisionsDebug::SetDrawCollisionMeshes(bool val)
447 {
448  m_draw_collision_meshes = val;
449 
450  // Initial setup
451  if (m_draw_collision_meshes && m_collision_meshes.size() == 0)
452  {
453  for (const collision_mesh_t& cmesh : App::GetGameContext()->GetTerrain()->GetCollisions()->getCollisionMeshes())
454  {
455  this->AddCollisionMeshDebugMesh(cmesh);
456  }
457  }
458  // Update visibility
459  for (Ogre::SceneNode* snode : m_collision_meshes)
460  {
461  snode->setVisible(m_draw_collision_meshes);
462  }
463 }
464 
465 void CollisionsDebug::SetDrawCollisionCells(bool val)
466 {
467  m_draw_collision_cells = val;
468 
469  // Initial setup
470  if (m_draw_collision_cells && !m_collision_grid_root)
471  {
472  this->GenerateCellDebugMaterials();
473  m_collision_grid_root = App::GetGfxScene()->GetSceneManager()->getRootSceneNode()->createChildSceneNode();
474  // For memory (including VRAM) and performance reasons, only generate meshes up to a certain distance from the character.
475  AxisAlignedBox aabb;
476  aabb.setMinimum(App::GetGameContext()->GetPlayerCharacter()->getPosition() + Ogre::Vector3(-m_cell_generator_distance_limit, 0, -m_cell_generator_distance_limit));
477  aabb.getMinimum().y = -FLT_MAX; // vertical axis
478  aabb.setMaximum(App::GetGameContext()->GetPlayerCharacter()->getPosition() + Ogre::Vector3(m_cell_generator_distance_limit, 0, m_cell_generator_distance_limit));
479  aabb.getMaximum().y = FLT_MAX; // vertical axis
480  try
481  {
482  App::GetGameContext()->GetTerrain()->GetCollisions()->createCollisionDebugVisualization(m_collision_grid_root, aabb, m_collision_cells);
483  }
484  catch (std::bad_alloc const& allocex)
485  {
486  App::GetConsole()->putMessage(Console::CONSOLE_MSGTYPE_INFO, Console::CONSOLE_SYSTEM_ERROR,
487  fmt::format("Could not create debug view, error: {}", allocex.what()));
488  this->ClearCollisionCellVisuals();
489  }
490  }
491  // Update visibility
492  if (m_collision_grid_root)
493  {
494  m_collision_grid_root->setVisible(m_draw_collision_cells);
495  }
496 }
497 
498 void CollisionsDebug::ClearCollisionMeshVisuals()
499 {
500  for (Ogre::SceneNode* snode : m_collision_meshes)
501  {
502  Entity* ent = static_cast<Entity*>(snode->getAttachedObject(0));
503  App::GetGfxScene()->GetSceneManager()->destroyEntity(ent);
504  App::GetGfxScene()->GetSceneManager()->destroySceneNode(snode);
505  }
506  m_collision_meshes.clear();
507  m_draw_collision_meshes = false;
508  m_collision_mesh_draw_distance = DEFAULT_DRAWDIST;
509 }
510 
511 void CollisionsDebug::ClearEventBoxVisuals()
512 {
513  for (Ogre::SceneNode* snode : m_collision_boxes)
514  {
515  Entity* ent = static_cast<Entity*>(snode->getAttachedObject(0));
516  App::GetGfxScene()->GetSceneManager()->destroyEntity(ent);
517  App::GetGfxScene()->GetSceneManager()->destroySceneNode(snode);
518  }
519  m_collision_boxes.clear();
520  m_draw_collision_boxes = false;
521  m_collision_box_draw_distance = DEFAULT_DRAWDIST;
522 }
523 
524 void CollisionsDebug::ClearCollisionCellVisuals()
525 {
526  for (Ogre::SceneNode* snode : m_collision_cells)
527  {
528  ManualObject* mo = static_cast<ManualObject*>(snode->getAttachedObject(0));
529  App::GetGfxScene()->GetSceneManager()->destroyManualObject(mo);
530  }
531  m_collision_cells.clear();
532  m_draw_collision_cells = false;
533  m_collision_cell_draw_distance = DEFAULT_DRAWDIST;
534 
535  if (m_collision_grid_root)
536  {
537  m_collision_grid_root->removeAndDestroyAllChildren();
538  App::GetGfxScene()->GetSceneManager()->destroySceneNode(m_collision_grid_root);
539  m_collision_grid_root = nullptr;
540  }
541 }
542 
543 void CollisionsDebug::SetVisible(bool v)
544 {
545  if (!v)
546  {
547  this->SetDrawEventBoxes(false);
548  this->SetDrawCollisionMeshes(false);
549  this->SetDrawCollisionCells(false);
550  }
551  m_is_visible = v;
552 }
GameContext.h
Game state manager and message-queue provider.
RoR::GUI::CollisionsDebug::GenerateCellDebugMaterials
void GenerateCellDebugMaterials()
Definition: GUI_CollisionsDebug.cpp:387
RoR::GUIManager::GuiTheme
Definition: GUIManager.h:70
RoR::App::GetCameraManager
CameraManager * GetCameraManager()
Definition: Application.cpp:275
RoR::GUI::CollisionsDebug::ClearEventBoxVisuals
void ClearEventBoxVisuals()
Definition: GUI_CollisionsDebug.cpp:511
RoR::collision_tri_t
Definition: Collisions.h:50
RoR::App::GetGuiManager
GUIManager * GetGuiManager()
Definition: Application.cpp:269
RoR::collision_box_t::virt
bool virt
Definition: SimData.h:715
RoR::eventsource_t::es_instance_name
std::string es_instance_name
Specified by user when calling "GameScript::spawnObject()".
Definition: Collisions.h:42
z
float z
Definition: (ValueTypes) quaternion.h:7
RoR::collision_mesh_t
Records which collision triangles belong to which mesh.
Definition: Collisions.h:64
RoR::GUI::CollisionsDebug::SetDrawEventBoxes
void SetDrawEventBoxes(bool val)
Definition: GUI_CollisionsDebug.cpp:427
RoR::eventsource_t
< Scripting
Definition: Collisions.h:40
format
Truck file format(technical spec)
RoR::collision_box_t::lo
Ogre::Vector3 lo
absolute collision box
Definition: SimData.h:722
GUIUtils.h
RoR::collision_box_t::eventsourcenum
short eventsourcenum
Definition: SimData.h:721
RoR::collision_box_t::hi
Ogre::Vector3 hi
absolute collision box
Definition: SimData.h:723
RoR::Collisions::CELL_BLOCKSIZE
static const int CELL_BLOCKSIZE
Definition: Collisions.h:170
RoR::Collisions::getCollisionTriangles
CollisionTriVec const & getCollisionTriangles() const
Definition: Collisions.h:220
RoR::Console::putMessage
void putMessage(MessageArea area, MessageType type, std::string const &msg, std::string icon="")
Definition: Console.cpp:97
RoR::CameraManager::GetCameraNode
Ogre::SceneNode * GetCameraNode()
Definition: CameraManager.h:63
Utils.h
Language.h
RoR::GUIManager::GuiTheme::semitransparent_window_bg
ImVec4 semitransparent_window_bg
Definition: GUIManager.h:83
RoR::collision_box_t
Definition: SimData.h:713
RoR::World2ScreenConverter::Convert
Ogre::Vector3 Convert(Ogre::Vector3 world_pos)
Definition: Utils.h:89
RoR::Console::CONSOLE_SYSTEM_ERROR
@ CONSOLE_SYSTEM_ERROR
Definition: Console.h:52
GUIManager.h
RoR::GUI::CollisionsDebug::DrawCollisionBoxDebugText
void DrawCollisionBoxDebugText(collision_box_t const &coll_box)
Definition: GUI_CollisionsDebug.cpp:323
RoR::collision_box_t::center
Ogre::Vector3 center
center of rotation
Definition: SimData.h:724
RoR::GfxScene::GetSceneManager
Ogre::SceneManager * GetSceneManager()
Definition: GfxScene.h:64
RoR::GUI::CollisionsDebug::ClearCollisionMeshVisuals
void ClearCollisionMeshVisuals()
Definition: GUI_CollisionsDebug.cpp:498
RoR::collision_tri_t::a
Ogre::Vector3 a
Definition: Collisions.h:52
RoR::collision_mesh_t::collision_tri_count
int collision_tri_count
Definition: Collisions.h:74
RoR::GUIManager::GetTheme
GuiTheme & GetTheme()
Definition: GUIManager.h:158
RoR::GUI::CollisionsDebug::AddCollisionBoxDebugMesh
void AddCollisionBoxDebugMesh(collision_box_t const &coll_box)
Definition: GUI_CollisionsDebug.cpp:220
RoR::collision_mesh_t::collision_tri_start
int collision_tri_start
Definition: Collisions.h:73
RoR::GUI::CollisionsDebug::DrawCollisionMeshDebugText
void DrawCollisionMeshDebugText(collision_mesh_t const &coll_mesh)
Definition: GUI_CollisionsDebug.cpp:308
RoR::GUI::CollisionsDebug::AddCollisionMeshDebugMesh
void AddCollisionMeshDebugMesh(collision_mesh_t const &coll_mesh)
Definition: GUI_CollisionsDebug.cpp:190
RoR::GUI::CollisionsDebug::ClearCollisionCellVisuals
void ClearCollisionCellVisuals()
Definition: GUI_CollisionsDebug.cpp:524
RoR::eventsource_t::es_box_name
std::string es_box_name
Specified in ODEF file as "event".
Definition: Collisions.h:43
RoR::GetImDummyFullscreenWindow
ImDrawList * GetImDummyFullscreenWindow()
Definition: GUIUtils.cpp:355
RoR::World2ScreenConverter
< Keeps data close for faster access.
Definition: Utils.h:81
RoR::collision_mesh_t::ground_model
ground_model_t * ground_model
Definition: Collisions.h:72
RoR::Terrain::GetCollisions
Collisions * GetCollisions()
Definition: Terrain.h:83
GfxScene.h
Application.h
Central state/object manager and communications hub.
RoR::App::GetConsole
Console * GetConsole()
Definition: Application.cpp:270
RoR::GUI::CollisionsDebug::Draw
void Draw()
Definition: GUI_CollisionsDebug.cpp:42
RoR::App::GetGameContext
GameContext * GetGameContext()
Definition: Application.cpp:280
RoR::ground_model_t::name
char name[256]
Definition: SimData.h:762
RoR::GUI::CollisionsDebug::DrawLabelAtWorldPos
void DrawLabelAtWorldPos(std::string const &caption, Ogre::Vector3 const &world_pos, ImVec4 const &text_color)
Definition: GUI_CollisionsDebug.cpp:337
RoRVersion.h
RoR::eventsource_t::es_script_handler
int es_script_handler
AngelScript function ID.
Definition: Collisions.h:45
RoR::CollisionTriVec
std::vector< collision_tri_t > CollisionTriVec
Definition: Collisions.h:61
_LC
#define _LC(ctx, str)
Definition: Language.h:42
RoR::Collisions::createCollisionDebugVisualization
void createCollisionDebugVisualization(Ogre::SceneNode *root_node, Ogre::AxisAlignedBox const &area_limit, std::vector< Ogre::SceneNode * > &out_nodes)
Definition: Collisions.cpp:1315
RoR::GUI::CollisionsDebug::SetVisible
void SetVisible(bool v)
Definition: GUI_CollisionsDebug.cpp:543
RoR::GUI::CollisionsDebug::CleanUp
void CleanUp()
Definition: GUI_CollisionsDebug.cpp:375
RoR::Collisions::getEventSource
eventsource_t & getEventSource(int pos)
Definition: Collisions.h:217
RoR::GUI::CollisionsDebug::SetDrawCollisionMeshes
void SetDrawCollisionMeshes(bool val)
Definition: GUI_CollisionsDebug.cpp:446
Terrain.h
RoR::collision_tri_t::b
Ogre::Vector3 b
Definition: Collisions.h:53
RoR::collision_box_t::debug_verts
Ogre::Vector3 debug_verts[8]
box corners in absolute world position
Definition: SimData.h:733
Ogre
Definition: ExtinguishableFireAffector.cpp:35
RoR::Console::CONSOLE_MSGTYPE_INFO
@ CONSOLE_MSGTYPE_INFO
Generic message.
Definition: Console.h:60
RoR::GUI::CollisionsDebug::GetCollBoxWorldPos
Ogre::Vector3 GetCollBoxWorldPos(collision_box_t const &coll_box)
Definition: GUI_CollisionsDebug.cpp:303
Collisions.h
RoR::collision_mesh_t::source_name
std::string source_name
Definition: Collisions.h:67
RoR::GUI::CollisionsDebug::SetDrawCollisionCells
void SetDrawCollisionCells(bool val)
Definition: GUI_CollisionsDebug.cpp:465
RoR::collision_tri_t::c
Ogre::Vector3 c
Definition: Collisions.h:54
RoR::GUIManager::RequestGuiCaptureKeyboard
void RequestGuiCaptureKeyboard(bool val)
Pass true during frame to prevent input passing to application.
Definition: GUIManager.cpp:450
RoR
Definition: AppContext.h:36
x
float x
Definition: (ValueTypes) quaternion.h:5
RoR::App::GetGfxScene
GfxScene * GetGfxScene()
Definition: Application.cpp:276
RoR::collision_mesh_t::position
Ogre::Vector3 position
Definition: Collisions.h:68
GUI_CollisionsDebug.h
RoR::IsDistanceWithin
bool IsDistanceWithin(Ogre::Vector3 const &a, Ogre::Vector3 const &b, float max)
Definition: Utils.cpp:158
RoR::collision_mesh_t::mesh_name
std::string mesh_name
Definition: Collisions.h:66
RoR::GameContext::GetTerrain
const TerrainPtr & GetTerrain()
Definition: GameContext.h:117
Generated by   doxygen 1.8.17