natsirt/noggit-red
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

create terrain mode and start working on the UI for minimap generator

Browse Source
This commit is contained in:
Skarn
2020-10-21 03:44:38 +03:00
parent 1be23f2c0c
commit cbefccacce
6 changed files with 327 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

117
src/noggit/MapView.cpp
View File

@@ -35,6 +35,7 @@
#include <noggit/ui/texturing_tool.hpp>
#include <noggit/ui/hole_tool.hpp>
#include <noggit/ui/texture_palette_small.hpp>
#include <noggit/ui/MinimapCreator.hpp>
#include <opengl/scoped.hpp>
#include "revision.h"
@@ -62,8 +63,6 @@
#include <regex>
#include <string>
#include <vector>
#include <thread>
#include <chrono>
static const float XSENS = 15.0f;
@@ -128,6 +127,9 @@ void MapView::setToolPropertyWidgetVisibility(editing_mode mode)
case editing_mode::holes:
_hole_tool_dock->setVisible(!ui_hidden);
break;
case editing_mode::minimap:
_minimap_tool_dock->setVisible(!ui_hidden);
break;
}
@@ -194,7 +196,6 @@ QWidgetAction* MapView::createTextSeparator(const QString& text)
void MapView::createGUI()
{
// create tool widgets
_terrain_tool_dock = new QDockWidget("Raise / Lower", this);
terrainTool = new noggit::ui::terrain_tool(_terrain_tool_dock);
_terrain_tool_dock->setWidget(terrainTool);
@@ -267,6 +268,11 @@ void MapView::createGUI()
_vertex_shading_dock->setWidget(shaderTool);
_tool_properties_docks.insert(_vertex_shading_dock);
_minimap_tool_dock = new QDockWidget("Minimap Creator", this);
minimapTool = new noggit::ui::MinimapCreator(this);
_minimap_tool_dock->setWidget(minimapTool);
_tool_properties_docks.insert(_minimap_tool_dock);
_object_editor_dock = new QDockWidget("Object", this);
objectEditor = new noggit::ui::object_editor(this
, _world.get()
@@ -1528,41 +1534,88 @@ void MapView::initializeGL()
}
}
void MapView::saveMinimap(noggit::MinimapRenderSettings* settings)
{
switch (settings->export_mode)
{
case noggit::MinimapGenMode::CURRENT_ADT:
{
tile_index tile = tile_index(_camera.position);
if (_world->mapIndex.hasTile(tile))
{
mmap_render_success = _world->saveMinimap(512, 512, tile);
}
else
{
Saving = false;
}
if (mmap_render_success)
{
Saving = false;
}
break;
}
case noggit::MinimapGenMode::MAP:
{
// increment tile indices here
if (mmap_render_success)
{
mmap_render_index++;
}
tile_index tile = tile_index(mmap_render_index / 64, mmap_render_index % 64);
if (_world->mapIndex.hasTile(tile))
{
mmap_render_success = _world->saveMinimap(512, 512, tile);
}
else
{
do
{
mmap_render_index++;
tile.x = mmap_render_index / 64;
tile.z = mmap_render_index % 64;
} while (!_world->mapIndex.hasTile(tile) && mmap_render_index != 4095 );
if (mmap_render_success)
{
mmap_render_index--;
}
}
if (mmap_render_success && mmap_render_index >= 4095)
{
Saving = false;
mmap_render_index = 0;
mmap_render_success = false;
}
break;
}
case noggit::MinimapGenMode::SELECTED_ADTS:
{
break;
}
}
}
void MapView::paintGL()
{
opengl::context::scoped_setter const _ (::gl, context());
if (Saving)
{
// increment tile indices here
if (mmap_render_success)
{
mmap_render_index++;
}
tile_index tile = tile_index(mmap_render_index / 64, mmap_render_index % 64);
if (_world->mapIndex.hasTile(tile))
{
mmap_render_success = _world->saveMinimap(512, 512, tile);
}
else
{
do
{
mmap_render_index++;
tile.x = mmap_render_index / 64;
tile.z = mmap_render_index % 64;
} while (!_world->mapIndex.hasTile(tile) && mmap_render_index != 4095);
}
if (mmap_render_success && mmap_render_index == 4095)
{
Saving = false;
mmap_render_index = 0;
mmap_render_success = false;
}
saveMinimap(minimapTool->getMinimapRenderSettings());
}
const qreal now(_startup_time.elapsed() / 1000.0);

5
src/noggit/MapView.h
View File

@@ -10,6 +10,7 @@
#include <noggit/camera.hpp>
#include <noggit/tool_enums.hpp>
#include <noggit/ui/ObjectEditor.h>
#include <noggit/ui/MinimapCreator.hpp>
#include <noggit/ui/uid_fix_window.hpp>
#include <noggit/unsigned_int_property.hpp>
@@ -198,6 +199,8 @@ public:
void tick (float dt);
void selectModel(std::string const& model);
void change_selected_wmo_doodadset(int set);
void saveMinimap(noggit::MinimapRenderSettings* settings);
void initMinimapSave() { Saving = true; };
void set_editing_mode (editing_mode);
@@ -312,4 +315,6 @@ private:
QDockWidget* _texturing_dock;
noggit::ui::hole_tool* holeTool;
QDockWidget* _hole_tool_dock;
noggit::ui::MinimapCreator* minimapTool;
QDockWidget* _minimap_tool_dock;
};

