3DPrinting/PrusaSlicer-NonPlainar
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Volumes rendering moved to c++

Browse Source
This commit is contained in:
Enrico Turri 2018-05-21 15:57:03 +02:00
parent 0f035d0bae
commit ae53c7cb2e
8 changed files with 159 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
lib/Slic3r/GUI/3DScene.pm
View File

@ -1470,7 +1470,10 @@ sub Render {
glDisable(GL_MULTISAMPLE) if ($self->{can_multisample}); glDisable(GL_MULTISAMPLE) if ($self->{can_multisample});
glDisable(GL_LIGHTING); glDisable(GL_LIGHTING);
glDisable(GL_BLEND); glDisable(GL_BLEND);
$self->draw_volumes(1); #==============================================================================================================================
Slic3r::GUI::_3DScene::render_volumes($self, 1);
# $self->draw_volumes(1);
#==============================================================================================================================
glPopAttrib(); glPopAttrib();
glFlush(); glFlush();
my $col = [ glReadPixels_p($pos->x, $self->GetSize->GetHeight - $pos->y, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE) ]; my $col = [ glReadPixels_p($pos->x, $self->GetSize->GetHeight - $pos->y, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE) ];
@ -1598,7 +1601,10 @@ sub Render {
# draw objects # draw objects
if (! $self->use_plain_shader) { if (! $self->use_plain_shader) {
$self->draw_volumes; #==============================================================================================================================
Slic3r::GUI::_3DScene::render_volumes($self, 0);
# $self->draw_volumes;
#==============================================================================================================================
} elsif ($self->UseVBOs) { } elsif ($self->UseVBOs) {
if ($self->enable_picking) { if ($self->enable_picking) {
$self->mark_volumes_for_layer_height; $self->mark_volumes_for_layer_height;
@ -1663,44 +1669,46 @@ sub Render {
$self->SwapBuffers(); $self->SwapBuffers();
} }
sub draw_volumes { #==============================================================================================================================
# $fakecolor is a boolean indicating, that the objects shall be rendered in a color coding the object index for picking. #sub draw_volumes {
my ($self, $fakecolor) = @_; # # $fakecolor is a boolean indicating, that the objects shall be rendered in a color coding the object index for picking.
# my ($self, $fakecolor) = @_;
# do not cull backfaces to show broken geometry, if any #
glDisable(GL_CULL_FACE); # # do not cull backfaces to show broken geometry, if any
# glDisable(GL_CULL_FACE);
glEnable(GL_BLEND); #
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); # glEnable(GL_BLEND);
# glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnableClientState(GL_VERTEX_ARRAY); #
glEnableClientState(GL_NORMAL_ARRAY); # glEnableClientState(GL_VERTEX_ARRAY);
# glEnableClientState(GL_NORMAL_ARRAY);
foreach my $volume_idx (0..$#{$self->volumes}) { #
my $volume = $self->volumes->[$volume_idx]; # foreach my $volume_idx (0..$#{$self->volumes}) {
# my $volume = $self->volumes->[$volume_idx];
if ($fakecolor) { #
# Object picking mode. Render the object with a color encoding the object index. # if ($fakecolor) {
my $r = ($volume_idx & 0x000000FF) >> 0; # # Object picking mode. Render the object with a color encoding the object index.
my $g = ($volume_idx & 0x0000FF00) >> 8; # my $r = ($volume_idx & 0x000000FF) >> 0;
my $b = ($volume_idx & 0x00FF0000) >> 16; # my $g = ($volume_idx & 0x0000FF00) >> 8;
glColor4f($r/255.0, $g/255.0, $b/255.0, 1); # my $b = ($volume_idx & 0x00FF0000) >> 16;
} elsif ($volume->selected) { # glColor4f($r/255.0, $g/255.0, $b/255.0, 1);
glColor4f(@{ &SELECTED_COLOR }); # } elsif ($volume->selected) {
} elsif ($volume->hover) { # glColor4f(@{ &SELECTED_COLOR });
glColor4f(@{ &HOVER_COLOR }); # } elsif ($volume->hover) {
} else { # glColor4f(@{ &HOVER_COLOR });
glColor4f(@{ $volume->color }); # } else {
} # glColor4f(@{ $volume->color });
# }
$volume->render; #
} # $volume->render;
glDisableClientState(GL_NORMAL_ARRAY); # }
glDisableClientState(GL_VERTEX_ARRAY); # glDisableClientState(GL_NORMAL_ARRAY);
# glDisableClientState(GL_VERTEX_ARRAY);
glDisable(GL_BLEND); #
glEnable(GL_CULL_FACE); # glDisable(GL_BLEND);
} # glEnable(GL_CULL_FACE);
#}
#==============================================================================================================================
sub mark_volumes_for_layer_height { sub mark_volumes_for_layer_height {
my ($self) = @_; my ($self) = @_;

5
xs/src/slic3r/GUI/3DScene.cpp
View File

@ -1938,6 +1938,11 @@ void _3DScene::render_axes(wxGLCanvas* canvas)
s_canvas_mgr.render_axes(canvas); s_canvas_mgr.render_axes(canvas);
} }
void _3DScene::render_volumes(wxGLCanvas* canvas, bool fake_colors)
{
s_canvas_mgr.render_volumes(canvas, fake_colors);
}
void _3DScene::render_cutting_plane(wxGLCanvas* canvas) void _3DScene::render_cutting_plane(wxGLCanvas* canvas)
{ {
s_canvas_mgr.render_cutting_plane(canvas); s_canvas_mgr.render_cutting_plane(canvas);

1
xs/src/slic3r/GUI/3DScene.hpp
View File

@ -600,6 +600,7 @@ public:
static void render_background(wxGLCanvas* canvas); static void render_background(wxGLCanvas* canvas);
static void render_bed(wxGLCanvas* canvas); static void render_bed(wxGLCanvas* canvas);
static void render_axes(wxGLCanvas* canvas); static void render_axes(wxGLCanvas* canvas);
static void render_volumes(wxGLCanvas* canvas, bool fake_colors);
static void render_cutting_plane(wxGLCanvas* canvas); static void render_cutting_plane(wxGLCanvas* canvas);
static void render_warning_texture(wxGLCanvas* canvas); static void render_warning_texture(wxGLCanvas* canvas);
static void render_legend_texture(wxGLCanvas* canvas); static void render_legend_texture(wxGLCanvas* canvas);

67
xs/src/slic3r/GUI/GLCanvas3D.cpp
View File

@ -203,7 +203,7 @@ const BoundingBoxf3& GLCanvas3D::Bed::get_bounding_box() const
return m_bounding_box; return m_bounding_box;
} }
void GLCanvas3D::Bed::render() void GLCanvas3D::Bed::render() const
{ {
unsigned int triangles_vcount = m_triangles.get_data_size() / 3; unsigned int triangles_vcount = m_triangles.get_data_size() / 3;
if (triangles_vcount > 0) if (triangles_vcount > 0)
@ -311,7 +311,7 @@ void GLCanvas3D::Axes::set_length(float length)
m_length = length; m_length = length;
} }
void GLCanvas3D::Axes::render() void GLCanvas3D::Axes::render() const
{ {
::glDisable(GL_LIGHTING); ::glDisable(GL_LIGHTING);
// disable depth testing so that axes are not covered by ground // disable depth testing so that axes are not covered by ground
@ -352,14 +352,14 @@ bool GLCanvas3D::CuttingPlane::set(float z, const ExPolygons& polygons)
return m_lines.set_from_lines(lines, m_z); return m_lines.set_from_lines(lines, m_z);
} }
void GLCanvas3D::CuttingPlane::render(const BoundingBoxf3& bb) void GLCanvas3D::CuttingPlane::render(const BoundingBoxf3& bb) const
{ {
::glDisable(GL_LIGHTING); ::glDisable(GL_LIGHTING);
_render_plane(bb); _render_plane(bb);
_render_contour(); _render_contour();
} }
void GLCanvas3D::CuttingPlane::_render_plane(const BoundingBoxf3& bb) void GLCanvas3D::CuttingPlane::_render_plane(const BoundingBoxf3& bb) const
{ {
if (m_z >= 0.0f) if (m_z >= 0.0f)
{ {
@ -386,7 +386,7 @@ void GLCanvas3D::CuttingPlane::_render_plane(const BoundingBoxf3& bb)
} }
} }
void GLCanvas3D::CuttingPlane::_render_contour() void GLCanvas3D::CuttingPlane::_render_contour() const
{ {
::glEnableClientState(GL_VERTEX_ARRAY); ::glEnableClientState(GL_VERTEX_ARRAY);
@ -745,7 +745,7 @@ void GLCanvas3D::select_view(const std::string& direction)
} }
} }
void GLCanvas3D::render_background() void GLCanvas3D::render_background() const
{ {
static const float COLOR[3] = { 10.0f / 255.0f, 98.0f / 255.0f, 144.0f / 255.0f }; static const float COLOR[3] = { 10.0f / 255.0f, 98.0f / 255.0f, 144.0f / 255.0f };
@ -776,22 +776,65 @@ void GLCanvas3D::render_background()
::glPopMatrix(); ::glPopMatrix();
} }
void GLCanvas3D::render_bed() void GLCanvas3D::render_bed() const
{ {
m_bed.render(); m_bed.render();
} }
void GLCanvas3D::render_axes() void GLCanvas3D::render_axes() const
{ {
m_axes.render(); m_axes.render();
} }
void GLCanvas3D::render_cutting_plane() void GLCanvas3D::render_volumes(bool fake_colors) const
{
static const float INV_255 = 1.0f / 255.0f;
if (m_volumes == nullptr)
return;
::glEnable(GL_LIGHTING);
// do not cull backfaces to show broken geometry, if any
::glDisable(GL_CULL_FACE);
::glEnable(GL_BLEND);
::glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
::glEnableClientState(GL_VERTEX_ARRAY);
::glEnableClientState(GL_NORMAL_ARRAY);
unsigned int volume_id = 0;
for (const GLVolume* vol : m_volumes->volumes)
{
if (fake_colors)
{
// Object picking mode. Render the object with a color encoding the object index.
unsigned int r = (volume_id & 0x000000FF) >> 0;
unsigned int g = (volume_id & 0x0000FF00) >> 8;
unsigned int b = (volume_id & 0x00FF0000) >> 16;
::glColor4f((float)r * INV_255, (float)g * INV_255, (float)b * INV_255, 1.0f);
}
else
::glColor4f(vol->render_color[0], vol->render_color[1], vol->render_color[2], vol->render_color[3]);
vol->render();
++volume_id;
}
::glDisableClientState(GL_NORMAL_ARRAY);
::glDisableClientState(GL_VERTEX_ARRAY);
::glDisable(GL_BLEND);
::glEnable(GL_CULL_FACE);
}
void GLCanvas3D::render_cutting_plane() const
{ {
m_cutting_plane.render(volumes_bounding_box()); m_cutting_plane.render(volumes_bounding_box());
} }
void GLCanvas3D::render_warning_texture() void GLCanvas3D::render_warning_texture() const
{ {
if (!m_warning_texture_enabled) if (!m_warning_texture_enabled)
return; return;
@ -824,7 +867,7 @@ void GLCanvas3D::render_warning_texture()
} }
} }
void GLCanvas3D::render_legend_texture() void GLCanvas3D::render_legend_texture() const
{ {
if (!m_legend_texture_enabled) if (!m_legend_texture_enabled)
return; return;
@ -856,7 +899,7 @@ void GLCanvas3D::render_legend_texture()
} }
} }
void GLCanvas3D::render_texture(unsigned int tex_id, float left, float right, float bottom, float top) void GLCanvas3D::render_texture(unsigned int tex_id, float left, float right, float bottom, float top) const
{ {
::glColor4f(1.0f, 1.0f, 1.0f, 1.0f); ::glColor4f(1.0f, 1.0f, 1.0f, 1.0f);

25
xs/src/slic3r/GUI/GLCanvas3D.hpp
View File

@ -89,7 +89,7 @@ public:
const BoundingBoxf3& get_bounding_box() const; const BoundingBoxf3& get_bounding_box() const;
void render(); void render() const;
private: private:
void _calc_bounding_box(); void _calc_bounding_box();
@ -111,7 +111,7 @@ public:
float get_length() const; float get_length() const;
void set_length(float length); void set_length(float length);
void render(); void render() const;
}; };
class CuttingPlane class CuttingPlane
@ -124,11 +124,11 @@ public:
bool set(float z, const ExPolygons& polygons); bool set(float z, const ExPolygons& polygons);
void render(const BoundingBoxf3& bb); void render(const BoundingBoxf3& bb) const;
private: private:
void _render_plane(const BoundingBoxf3& bb); void _render_plane(const BoundingBoxf3& bb) const;
void _render_contour(); void _render_contour() const;
}; };
class LayersEditing class LayersEditing
@ -225,14 +225,15 @@ public:
void zoom_to_volumes(); void zoom_to_volumes();
void select_view(const std::string& direction); void select_view(const std::string& direction);
void render_background(); void render_background() const;
void render_bed(); void render_bed() const;
void render_axes(); void render_axes() const;
void render_cutting_plane(); void render_volumes(bool fake_colors) const;
void render_warning_texture(); void render_cutting_plane() const;
void render_legend_texture(); void render_warning_texture() const;
void render_legend_texture() const;
void render_texture(unsigned int tex_id, float left, float right, float bottom, float top); void render_texture(unsigned int tex_id, float left, float right, float bottom, float top) const;
void register_on_viewport_changed_callback(void* callback); void register_on_viewport_changed_callback(void* callback);

