3D-printing/OrcaSlicer
1
0
Fork 0
mirror of https://github.com/SoftFever/OrcaSlicer.git synced 2025-07-11 16:57:53 -06:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Further removal of the 3DScene / GLCanvas3DManager scaffold.

Browse source
This commit is contained in:
bubnikv 2018-11-23 17:15:17 +01:00
parent 103af1d8fb
commit 9258ca8cc6
4 changed files with 0 additions and 577 deletions
Download patch file Download diff file Expand all files Collapse all files

207
src/slic3r/GUI/3DScene.cpp
View file

@ -1871,211 +1871,4 @@ GUI::GLCanvas3D* _3DScene::get_canvas(wxGLCanvas* canvas)
return s_canvas_mgr.get_canvas(canvas);
}
void _3DScene::set_config(wxGLCanvas* canvas, DynamicPrintConfig* config)
{
s_canvas_mgr.set_config(canvas, config);
}
void _3DScene::set_process(wxGLCanvas* canvas, BackgroundSlicingProcess* process)
{
s_canvas_mgr.set_process(canvas, process);
}
void _3DScene::set_model(wxGLCanvas* canvas, Model* model)
{
s_canvas_mgr.set_model(canvas, model);
}
void _3DScene::set_bed_shape(wxGLCanvas* canvas, const Pointfs& shape)
{
s_canvas_mgr.set_bed_shape(canvas, shape);
}
void _3DScene::set_color_by(wxGLCanvas* canvas, const std::string& value)
{
s_canvas_mgr.set_color_by(canvas, value);
}
void _3DScene::enable_layers_editing(wxGLCanvas* canvas, bool enable)
{
s_canvas_mgr.enable_layers_editing(canvas, enable);
}
void _3DScene::enable_warning_texture(wxGLCanvas* canvas, bool enable)
{
s_canvas_mgr.enable_warning_texture(canvas, enable);
}
void _3DScene::enable_legend_texture(wxGLCanvas* canvas, bool enable)
{
s_canvas_mgr.enable_legend_texture(canvas, enable);
}
void _3DScene::enable_picking(wxGLCanvas* canvas, bool enable)
{
s_canvas_mgr.enable_picking(canvas, enable);
}
void _3DScene::enable_moving(wxGLCanvas* canvas, bool enable)
{
s_canvas_mgr.enable_moving(canvas, enable);
}
void _3DScene::enable_gizmos(wxGLCanvas* canvas, bool enable)
{
s_canvas_mgr.enable_gizmos(canvas, enable);
}
void _3DScene::enable_toolbar(wxGLCanvas* canvas, bool enable)
{
s_canvas_mgr.enable_toolbar(canvas, enable);
}
void _3DScene::enable_shader(wxGLCanvas* canvas, bool enable)
{
s_canvas_mgr.enable_shader(canvas, enable);
}
void _3DScene::enable_force_zoom_to_bed(wxGLCanvas* canvas, bool enable)
{
s_canvas_mgr.enable_force_zoom_to_bed(canvas, enable);
}
void _3DScene::enable_dynamic_background(wxGLCanvas* canvas, bool enable)
{
s_canvas_mgr.enable_dynamic_background(canvas, enable);
}
void _3DScene::allow_multisample(wxGLCanvas* canvas, bool allow)
{
s_canvas_mgr.allow_multisample(canvas, allow);
}
void _3DScene::enable_toolbar_item(wxGLCanvas* canvas, const std::string& name, bool enable)
{
s_canvas_mgr.enable_toolbar_item(canvas, name, enable);
}
bool _3DScene::is_toolbar_item_pressed(wxGLCanvas* canvas, const std::string& name)
{
return s_canvas_mgr.is_toolbar_item_pressed(canvas, name);
}
void _3DScene::zoom_to_bed(wxGLCanvas* canvas)
{
s_canvas_mgr.zoom_to_bed(canvas);
}
void _3DScene::zoom_to_volumes(wxGLCanvas* canvas)
{
s_canvas_mgr.zoom_to_volumes(canvas);
}
void _3DScene::select_view(wxGLCanvas* canvas, const std::string& direction)
{
s_canvas_mgr.select_view(canvas, direction);
}
void _3DScene::set_viewport_from_scene(wxGLCanvas* canvas, wxGLCanvas* other)
{
s_canvas_mgr.set_viewport_from_scene(canvas, other);
}
void _3DScene::update_volumes_colors_by_extruder(wxGLCanvas* canvas)
{
s_canvas_mgr.update_volumes_colors_by_extruder(canvas);
}
void _3DScene::render(wxGLCanvas* canvas)
{
s_canvas_mgr.render(canvas);
}
void _3DScene::select_all(wxGLCanvas* canvas)
{
s_canvas_mgr.select_all(canvas);
}
void _3DScene::delete_selected(wxGLCanvas* canvas)
{
s_canvas_mgr.delete_selected(canvas);
}
void _3DScene::ensure_on_bed(wxGLCanvas* canvas, unsigned int object_idx)
{
s_canvas_mgr.ensure_on_bed(canvas, object_idx);
}
std::vector<double> _3DScene::get_current_print_zs(wxGLCanvas* canvas, bool active_only)
{
return s_canvas_mgr.get_current_print_zs(canvas, active_only);
}
void _3DScene::set_toolpaths_range(wxGLCanvas* canvas, double low, double high)
{
s_canvas_mgr.set_toolpaths_range(canvas, low, high);
}
static inline int hex_digit_to_int(const char c)
{
return
(c >= '0' && c <= '9') ? int(c - '0') :
(c >= 'A' && c <= 'F') ? int(c - 'A') + 10 :
(c >= 'a' && c <= 'f') ? int(c - 'a') + 10 : -1;
}
static inline std::vector<float> parse_colors(const std::vector<std::string> &scolors)
{
std::vector<float> output(scolors.size() * 4, 1.f);
for (size_t i = 0; i < scolors.size(); ++ i) {
const std::string &scolor = scolors[i];
const char *c = scolor.data() + 1;
if (scolor.size() == 7 && scolor.front() == '#') {
for (size_t j = 0; j < 3; ++j) {
int digit1 = hex_digit_to_int(*c ++);
int digit2 = hex_digit_to_int(*c ++);
if (digit1 == -1 || digit2 == -1)
break;
output[i * 4 + j] = float(digit1 * 16 + digit2) / 255.f;
}
}
}
return output;
}
std::vector<int> _3DScene::load_object(wxGLCanvas* canvas, const ModelObject* model_object, int obj_idx, std::vector<int> instance_idxs)
{
return s_canvas_mgr.load_object(canvas, model_object, obj_idx, instance_idxs);
}
std::vector<int> _3DScene::load_object(wxGLCanvas* canvas, const Model* model, int obj_idx)
{
return s_canvas_mgr.load_object(canvas, model, obj_idx);
}
void _3DScene::mirror_selection(wxGLCanvas* canvas, Axis axis)
{
s_canvas_mgr.mirror_selection(canvas, axis);
}
void _3DScene::reload_scene(wxGLCanvas* canvas, bool refresh_immediately, bool force_full_scene_refresh)
{
s_canvas_mgr.reload_scene(canvas, refresh_immediately, force_full_scene_refresh);
}
void _3DScene::load_gcode_preview(wxGLCanvas* canvas, const GCodePreviewData* preview_data, const std::vector<std::string>& str_tool_colors)
{
s_canvas_mgr.load_gcode_preview(canvas, preview_data, str_tool_colors);
}
void _3DScene::load_preview(wxGLCanvas* canvas, const std::vector<std::string>& str_tool_colors)
{
s_canvas_mgr.load_preview(canvas, str_tool_colors);
}
void _3DScene::reset_legend_texture(wxGLCanvas* canvas)
{
s_canvas_mgr.reset_legend_texture(canvas);
}
} // namespace Slic3r