1
src/noggit/tool_enums.hpp
View File

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

162
src/noggit/ui/MinimapCreator.cpp Normal file
View File

@@ -0,0 +1,162 @@
// This file is part of Noggit3, licensed under GNU General Public License (version 3).
#include "MinimapCreator.hpp"
#include <noggit/MapView.h>
#include <util/qt/overload.hpp>
#include <QFormLayout>
#include <QGroupBox>
#include <QCheckBox>
#include <QButtonGroup>
#include <QPushButton>
#include <QTabWidget>
namespace noggit
{
namespace ui
{
MinimapCreator::MinimapCreator (
MapView* mapView,
QWidget* parent ) : QWidget(parent)
{
auto layout = new QHBoxLayout(this);
auto layout_left = new QFormLayout (this);
layout->addItem(layout_left);
auto settings_tabs = new QTabWidget (this);
layout->addWidget(settings_tabs);
// Generate
auto generate_widget = new QWidget(this);
auto generate_layout = new QFormLayout(generate_widget);
settings_tabs->addTab(generate_widget, "Generate");
_radius_spin = new QDoubleSpinBox (generate_widget);
_radius_spin->setRange (0.0f, 100.0f);
_radius_spin->setDecimals (2);
_radius_spin->setValue (_radius);
generate_layout->addRow ("Radius:", _radius_spin);
_radius_slider = new QSlider (Qt::Orientation::Horizontal, generate_widget);
_radius_slider->setRange (0, 100);
_radius_slider->setSliderPosition (_radius);
generate_layout->addRow (_radius_slider);
auto cur_adt_btn = new QPushButton("Current ADT", generate_widget);
auto sel_adts_btn = new QPushButton("Selected ADTs", generate_widget);
auto all_adts_btn = new QPushButton("Map", generate_widget);
generate_layout->addRow (cur_adt_btn);
generate_layout->addRow (sel_adts_btn);
generate_layout->addRow (all_adts_btn);
// Render settings box
auto render_settings_box = new QGroupBox("Render options", generate_widget);
generate_layout->addRow (render_settings_box);
auto render_settings_box_layout = new QFormLayout (render_settings_box);
auto draw_models = new QCheckBox("Draw models", render_settings_box);
draw_models->setChecked(_render_settings.draw_m2);
render_settings_box_layout->addRow (draw_models);
auto draw_wmos = new QCheckBox("Draw WMOs", render_settings_box);
draw_wmos->setChecked(_render_settings.draw_wmo);
render_settings_box_layout->addRow (draw_wmos);
auto draw_water = new QCheckBox("Draw water", render_settings_box);
draw_water->setChecked(_render_settings.draw_water);
render_settings_box_layout->addRow (draw_water);
auto draw_adt = new QCheckBox("Draw ADT grid", render_settings_box);
draw_adt->setChecked(_render_settings.draw_adt_grid);
render_settings_box_layout->addRow (draw_adt);
auto draw_elevation = new QCheckBox("Draw elevation lines", render_settings_box);
draw_elevation->setChecked(_render_settings.draw_elevation);
render_settings_box_layout->addRow (draw_elevation);
// Connections
connect ( _radius_spin, qOverload<double> (&QDoubleSpinBox::valueChanged)
, [&] (double v)
{
_radius = v;
QSignalBlocker const blocker(_radius_slider);
_radius_slider->setSliderPosition ((int)std::round (v));
}
);
connect ( _radius_slider, &QSlider::valueChanged
, [&] (int v)
{
_radius = v;
QSignalBlocker const blocker(_radius_spin);
_radius_spin->setValue(v);
}
);
// Render settings
connect (draw_models, &QCheckBox::stateChanged, [this] (int s)
{
_render_settings.draw_m2 = s;
});
connect (draw_wmos, &QCheckBox::stateChanged, [this] (int s)
{
_render_settings.draw_wmo = s;
});
connect (draw_water, &QCheckBox::stateChanged, [this] (int s)
{
_render_settings.draw_water = s;
});
connect (draw_adt, &QCheckBox::stateChanged, [this] (int s)
{
_render_settings.draw_adt_grid = s;
});
connect (draw_elevation, &QCheckBox::stateChanged, [this] (int s)
{
_render_settings.draw_elevation = s;
});
// Buttons
connect(cur_adt_btn, &QPushButton::clicked, [=]() {
_render_settings.export_mode = MinimapGenMode::CURRENT_ADT;
mapView->initMinimapSave();
});
connect(sel_adts_btn, &QPushButton::clicked, [=]() {
_render_settings.export_mode = MinimapGenMode::SELECTED_ADTS;
mapView->initMinimapSave();
});
connect(all_adts_btn, &QPushButton::clicked, [=]() {
_render_settings.export_mode = MinimapGenMode::MAP;
mapView->initMinimapSave();
});
setMinimumWidth(sizeHint().width());
}
void MinimapCreator::changeRadius(float change)
{
_radius_spin->setValue (_radius + change);
}
QSize MinimapCreator::sizeHint() const
{
return QSize(215, height());
}
}
}