35
xs/src/slic3r/GUI/GLCanvas3DManager.cpp
View File

@ -390,51 +390,58 @@ void GLCanvas3DManager::select_view(wxGLCanvas* canvas, const std::string& direc
it->second->select_view(direction); it->second->select_view(direction);
} }
void GLCanvas3DManager::render_background(wxGLCanvas* canvas) void GLCanvas3DManager::render_background(wxGLCanvas* canvas) const
{ {
CanvasesMap::iterator it = _get_canvas(canvas); CanvasesMap::const_iterator it = _get_canvas(canvas);
if (it != m_canvases.end()) if (it != m_canvases.end())
it->second->render_background(); it->second->render_background();
} }
void GLCanvas3DManager::render_bed(wxGLCanvas* canvas) void GLCanvas3DManager::render_bed(wxGLCanvas* canvas) const
{ {
CanvasesMap::iterator it = _get_canvas(canvas); CanvasesMap::const_iterator it = _get_canvas(canvas);
if (it != m_canvases.end()) if (it != m_canvases.end())
it->second->render_bed(); it->second->render_bed();
} }
void GLCanvas3DManager::render_axes(wxGLCanvas* canvas) void GLCanvas3DManager::render_axes(wxGLCanvas* canvas) const
{ {
CanvasesMap::iterator it = _get_canvas(canvas); CanvasesMap::const_iterator it = _get_canvas(canvas);
if (it != m_canvases.end()) if (it != m_canvases.end())
it->second->render_axes(); it->second->render_axes();
} }
void GLCanvas3DManager::render_cutting_plane(wxGLCanvas* canvas) void GLCanvas3DManager::render_volumes(wxGLCanvas* canvas, bool fake_colors) const
{ {
CanvasesMap::iterator it = _get_canvas(canvas); CanvasesMap::const_iterator it = _get_canvas(canvas);
if (it != m_canvases.end())
it->second->render_volumes(fake_colors);
}
void GLCanvas3DManager::render_cutting_plane(wxGLCanvas* canvas) const
{
CanvasesMap::const_iterator it = _get_canvas(canvas);
if (it != m_canvases.end()) if (it != m_canvases.end())
it->second->render_cutting_plane(); it->second->render_cutting_plane();
} }
void GLCanvas3DManager::render_warning_texture(wxGLCanvas* canvas) void GLCanvas3DManager::render_warning_texture(wxGLCanvas* canvas) const
{ {
CanvasesMap::iterator it = _get_canvas(canvas); CanvasesMap::const_iterator it = _get_canvas(canvas);
if (it != m_canvases.end()) if (it != m_canvases.end())
it->second->render_warning_texture(); it->second->render_warning_texture();
} }
void GLCanvas3DManager::render_legend_texture(wxGLCanvas* canvas) void GLCanvas3DManager::render_legend_texture(wxGLCanvas* canvas) const
{ {
CanvasesMap::iterator it = _get_canvas(canvas); CanvasesMap::const_iterator it = _get_canvas(canvas);
if (it != m_canvases.end()) if (it != m_canvases.end())
it->second->render_legend_texture(); it->second->render_legend_texture();
} }
void GLCanvas3DManager::render_texture(wxGLCanvas* canvas, unsigned int tex_id, float left, float right, float bottom, float top) void GLCanvas3DManager::render_texture(wxGLCanvas* canvas, unsigned int tex_id, float left, float right, float bottom, float top) const
{ {
CanvasesMap::iterator it = _get_canvas(canvas); CanvasesMap::const_iterator it = _get_canvas(canvas);
if (it != m_canvases.end()) if (it != m_canvases.end())
it->second->render_texture(tex_id, left, right, bottom, top); it->second->render_texture(tex_id, left, right, bottom, top);
} }

