implement dark theme

minimap creator: make filters work

CMakeLists.txt

@@ -209,10 +209,11 @@ ENDIF()
 includePlattform("postfind")
 
 include_directories ("${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/tmp")
-include_directories(PRIVATE ${CMAKE_BINARY_DIR})
+include_directories(PRIVATE ${CMAKE_CURRENT_BINARY_DIR})
 
 # And do the job.
 INCLUDE_DIRECTORIES("${CMAKE_SOURCE_DIR}/src" )
+INCLUDE_DIRECTORIES("${CMAKE_SOURCE_DIR}/src/noggit/ui/style/framelesswindow" )
 COLLECT_FILES(false noggit_root_sources src/noggit .cpp)
 COLLECT_FILES(true noggit_ui_sources src/noggit/ui .cpp)
 COLLECT_FILES(false math_sources src/math .cpp)

src/noggit/MapView.cpp

@@ -2373,7 +2373,7 @@ selection_result MapView::intersect_result(bool terrain_only)
     ( model_view().transposed()
     , intersect_ray()
     , terrain_only
-    , terrainMode == editing_mode::object
+    , terrainMode == editing_mode::object || terrainMode == editing_mode::minimap
     , _draw_terrain.get()
     , _draw_wmo.get()
     , _draw_models.get()

src/noggit/World.cpp

@@ -1911,7 +1911,7 @@ void World::drawMinimap ( MapTile *tile
   }
 
   // M2s / models
-  if (settings->draw_m2)
+  if (settings->draw_m2 || settings->use_filters)
   {
 
     if (need_model_updates)
@@ -1936,10 +1936,54 @@ void World::drawMinimap ( MapTile *tile
 
       for (auto &it : _models_by_filename)
       {
+        std::vector<ModelInstance*> instances;
+
+        if (settings->use_filters)
+        {
+          instances = it.second;
+          for (auto instance : it.second)
+          {
+            bool found_model = false;
+            bool found_instance = false;
+
+            for (int i = 0; i < settings->m2_model_filter_include->count(); ++i)
+            {
+              auto item_wgt_m = reinterpret_cast<noggit::ui::MinimapM2ModelFilterEntry *>(
+                  settings->m2_model_filter_include->itemWidget(settings->m2_model_filter_include->item(i)));
+
+              if (item_wgt_m->getFileName().toStdString() == instance->model->filename
+                  && item_wgt_m->getSizeCategory() <= instance->size_cat)
+              {
+                found_model = true;
+              }
+            }
+
+            for (int i = 0; i < settings->m2_instance_filter_include->count(); ++i)
+            {
+              auto item_wgt_i = reinterpret_cast<noggit::ui::MinimapInstanceFilterEntry*>(
+                  settings->m2_instance_filter_include->itemWidget(settings->m2_instance_filter_include->item(i)));
+
+              if (item_wgt_i->getUid() == instance->uid)
+              {
+                found_instance = true;
+              }
+            }
+
+            if (!(found_model || found_instance))
+            {
+              std::vector<ModelInstance*>::iterator position = std::find(instances.begin(), instances.end(), instance);
+              if (position != instances.end())
+              {
+                instances.erase(position);
+              }
+            }
+          }
+        }
+
         it.second[0]->model->wait_until_loaded();
-        it.second[0]->model->draw(model_view, it.second, m2_shader, frustum, culldistance, camera_pos, false,
-                                  animtime, false, false, model_with_particles,
-                                  model_boxes_to_draw, display_mode::in_2D
+        it.second[0]->model->draw(model_view, settings->use_filters ? instances : it.second, m2_shader, frustum,
+                                  culldistance, camera_pos, false,animtime, false,
+                                  false, model_with_particles,model_boxes_to_draw, display_mode::in_2D
         );
       }
 
@@ -1984,16 +2028,52 @@ void World::drawMinimap ( MapTile *tile
     wmo_program.uniform("exterior_diffuse_color", diffuse_color);
     wmo_program.uniform("exterior_ambient_color", ambient_color);
 
-    _model_instance_storage.for_each_wmo_instance([&](WMOInstance &wmo)
-                                                  {
-                                                    wmo.wmo->wait_until_loaded();
-                                                    wmo.draw(wmo_program, model_view, projection, frustum,
-                                                             culldistance, camera_pos, false, false,
-                                                             false, _liquid_render.get(), current_selection(),
-                                                             animtime, skies->hasSkies(), display_mode::in_2D
-                                                    );
+    _model_instance_storage.for_each_wmo_instance(
+        [&](WMOInstance &wmo)
+        {
+          if (settings->use_filters)
+          {
+            bool found_model = false;
+            bool found_instance = false;
 
-                                                  });
+            for (int i = 0; i < settings->wmo_model_filter_exclude->count(); ++i)
+            {
+              auto item_wgt_m = reinterpret_cast<noggit::ui::MinimapWMOModelFilterEntry*>(
+                  settings->wmo_model_filter_exclude->itemWidget(settings->wmo_model_filter_exclude->item(i)));
+
+              if (item_wgt_m->getFileName().toStdString() == wmo.wmo->filename)
+              {
+                found_model = true;
+              }
+            }
+
+            for (int i = 0; i < settings->wmo_instance_filter_exclude->count(); ++i)
+            {
+              auto item_wgt_i = reinterpret_cast<noggit::ui::MinimapInstanceFilterEntry*>(
+                  settings->wmo_instance_filter_exclude->itemWidget(settings->wmo_instance_filter_exclude->item(i)));
+
+              if (item_wgt_i->getUid() == wmo.mUniqueID)
+              {
+                found_instance = true;
+              }
+            }
+
+            // For WMOs we exclude models from rendering
+            if (found_model || found_instance)
+            {
+              return;
+            }
+
+          }
+
+          wmo.wmo->wait_until_loaded();
+          wmo.draw(wmo_program, model_view, projection, frustum,
+                   culldistance, camera_pos, false, false,
+                   false, _liquid_render.get(), current_selection(),
+                   animtime, skies->hasSkies(), display_mode::in_2D
+          );
+
+        });
 
     gl.enable(GL_BLEND);
     gl.blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

src/noggit/World.h

@@ -161,6 +161,7 @@ public:
   boost::optional<selection_type> get_last_selected_model() const;
   bool has_selection() const { return !_current_selection.empty(); }
   bool has_multiple_model_selected() const { return _selected_model_count > 1; }
+  int get_selected_model_count() const { return _selected_model_count; }
   void set_current_selection(selection_type entry);
   void add_to_selection(selection_type entry);
   void remove_from_selection(selection_type entry);

src/noggit/application.cpp

@@ -290,19 +290,9 @@ Noggit::Noggit(int argc, char *argv[])
 
   qApp->setStyle(new DarkStyle);
 
-  // create frameless window (and set windowState or title)
-  FramelessWindow framelessWindow;
-  framelessWindow.setWindowState(Qt::WindowMaximized);
-  framelessWindow.setWindowTitle("Noggit Red");
-  //framelessWindow.setWindowIcon(a.style()->standardIcon(QStyle::SP_DesktopIcon));
-
-
   main_window = std::make_unique<noggit::ui::main_window>();
-  // add the mainwindow to our custom frameless window
-  framelessWindow.setContent(main_window.get());
-  framelessWindow.showMaximized();
 
-  /*if (fullscreen)
+  if (fullscreen)
   {
     main_window->showFullScreen();
   }
@@ -310,7 +300,6 @@ Noggit::Noggit(int argc, char *argv[])
   {
     main_window->showMaximized();
   }
-  */
 }
 
 namespace
@@ -366,12 +355,5 @@ int main(int argc, char *argv[])
 
   Noggit app (argc, argv);
 
-
-  QFile File("./themes/dark/theme.qss");
-  File.open(QFile::ReadOnly);
-  QString StyleSheet = QLatin1String(File.readAll());
-
-  qapp.setStyleSheet(StyleSheet);
-
   return qapp.exec();
 }

src/noggit/tool_enums.hpp

@@ -70,7 +70,8 @@ enum class editing_mode
   water,
   mccv,
   object,
-  minimap
+  minimap,
+  stamp
 };
 
 enum water_opacity

src/noggit/ui/MinimapCreator.cpp

@@ -125,42 +125,164 @@ namespace noggit
       draw_elevation->setChecked(_render_settings.draw_elevation);
       render_settings_box_layout->addRow (draw_elevation);
 
+      auto use_filters = new QCheckBox("Use filters", render_settings_box);
+      use_filters->setChecked(_render_settings.use_filters);
+      render_settings_box_layout->addRow (use_filters);
+
       _progress_bar = new QProgressBar(this);
       _progress_bar->setRange(0, 4096);
       generate_layout->addRow (_progress_bar);
 
       // Filter
       auto filter_widget = new QWidget(this);
+      filter_widget->setContentsMargins(0, 0, 0, 0);
       auto filter_layout = new QFormLayout(filter_widget);
+      filter_layout->setContentsMargins(0, 0, 0, 0);
 
       settings_tabs->addTab(filter_widget, "Filter");
 
-      auto m2_include_box = new QGroupBox("Render options", filter_widget);
-      filter_layout->addRow(m2_include_box);
+      auto filter_tabs = new QTabWidget(filter_widget);
+      filter_tabs->setTabPosition(QTabWidget::East);
+      filter_tabs->setDocumentMode(true);
+      filter_layout->addRow(filter_tabs);
 
-      auto m2_include_box_layout = new QFormLayout (m2_include_box);
+      // M2 model include tab
+      auto m2_include_widget = new QWidget(filter_tabs);
+      filter_tabs->addTab(m2_include_widget, "M2 Model");
 
-      _m2_model_filter_include = new QListWidget(m2_include_box);
+      auto m2_include_box_layout = new QFormLayout(m2_include_widget);
+      m2_include_box_layout->setContentsMargins(0, 0, 0, 0);
+      m2_include_widget->setLayout(m2_include_box_layout);
+
+      auto search_filter_m2 = new QLineEdit(this);
+      search_filter_m2->setMinimumWidth(220);
+      m2_include_box_layout->addRow("Filter:", search_filter_m2);
+
+      _m2_model_filter_include = new QListWidget(m2_include_widget);
       _render_settings.m2_model_filter_include = _m2_model_filter_include;
+      _m2_model_filter_include->setAlternatingRowColors(true);
 
       m2_include_box_layout->addRow(_m2_model_filter_include);
 
-      auto m2_include_box_layout_btns = new QHBoxLayout(m2_include_box);
+      auto m2_include_box_layout_btns = new QHBoxLayout(m2_include_widget);
       m2_include_box_layout->addRow(m2_include_box_layout_btns);
 
-      auto add_btn = new QPushButton(m2_include_box);
+      auto add_btn = new QPushButton("Add", m2_include_widget);
       add_btn->setIcon(font_awesome_icon(font_awesome::plus));
       m2_include_box_layout_btns->addWidget(add_btn);
 
-      auto remove_btn = new QPushButton(m2_include_box);
+      auto remove_btn = new QPushButton("Remove", m2_include_widget);
       remove_btn->setIcon(font_awesome_icon(font_awesome::timescircle));
       m2_include_box_layout_btns->addWidget(remove_btn);
 
+      auto clear_btn = new QPushButton("Clear all", m2_include_widget);
+      clear_btn->setIcon(font_awesome_icon(font_awesome::trash));
+      m2_include_box_layout_btns->addWidget(clear_btn);
+
+      // M2 instance include tab
+      auto m2_instance_include_widget = new QWidget(filter_tabs);
+      filter_tabs->addTab(m2_instance_include_widget, "M2 Instance");
+
+      auto m2_instance_include_box_layout = new QFormLayout(m2_instance_include_widget);
+      m2_instance_include_box_layout->setContentsMargins(0, 0, 0, 0);
+      m2_instance_include_widget->setLayout(m2_instance_include_box_layout);
+
+      auto search_filter_m2i = new QLineEdit(this);
+      search_filter_m2i->setMinimumWidth(220);
+      m2_instance_include_box_layout->addRow("Filter:", search_filter_m2i);
+
+      _m2_instance_filter_include = new QListWidget(m2_instance_include_widget);
+      _render_settings.m2_instance_filter_include = _m2_instance_filter_include;
+      _m2_instance_filter_include->setAlternatingRowColors(true);
+
+      m2_instance_include_box_layout->addRow(_m2_instance_filter_include);
+
+      auto m2_instance_include_box_layout_btns = new QHBoxLayout(m2_instance_include_widget);
+      m2_instance_include_box_layout->addRow(m2_instance_include_box_layout_btns);
+
+      auto add_btn_m2i = new QPushButton("Add", m2_instance_include_widget);
+      add_btn_m2i->setIcon(font_awesome_icon(font_awesome::plus));
+      m2_instance_include_box_layout_btns->addWidget(add_btn_m2i);
+
+      auto remove_btn_m2i = new QPushButton("Remove", m2_instance_include_widget);
+      remove_btn_m2i->setIcon(font_awesome_icon(font_awesome::timescircle));
+      m2_instance_include_box_layout_btns->addWidget(remove_btn_m2i);
+
+      auto clear_btn_m2i = new QPushButton("Clear all", m2_instance_include_widget);
+      clear_btn_m2i->setIcon(font_awesome_icon(font_awesome::trash));
+      m2_instance_include_box_layout_btns->addWidget(clear_btn_m2i);
+
+      // WMO model exclude tab
+      auto wmo_exclude_widget = new QWidget(filter_tabs);
+      filter_tabs->addTab(wmo_exclude_widget, "WMO Model");
+
+      auto wmo_exclude_box_layout = new QFormLayout(wmo_exclude_widget);
+      wmo_exclude_box_layout->setContentsMargins(0, 0, 0, 0);
+      wmo_exclude_widget->setLayout(wmo_exclude_box_layout);
+
+      auto search_filter_wmo = new QLineEdit(this);
+      search_filter_wmo->setMinimumWidth(220);
+      wmo_exclude_box_layout->addRow("Filter:", search_filter_wmo);
+
+      _wmo_model_filter_exclude = new QListWidget(wmo_exclude_widget);
+      _render_settings.wmo_model_filter_exclude = _wmo_model_filter_exclude;
+      _wmo_model_filter_exclude->setAlternatingRowColors(true);
+
+      wmo_exclude_box_layout->addRow(_wmo_model_filter_exclude);
+
+      auto wmo_exclude_box_layout_btns = new QHBoxLayout(wmo_exclude_widget);
+      wmo_exclude_box_layout->addRow(wmo_exclude_box_layout_btns);
+
+      auto add_btn_wmo = new QPushButton("Add", wmo_exclude_widget);
+      add_btn_wmo->setIcon(font_awesome_icon(font_awesome::plus));
+      wmo_exclude_box_layout_btns->addWidget(add_btn_wmo);
+
+      auto remove_btn_wmo = new QPushButton("Remove", wmo_exclude_widget);
+      remove_btn_wmo->setIcon(font_awesome_icon(font_awesome::timescircle));
+      wmo_exclude_box_layout_btns->addWidget(remove_btn_wmo);
+
+      auto clear_btn_wmo = new QPushButton("Clear all", wmo_exclude_widget);
+      clear_btn_wmo->setIcon(font_awesome_icon(font_awesome::trash));
+      wmo_exclude_box_layout_btns->addWidget(clear_btn_wmo);
+
+      // WMO instance exclude tab
+      auto wmo_instance_exclude_widget = new QWidget(filter_tabs);
+      filter_tabs->addTab(wmo_instance_exclude_widget, "WMO Instance");
+
+      auto wmo_instance_exclude_box_layout = new QFormLayout(wmo_instance_exclude_widget);
+      wmo_instance_exclude_box_layout->setContentsMargins(0, 0, 0, 0);
+      wmo_instance_exclude_widget->setLayout(wmo_instance_exclude_box_layout);
+
+      auto search_filter_wmo_i = new QLineEdit(this);
+      search_filter_wmo_i->setMinimumWidth(220);
+      wmo_instance_exclude_box_layout->addRow("Filter:", search_filter_wmo_i);
+
+      _wmo_instance_filter_exclude = new QListWidget(wmo_instance_exclude_widget);
+      _render_settings.wmo_instance_filter_exclude = _wmo_instance_filter_exclude;
+      _wmo_instance_filter_exclude->setAlternatingRowColors(true);
+
+      wmo_instance_exclude_box_layout->addRow(_wmo_instance_filter_exclude);
+
+      auto wmo_instance_exclude_box_layout_btns = new QHBoxLayout(wmo_instance_exclude_widget);
+      wmo_instance_exclude_box_layout->addRow(wmo_instance_exclude_box_layout_btns);
+
+      auto add_btn_wmo_i = new QPushButton("Add", wmo_instance_exclude_widget);
+      add_btn_wmo_i->setIcon(font_awesome_icon(font_awesome::plus));
+      wmo_instance_exclude_box_layout_btns->addWidget(add_btn_wmo_i);
+
+      auto remove_btn_wmo_i = new QPushButton("Remove", wmo_instance_exclude_widget);
+      remove_btn_wmo_i->setIcon(font_awesome_icon(font_awesome::timescircle));
+      wmo_instance_exclude_box_layout_btns->addWidget(remove_btn_wmo_i);
+
+      auto clear_btn_wmo_i = new QPushButton("Clear all", wmo_instance_exclude_widget);
+      clear_btn_wmo_i->setIcon(font_awesome_icon(font_awesome::trash));
+      wmo_instance_exclude_box_layout_btns->addWidget(clear_btn_wmo_i);
 
       // Connections
 
       // Filter buttons
 
+      // M2 model filter
       connect(add_btn, &QPushButton::clicked,
           [=]()
                 {
@@ -171,17 +293,9 @@ namespace noggit
 
                   for (auto& selection : world->current_selection())
                   {
-                    if (selection.which() == eEntry_MapChunk)
-                    {
-                      continue;
-                    }
-
-                    std::string path;
-
                     if (selection.which() == eEntry_Model)
                     {
-                      path = boost::get<selected_model_type>(selection)->model->filename;
-                      includeM2Model(path);
+                      includeM2Model(boost::get<selected_model_type>(selection)->model->filename);
                     }
 
                   }
@@ -192,12 +306,98 @@ namespace noggit
       connect(remove_btn, &QPushButton::clicked,
               [=]()
               {
-                for (auto item : _m2_model_filter_include->selectedItems())
+
+                if (!world->get_selected_model_count())
                 {
-                  auto item_ = _m2_model_filter_include->takeItem(_m2_model_filter_include->row(item));
-                  delete item_;
+                  for (auto item : _m2_model_filter_include->selectedItems())
+                  {
+                    auto item_ = _m2_model_filter_include->takeItem(_m2_model_filter_include->row(item));
+                    delete item_;
+                  }
+
+                  return;
                 }
 
+                for (auto& selection : world->current_selection())
+                {
+                  if (selection.which() == eEntry_Model)
+                  {
+                    unincludeM2Model(boost::get<selected_model_type>(selection)->model->filename);
+                  }
+
+                }
+
+              }
+      );
+
+
+      connect(clear_btn, &QPushButton::clicked,
+              [=]()
+              {
+                _m2_model_filter_include->clear();
+              }
+      );
+
+      // M2 instance filter
+      connect(add_btn_m2i, &QPushButton::clicked,
+          [=]()
+                {
+                  if (!world->has_selection())
+                  {
+                    return;
+                  }
+
+                  for (auto& selection : world->current_selection())
+                  {
+                    if (selection.which() == eEntry_Model)
+                    {
+                      includeM2Instance(boost::get<selected_model_type>(selection)->uid);
+                    }
+
+                  }
+
+                }
+      );
+
+      connect(remove_btn_m2i, &QPushButton::clicked,
+              [=]()
+              {
+
+                if (!world->get_selected_model_count())
+                {
+                  for (auto item : _m2_instance_filter_include->selectedItems())
+                  {
+                    auto item_ = _m2_instance_filter_include->takeItem(_m2_instance_filter_include->row(item));
+                    delete item_;
+                  }
+
+                  return;
+                }
+
+                for (auto& selection : world->current_selection())
+                {
+
+                  if (selection.which() == eEntry_Model)
+                  {
+                    unincludeM2Instance(boost::get<selected_model_type>(selection)->uid);
+                  }
+
+                }
+
+              }
+      );
+
+      connect(clear_btn_m2i, &QPushButton::clicked,
+              [=]()
+              {
+                _m2_instance_filter_include->clear();
+              }
+      );
+
+      // WMO model filter
+      connect(add_btn_wmo, &QPushButton::clicked,
+              [=]()
+              {
                 if (!world->has_selection())
                 {
                   return;
@@ -205,17 +405,9 @@ namespace noggit
 
                 for (auto& selection : world->current_selection())
                 {
-                  if (selection.which() == eEntry_MapChunk)
+                  if (selection.which() == eEntry_WMO)
                   {
-                    continue;
-                  }
-
-                  std::string path;
-
-                  if (selection.which() == eEntry_Model)
-                  {
-                    path = boost::get<selected_model_type>(selection)->model->filename;
-                    unincludeM2Model(path);
+                    excludeWMOModel(boost::get<selected_wmo_type>(selection)->wmo->filename);
                   }
 
                 }
@@ -223,6 +415,163 @@ namespace noggit
               }
       );
 
+      connect(remove_btn_wmo, &QPushButton::clicked,
+              [=]()
+              {
+
+                if (!world->get_selected_model_count())
+                {
+                  for (auto item : _wmo_model_filter_exclude->selectedItems())
+                  {
+                    auto item_ = _wmo_model_filter_exclude->takeItem(_wmo_model_filter_exclude->row(item));
+                    delete item_;
+                  }
+
+                  return;
+                }
+
+                for (auto& selection : world->current_selection())
+                {
+
+                  if (selection.which() == eEntry_WMO)
+                  {
+                    unexcludeWMOModel(boost::get<selected_wmo_type>(selection)->wmo->filename);
+                  }
+
+                }
+
+              }
+      );
+
+      connect(clear_btn_wmo, &QPushButton::clicked,
+              [=]()
+              {
+                _wmo_model_filter_exclude->clear();
+              }
+      );
+
+      // WMO instance filter
+      connect(add_btn_wmo_i, &QPushButton::clicked,
+              [=]()
+              {
+                if (!world->has_selection())
+                {
+                  return;
+                }
+
+                for (auto& selection : world->current_selection())
+                {
+                  if (selection.which() == eEntry_WMO)
+                  {
+                    excludeWMOInstance(boost::get<selected_wmo_type>(selection)->mUniqueID);
+                  }
+
+                }
+
+              }
+      );
+
+      connect(remove_btn_wmo_i, &QPushButton::clicked,
+              [=]()
+              {
+
+                if (!world->get_selected_model_count())
+                {
+                  for (auto item : _wmo_instance_filter_exclude->selectedItems())
+                  {
+                    auto item_ = _wmo_instance_filter_exclude->takeItem(_wmo_instance_filter_exclude->row(item));
+                    delete item_;
+                  }
+
+                  return;
+                }
+
+                for (auto& selection : world->current_selection())
+                {
+
+                  if (selection.which() == eEntry_WMO)
+                  {
+                    unexcludeWMOInstance(boost::get<selected_wmo_type>(selection)->mUniqueID);
+                  }
+
+                }
+
+              }
+      );
+
+      connect(clear_btn_wmo_i, &QPushButton::clicked,
+              [=]()
+              {
+                _wmo_instance_filter_exclude->clear();
+              }
+      );
+
+      // Search filters
+
+      connect ( search_filter_m2, qOverload<const QString&> (&QLineEdit::textChanged)
+          , [&] (const QString& s)
+                {
+                  for (int i = 0; i < _m2_model_filter_include->count(); ++i)
+                  {
+                    MinimapM2ModelFilterEntry* item_wgt = reinterpret_cast<MinimapM2ModelFilterEntry*>(
+                        _m2_model_filter_include->itemWidget(_m2_model_filter_include->item(i)));
+
+                    std::string filename = item_wgt->getFileName().toStdString();
+                    std::string filter = s.toStdString();
+                    bool isHidden = !filter.empty() && filename.find(filter) == std::string::npos;
+                    _m2_model_filter_include->item(i)->setHidden(isHidden);
+                  }
+                }
+      );
+
+      connect ( search_filter_m2i, qOverload<const QString&> (&QLineEdit::textChanged)
+          , [&] (const QString& s)
+                {
+                  for (int i = 0; i < _m2_instance_filter_include->count(); ++i)
+                  {
+                    MinimapInstanceFilterEntry* item_wgt = reinterpret_cast<MinimapInstanceFilterEntry*>(
+                        _m2_instance_filter_include->itemWidget(_m2_instance_filter_include->item(i)));
+
+                    std::string uid = std::to_string(item_wgt->getUid());
+                    std::string filter = s.toStdString();
+                    bool isHidden = !filter.empty() && uid.find(filter) == std::string::npos;
+                    _m2_instance_filter_include->item(i)->setHidden(isHidden);
+                  }
+                }
+      );
+
+      connect ( search_filter_wmo, qOverload<const QString&> (&QLineEdit::textChanged)
+          , [&] (const QString& s)
+                {
+                  for (int i = 0; i < _wmo_model_filter_exclude->count(); ++i)
+                  {
+                    MinimapWMOModelFilterEntry* item_wgt = reinterpret_cast<MinimapWMOModelFilterEntry*>(
+                        _wmo_model_filter_exclude->itemWidget(_wmo_model_filter_exclude->item(i)));
+
+                    std::string filename = item_wgt->getFileName().toStdString();
+                    std::string filter = s.toStdString();
+                    bool isHidden = !filter.empty() && filename.find(filter) == std::string::npos;
+                    _wmo_model_filter_exclude->item(i)->setHidden(isHidden);
+                  }
+                }
+      );
+
+      connect ( search_filter_wmo_i, qOverload<const QString&> (&QLineEdit::textChanged)
+          , [&] (const QString& s)
+                {
+                  for (int i = 0; i < _wmo_instance_filter_exclude->count(); ++i)
+                  {
+                    MinimapInstanceFilterEntry* item_wgt = reinterpret_cast<MinimapInstanceFilterEntry*>(
+                        _wmo_instance_filter_exclude->itemWidget(_wmo_instance_filter_exclude->item(i)));
+
+                    std::string uid = std::to_string(item_wgt->getUid());
+                    std::string filter = s.toStdString();
+                    bool isHidden = !filter.empty() && uid.find(filter) == std::string::npos;
+                    _wmo_instance_filter_exclude->item(i)->setHidden(isHidden);
+                  }
+                }
+      );
+
       connect ( _radius_spin, qOverload<double> (&QDoubleSpinBox::valueChanged)
           , [&] (double v)
                 {
@@ -275,6 +624,11 @@ namespace noggit
         _render_settings.draw_elevation = s;
       });
 
+      connect (use_filters, &QCheckBox::stateChanged, [this] (int s)
+      {
+        _render_settings.use_filters = s;
+      });
+
       // Buttons
       connect(cur_adt_btn, &QPushButton::clicked, [=]() {
         _render_settings.export_mode = MinimapGenMode::CURRENT_ADT;
@@ -416,16 +770,154 @@ namespace noggit
 
     }
 
+    void MinimapCreator::includeM2Instance(uint32_t uid)
+    {
+      bool already_added = false;
+
+      for (int i = 0; i < _m2_instance_filter_include->count(); ++i)
+      {
+        if (reinterpret_cast<MinimapInstanceFilterEntry*>(_m2_instance_filter_include->itemWidget(
+            _m2_instance_filter_include->item(i)))->getUid() == uid)
+        {
+          already_added = true;
+          break;
+        }
+      }
+
+      if (already_added)
+      {
+        return;
+      }
+
+      auto item = new QListWidgetItem();
+      _m2_instance_filter_include->addItem(item);
+      auto entry_wgt = new MinimapInstanceFilterEntry(this);
+      entry_wgt->setUid(uid);
+      item->setSizeHint(entry_wgt->minimumSizeHint());
+      _m2_instance_filter_include->setItemWidget(item, entry_wgt);
+    }
+
+    void MinimapCreator::unincludeM2Instance(uint32_t uid)
+    {
+      for (int i = 0; i < _m2_model_filter_include->count(); ++i )
+      {
+        if (reinterpret_cast<MinimapInstanceFilterEntry*>(_m2_instance_filter_include->itemWidget(
+            _m2_instance_filter_include->item(i)))->getUid() == uid)
+        {
+          auto item = _m2_model_filter_include->takeItem(i);
+          delete item;
+        }
+      }
+    }
+
+    void MinimapCreator::excludeWMOModel(std::string filename)
+    {
+      bool already_added = false;
+
+      for (int i = 0; i < _wmo_model_filter_exclude->count(); ++i)
+      {
+        if (!reinterpret_cast<MinimapWMOModelFilterEntry*>(_wmo_model_filter_exclude->itemWidget(
+            _wmo_model_filter_exclude->item(i)))->getFileName().toStdString().compare(filename))
+        {
+          already_added = true;
+          break;
+        }
+      }
+
+      if (already_added)
+      {
+        return;
+      }
+
+      auto item = new QListWidgetItem();
+      _wmo_model_filter_exclude->addItem(item);
+      auto entry_wgt = new MinimapWMOModelFilterEntry(this);
+      entry_wgt->setFileName(filename);
+      item->setSizeHint(entry_wgt->minimumSizeHint());
+      _wmo_model_filter_exclude->setItemWidget(item, entry_wgt);
+    }
+
+    void MinimapCreator::unexcludeWMOModel(std::string filename)
+    {
+
+      for (int i = 0; i < _wmo_model_filter_exclude->count(); ++i )
+      {
+        if (!reinterpret_cast<MinimapWMOModelFilterEntry*>(_wmo_model_filter_exclude->itemWidget(
+            _wmo_model_filter_exclude->item(i)))->getFileName().toStdString().compare(filename))
+        {
+          auto item = _wmo_model_filter_exclude->takeItem(i);
+          delete item;
+        }
+      }
+
+    }
+
+    void MinimapCreator::excludeWMOInstance(uint32_t uid)
+    {
+      bool already_added = false;
+
+      for (int i = 0; i < _wmo_instance_filter_exclude->count(); ++i)
+      {
+        if (reinterpret_cast<MinimapInstanceFilterEntry*>(_wmo_instance_filter_exclude->itemWidget(
+            _wmo_instance_filter_exclude->item(i)))->getUid() == uid)
+        {
+          already_added = true;
+          break;
+        }
+      }
+
+      if (already_added)
+      {
+        return;
+      }
+
+      auto item = new QListWidgetItem();
+      _wmo_instance_filter_exclude->addItem(item);
+      auto entry_wgt = new MinimapInstanceFilterEntry(this);
+      entry_wgt->setUid(uid);
+      item->setSizeHint(entry_wgt->minimumSizeHint());
+      _wmo_instance_filter_exclude->setItemWidget(item, entry_wgt);
+    }
+
+    void MinimapCreator::unexcludeWMOInstance(uint32_t uid)
+    {
+      for (int i = 0; i < _wmo_instance_filter_exclude->count(); ++i )
+      {
+        if (reinterpret_cast<MinimapInstanceFilterEntry*>(_wmo_instance_filter_exclude->itemWidget(
+            _wmo_instance_filter_exclude->item(i)))->getUid() == uid)
+        {
+          auto item = _wmo_instance_filter_exclude->takeItem(i);
+          delete item;
+        }
+      }
+    }
+
     MinimapM2ModelFilterEntry::MinimapM2ModelFilterEntry(MinimapCreator* parent) : QWidget(parent)
     {
       auto layout = new QHBoxLayout(this);
+      layout->setContentsMargins(5, 2, 5, 2);
       layout->addWidget(_filename = new QLineEdit(this));
+      _filename->setEnabled(false);
       layout->addWidget(_size_category_spin = new QDoubleSpinBox(this));
-      _size_category_spin->setRange (0.0f, 100.0f);
-      _size_category_spin->setDecimals (2);
+      _size_category_spin->setRange (0.0f, 1000.0f);
       _size_category_spin->setValue (0.0);
 
     }
 
+     MinimapWMOModelFilterEntry::MinimapWMOModelFilterEntry(MinimapCreator* parent) : QWidget(parent)
+    {
+      auto layout = new QHBoxLayout(this);
+      layout->addWidget(_filename = new QLineEdit(this));
+      layout->setContentsMargins(5, 2, 5, 2);
+      _filename->setEnabled(false);
+    }
+
+    MinimapInstanceFilterEntry::MinimapInstanceFilterEntry(MinimapCreator* parent) : QWidget(parent)
+    {
+      auto layout = new QHBoxLayout(this);
+      layout->addWidget(_uid_label = new QLabel(this));
+      layout->setContentsMargins(5, 2, 5, 2);
+    }
+
   }
 }

src/noggit/ui/MinimapCreator.hpp

@@ -6,6 +6,7 @@
 #include <QWidget>
 #include <QtWidgets/QSlider>
 #include <QDoubleSpinBox>
+#include <QSpinBox>
 #include <QProgressBar>
 #include <QLineEdit>
 #include <QListWidget>
@@ -39,10 +40,14 @@ struct MinimapRenderSettings
   bool draw_water = true;
   bool draw_adt_grid = false;
   bool draw_elevation = false;
+  bool use_filters = false;
 
   std::array<bool, 4096> selected_tiles = {false};
 
   QListWidget* m2_model_filter_include;
+  QListWidget* m2_instance_filter_include;
+  QListWidget* wmo_model_filter_exclude;
+  QListWidget* wmo_instance_filter_exclude;
 
   // Filtering
   /*
@@ -82,6 +87,14 @@ namespace noggit
 
       void includeM2Model(std::string filename);
       void unincludeM2Model(std::string filename);
+      void includeM2Instance(uint32_t uid);
+      void unincludeM2Instance(uint32_t uid);
+
+      void excludeWMOModel(std::string filename);
+      void unexcludeWMOModel(std::string filename);
+      void excludeWMOInstance(uint32_t uid);
+      void unexcludeWMOInstance(uint32_t uid);
+
 
     private:
       float _radius = 0.01f;
@@ -91,6 +104,9 @@ namespace noggit
       minimap_widget* _minimap_widget;
       QProgressBar* _progress_bar;
       QListWidget* _m2_model_filter_include;
+      QListWidget* _m2_instance_filter_include;
+      QListWidget* _wmo_model_filter_exclude;
+      QListWidget* _wmo_instance_filter_exclude;
 
     };
 
@@ -107,5 +123,30 @@ namespace noggit
       QLineEdit* _filename;
       QDoubleSpinBox* _size_category_spin;
     };
+
+    class MinimapWMOModelFilterEntry : public QWidget
+    {
+    public:
+      MinimapWMOModelFilterEntry(MinimapCreator* parent = nullptr);
+
+      QString getFileName() { return _filename->text(); };
+      void setFileName(const std::string& filename) { _filename->setText(QString(filename.c_str())); };
+
+    private:
+      QLineEdit* _filename;
+    };
+
+    class MinimapInstanceFilterEntry : public QWidget
+    {
+    public:
+      MinimapInstanceFilterEntry(MinimapCreator* parent = nullptr);
+
+      uint32_t getUid() { return _uid; };
+      void setUid(uint32_t uid) { _uid = uid; _uid_label->setText(QString::fromStdString(std::to_string(uid))); };
+
+    private:
+      uint32_t _uid;
+      QLabel* _uid_label;
+    };
   }
 }

src/noggit/ui/Toolbar.cpp

@@ -20,7 +20,7 @@ namespace noggit
       add_tool_icon (editing_mode::mccv,         tr("Vertex Painter"),    font_noggit::TOOL_VERTEX_PAINT);
       add_tool_icon (editing_mode::object,       tr("Object Editor"),     font_noggit::TOOL_OBJECT_EDITOR);
       add_tool_icon (editing_mode::minimap,      tr("Minimap Editor"),    font_noggit::TOOL_MINIMAP_EDITOR);
-      add_tool_icon(editing_mode::stamp, tr("Stamp Mode"), font_noggit::TOOL_STAMP);
+      add_tool_icon(editing_mode::stamp,         tr("Stamp Mode"),        font_noggit::TOOL_STAMP);
     }
 
     void toolbar::add_tool_icon(editing_mode mode, const QString& name, const font_noggit::icons& icon)