69
src/noggit/ui/MinimapCreator.hpp Normal file
View File

@@ -0,0 +1,69 @@
// This file is part of Noggit3, licensed under GNU General Public License (version 3).
#pragma once
#include <QLabel>
#include <QWidget>
#include <QSettings>
#include <QtWidgets/QDoubleSpinBox>
#include <QtWidgets/QSlider>
#include <boost/optional.hpp>
#include <string>
#include <unordered_map>
#include <vector>
class MapView;
namespace noggit
{
enum MinimapGenMode
{
CURRENT_ADT,
SELECTED_ADTS,
MAP
};
struct MinimapRenderSettings
{
MinimapGenMode export_mode; // Export mode
// Render settings
bool draw_m2 = false;
bool draw_wmo = true;
bool draw_water = true;
bool draw_adt_grid = false;
bool draw_elevation = false;
// Filtering
std::unordered_map<std::string, float> m2_model_filter_include; // filename, size category
std::vector<uint32_t> m2_instance_filter_include; // include specific M2 instances
std::vector<std::string> wmo_model_filter_exclude; // exclude WMOs by filename
std::vector<uint32_t> wmo_instance_filter_exclude; // exclude specific WMO instances
};
namespace ui
{
class MinimapCreator : public QWidget
{
public:
MinimapCreator (MapView* mapView, QWidget* parent = nullptr);
void changeRadius(float change);
float brushRadius() const { return _radius; }
MinimapRenderSettings* getMinimapRenderSettings() { return &_render_settings; };
QSize sizeHint() const override;
private:
float _radius = 0.01f;
MinimapRenderSettings _render_settings;
QSlider* _radius_slider;
QDoubleSpinBox* _radius_spin;
};
}
}

9
src/noggit/ui/Toolbar.cpp
View File

@@ -12,13 +12,14 @@ namespace noggit
{
add_tool_icon (editing_mode::ground, tr("Raise / Lower"), font_awesome::chartarea);
add_tool_icon (editing_mode::flatten_blur, tr("Flatten / Blur"), font_awesome::bacon);
add_tool_icon (editing_mode::paint, tr("3D Paint"), font_awesome::paintbrush);
add_tool_icon (editing_mode::paint, tr("Texturing editor"),font_awesome::paintbrush);
add_tool_icon (editing_mode::holes, tr("Holes"), font_awesome::cut);
add_tool_icon (editing_mode::areaid, tr("AreaID Paint"), font_awesome::objectgroup);
add_tool_icon (editing_mode::flags, tr("Impassible Flag"), font_awesome::ban);
add_tool_icon (editing_mode::water, tr("Water edit"), font_awesome::water);
add_tool_icon (editing_mode::areaid, tr("Area ID"), font_awesome::objectgroup);
add_tool_icon (editing_mode::flags, tr("Impassible flag"), font_awesome::ban);
add_tool_icon (editing_mode::water, tr("Water editor"), font_awesome::water);
add_tool_icon (editing_mode::mccv, tr("Shader editor"), font_awesome::eyedropper);
add_tool_icon (editing_mode::object, tr("Object editor"), font_awesome::cube);
add_tool_icon (editing_mode::minimap, tr("Minimap сreator"), font_awesome::cube);
}
void toolbar::add_tool_icon(editing_mode mode, const QString& name, const font_awesome::icons& icon)