15
xs/src/slic3r/GUI/GLCanvas3DManager.hpp
View File

@ -107,14 +107,15 @@ public:
void zoom_to_volumes(wxGLCanvas* canvas); void zoom_to_volumes(wxGLCanvas* canvas);
void select_view(wxGLCanvas* canvas, const std::string& direction); void select_view(wxGLCanvas* canvas, const std::string& direction);
void render_background(wxGLCanvas* canvas); void render_background(wxGLCanvas* canvas) const;
void render_bed(wxGLCanvas* canvas); void render_bed(wxGLCanvas* canvas) const;
void render_axes(wxGLCanvas* canvas); void render_axes(wxGLCanvas* canvas) const;
void render_cutting_plane(wxGLCanvas* canvas); void render_volumes(wxGLCanvas* canvas, bool fake_colors) const;
void render_warning_texture(wxGLCanvas* canvas); void render_cutting_plane(wxGLCanvas* canvas) const;
void render_legend_texture(wxGLCanvas* canvas); void render_warning_texture(wxGLCanvas* canvas) const;
void render_legend_texture(wxGLCanvas* canvas) const;
void render_texture(wxGLCanvas* canvas, unsigned int tex_id, float left, float right, float bottom, float top); void render_texture(wxGLCanvas* canvas, unsigned int tex_id, float left, float right, float bottom, float top) const;
void register_on_viewport_changed_callback(wxGLCanvas* canvas, void* callback); void register_on_viewport_changed_callback(wxGLCanvas* canvas, void* callback);

7
xs/xsp/GUI_3DScene.xsp
View File

@ -462,6 +462,13 @@ render_axes(canvas)
CODE: CODE:
_3DScene::render_axes((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas")); _3DScene::render_axes((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"));
void
render_volumes(canvas, fake_colors)
SV *canvas;
bool fake_colors;
CODE:
_3DScene::render_volumes((wxGLCanvas*)wxPli_sv_2_object(aTHX_ canvas, "Wx::GLCanvas"), fake_colors);
void void
render_cutting_plane(canvas) render_cutting_plane(canvas)
SV *canvas; SV *canvas;