mozhe
/
BambuStudio
5
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ENH: add fxaa for thumbinal 

jira: STUDIO-10640

Change-Id: Ia949904f687b0050514e07e439d82312db473557
(cherry picked from commit a823435a282129a8020e5bf811f6b4203d2a7e89)
This commit is contained in:
jun.zhang 2025-03-10 10:13:37 +08:00 committed by lane.wei
parent c8ceb4ba38
commit cd3b96c7f5
8 changed files with 504 additions and 795 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

131
src/BambuStudio.cpp
View File

@ -5299,7 +5299,8 @@ int CLI::run(int argc, char **argv)
global_begin_time = global_current_time;
//opengl related
Slic3r::GUI::OpenGLManager opengl_mgr;
std::shared_ptr<Slic3r::GUI::OpenGLManager> p_opengl_mgr = std::make_shared<Slic3r::GUI::OpenGLManager>();
p_opengl_mgr->set_legacy_framebuffer_enabled(false);
std::shared_ptr<GLShaderProgram> shader = nullptr;
GLVolumeCollection glvolume_collection;
bool opengl_valid = false;
@ -5311,7 +5312,7 @@ int CLI::run(int argc, char **argv)
else
colors.push_back("#FFFFFFFF");
std::vector<std::array<float, 4>> colors_out(colors.size());
auto init_opengl_and_colors = [&opengl_mgr, &colors_out, &glvolume_collection, &shader, &filament_color](Model &model, std::vector<std::string>& f_colors) -> bool {
auto init_opengl_and_colors = [&p_opengl_mgr, &colors_out, &glvolume_collection, &shader, &filament_color](Model &model, std::vector<std::string>& f_colors) -> bool {
unsigned char rgb_color[4] = {};
for (const std::string& color : f_colors) {
Slic3r::GUI::BitmapCache::parse_color4(color, rgb_color);
@ -5362,14 +5363,14 @@ int CLI::run(int argc, char **argv)
glfwMakeContextCurrent(window);
}
bool gl_valid = opengl_mgr.init_gl(false);
bool gl_valid = p_opengl_mgr->init_gl(false);
if (!gl_valid) {
BOOST_LOG_TRIVIAL(error) << "init opengl failed! skip thumbnail generating" << std::endl;
}
else {
BOOST_LOG_TRIVIAL(info) << "glewInit Sucess." << std::endl;
shader = opengl_mgr.get_shader("thumbnail");
shader = p_opengl_mgr->get_shader("thumbnail");
if (!shader) {
BOOST_LOG_TRIVIAL(error) << boost::format("can not get shader for rendering thumbnail");
gl_valid = false;
@ -5993,41 +5994,22 @@ int CLI::run(int argc, char **argv)
}
sliced_plate_info.triangle_count = plate_triangle_counts[index];
auto cli_generate_thumbnails = [&partplate_list, &model, &glvolume_collection, &colors_out, &shader, &opengl_mgr](const ThumbnailsParams& params) -> ThumbnailsList{
auto cli_generate_thumbnails = [&partplate_list, &model, &glvolume_collection, &colors_out, &shader, &p_opengl_mgr](const ThumbnailsParams& params) -> ThumbnailsList{
ThumbnailsList thumbnails;
opengl_mgr.bind_vao();
opengl_mgr.bind_shader(shader);
p_opengl_mgr->bind_vao();
p_opengl_mgr->bind_shader(shader);
for (const Vec2d& size : params.sizes) {
thumbnails.push_back(ThumbnailData());
Point isize(size); // round to ints
ThumbnailData& thumbnail_data = thumbnails.back();
const auto fb_type = Slic3r::GUI::OpenGLManager::get_framebuffers_type();
BOOST_LOG_TRIVIAL(info) << boost::format("framebuffer_type: %1%") %Slic3r::GUI::OpenGLManager::framebuffer_type_to_string(fb_type).c_str();
switch (fb_type)
{
case Slic3r::GUI::OpenGLManager::EFramebufferType::Supported:
case Slic3r::GUI::OpenGLManager::EFramebufferType::Arb:
{
Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer(thumbnail_data,
Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer(p_opengl_mgr, thumbnail_data,
isize.x(), isize.y(), params,
partplate_list, model.objects, glvolume_collection, colors_out, shader, Slic3r::GUI::Camera::EType::Ortho);
break;
}
case Slic3r::GUI::OpenGLManager::EFramebufferType::Ext:
{
Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer_ext(thumbnail_data,
isize.x(), isize.y(), params,
partplate_list, model.objects, glvolume_collection, colors_out, shader, Slic3r::GUI::Camera::EType::Ortho);
break;
}
default:
break;
}
if (!thumbnails.back().is_valid())
thumbnails.pop_back();
}
opengl_mgr.unbind_shader();
opengl_mgr.unbind_vao();
p_opengl_mgr->unbind_shader();
p_opengl_mgr->unbind_vao();
return thumbnails;
};
@ -6537,8 +6519,8 @@ int CLI::run(int argc, char **argv)
else {*/
if (opengl_valid) {
Model &model = m_models[0];
opengl_mgr.bind_vao();
opengl_mgr.bind_shader(shader);
p_opengl_mgr->bind_vao();
p_opengl_mgr->bind_shader(shader);
for (int i = 0; i < partplate_list.get_plate_count(); i++) {
Slic3r::GUI::PartPlate *part_plate = partplate_list.get_plate(i);
PlateData *plate_data = plate_data_list[i];
@ -6580,28 +6562,9 @@ int CLI::run(int argc, char **argv)
const ThumbnailsParams thumbnail_params = {{}, false, true, true, true, i};
BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%'s thumbnail, need to regenerate")%(i+1);
const auto fb_type = Slic3r::GUI::OpenGLManager::get_framebuffers_type();
BOOST_LOG_TRIVIAL(info) << boost::format("framebuffer_type: %1%") % Slic3r::GUI::OpenGLManager::framebuffer_type_to_string(fb_type).c_str();
switch (fb_type)
{
case Slic3r::GUI::OpenGLManager::EFramebufferType::Supported:
case Slic3r::GUI::OpenGLManager::EFramebufferType::Arb:
{
Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer(*thumbnail_data,
Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer(p_opengl_mgr, *thumbnail_data,
thumbnail_width, thumbnail_height, thumbnail_params,
partplate_list, model.objects, glvolume_collection, colors_out, shader, Slic3r::GUI::Camera::EType::Ortho);
break;
}
case Slic3r::GUI::OpenGLManager::EFramebufferType::Ext:
{
Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer_ext(*thumbnail_data,
thumbnail_width, thumbnail_height, thumbnail_params,
partplate_list, model.objects, glvolume_collection, colors_out, shader, Slic3r::GUI::Camera::EType::Ortho);
break;
}
default:
break;
}
BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%'s thumbnail,finished rendering")%(i+1);
}
}
@ -6632,32 +6595,11 @@ int CLI::run(int argc, char **argv)
const ThumbnailsParams thumbnail_params = { {}, false, true, false, true, i };
BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%'s no_light_thumbnail_file missed, need to regenerate")%(i+1);
const auto fb_type = Slic3r::GUI::OpenGLManager::get_framebuffers_type();
BOOST_LOG_TRIVIAL(info) << boost::format("framebuffer_type: %1%") % Slic3r::GUI::OpenGLManager::framebuffer_type_to_string(fb_type).c_str();
switch (fb_type)
{
case Slic3r::GUI::OpenGLManager::EFramebufferType::Supported:
case Slic3r::GUI::OpenGLManager::EFramebufferType::Arb:
{
Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer(*no_light_thumbnail,
Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer(p_opengl_mgr, *no_light_thumbnail,
thumbnail_width, thumbnail_height, thumbnail_params,
partplate_list, model.objects, glvolume_collection, colors_out, shader,
Slic3r::GUI::Camera::EType::Ortho, Slic3r::GUI::Camera::ViewAngleType::Iso,
false, true);
break;
}
case Slic3r::GUI::OpenGLManager::EFramebufferType::Ext:
{
Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer_ext(*no_light_thumbnail,
thumbnail_width, thumbnail_height, thumbnail_params,
partplate_list, model.objects, glvolume_collection, colors_out, shader,
Slic3r::GUI::Camera::EType::Ortho, Slic3r::GUI::Camera::ViewAngleType::Iso,
false, true);
break;
}
default:
break;
}
plate_data->no_light_thumbnail_file = "valid_no_light";
BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%'s no_light thumbnail,finished rendering")%(i+1);
}
@ -6722,41 +6664,16 @@ int CLI::run(int argc, char **argv)
else {
const auto fb_type = Slic3r::GUI::OpenGLManager::get_framebuffers_type();
BOOST_LOG_TRIVIAL(info) << boost::format("framebuffer_type: %1%") % Slic3r::GUI::OpenGLManager::framebuffer_type_to_string(fb_type).c_str();
switch (fb_type)
{
case Slic3r::GUI::OpenGLManager::EFramebufferType::Supported:
case Slic3r::GUI::OpenGLManager::EFramebufferType::Arb:
{
Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer(*top_thumbnail,
Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer(p_opengl_mgr, *top_thumbnail,
thumbnail_width, thumbnail_height, thumbnail_params,
partplate_list, model.objects, glvolume_collection, colors_out, shader,
Slic3r::GUI::Camera::EType::Ortho, Slic3r::GUI::Camera::ViewAngleType::Top_Plate,
false);
Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer(*picking_thumbnail,
Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer(p_opengl_mgr, *picking_thumbnail,
thumbnail_width, thumbnail_height, thumbnail_params,
partplate_list, model.objects, glvolume_collection, colors_out, shader,
Slic3r::GUI::Camera::EType::Ortho,
Slic3r::GUI::Camera::ViewAngleType::Top_Plate, true, true);
break;
}
case Slic3r::GUI::OpenGLManager::EFramebufferType::Ext:
{
Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer_ext(*top_thumbnail,
thumbnail_width, thumbnail_height, thumbnail_params,
partplate_list, model.objects, glvolume_collection, colors_out, shader,
Slic3r::GUI::Camera::EType::Ortho,
Slic3r::GUI::Camera::ViewAngleType::Top_Plate, false);
Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer_ext(*picking_thumbnail,
thumbnail_width, thumbnail_height, thumbnail_params, partplate_list, model.objects,
glvolume_collection, colors_out, shader,
Slic3r::GUI::Camera::EType::Ortho,
Slic3r::GUI::Camera::ViewAngleType::Top_Plate,
true,true);
break;
}
default:
break;
}
plate_data->top_file = "valid_top";
plate_data->pick_file = "valid_pick";
BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%'s top_thumbnail,finished rendering")%(i+1);
@ -6770,12 +6687,10 @@ int CLI::run(int argc, char **argv)
BOOST_LOG_TRIVIAL(info) << boost::format("plate %1%: add thumbnail data for top and pick into group")%(i+1);
}
}
opengl_mgr.unbind_shader();
opengl_mgr.unbind_vao();
p_opengl_mgr->unbind_shader();
p_opengl_mgr->unbind_vao();
}
}
//BBS: release glfw
glfwTerminate();
}
else {
BOOST_LOG_TRIVIAL(info) << boost::format("Line %1%: use previous thumbnails, no need to regenerate")%__LINE__;
@ -7022,8 +6937,16 @@ int CLI::run(int argc, char **argv)
g_cli_callback_mgr.stop();
#endif
if (opengl_valid) {
for (Model& model : m_models) {
model.remove_backup_path_if_exist();
model.objects.clear();
}
shader = nullptr;
glvolume_collection.clear();
p_opengl_mgr = nullptr;
//BBS: release glfw
glfwTerminate();
}
//BBS: flush logs
BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ", Finished" << std::endl;

2
src/libslic3r/GCode/ThumbnailData.hpp
View File

@ -39,6 +39,8 @@ struct ThumbnailsParams
bool transparent_background;
int plate_id;
bool use_plate_box{true};
bool post_processing_enabled{ false };
Vec4f background_color{ 0.0f, 0.0f, 0.0f, 0.0f };
};
typedef std::function<ThumbnailsList(const ThumbnailsParams&)> ThumbnailsGeneratorCallback;

919
src/slic3r/GUI/GLCanvas3D.cpp
View File

File diff suppressed because it is too large Load Diff

63
src/slic3r/GUI/GLCanvas3D.hpp
View File

@ -681,7 +681,7 @@ private:
int assembly_view_count = 0;
std::stack<ERenderPipelineStage> m_render_pipeline_stage_stack;
mutable GLModel m_full_screen_mesh;
static GLModel s_full_screen_mesh;
using FrameCallback = std::function<void()>;
std::vector<FrameCallback> m_frame_callback_list;
@ -929,16 +929,6 @@ public:
Camera::ViewAngleType camera_view_angle_type = Camera::ViewAngleType::Iso,
bool for_picking = false,
bool ban_light = false);
void render_thumbnail(ThumbnailData & thumbnail_data,
unsigned int w,
unsigned int h,
const ThumbnailsParams & thumbnail_params,
ModelObjectPtrs & model_objects,
const GLVolumeCollection &volumes,
Camera::EType camera_type,
Camera::ViewAngleType camera_view_angle_type = Camera::ViewAngleType::Iso,
bool for_picking = false,
bool ban_light = false);
void render_thumbnail(ThumbnailData & thumbnail_data,
std::vector<std::array<float, 4>> &extruder_colors,
unsigned int w,
@ -950,39 +940,10 @@ public:
Camera::ViewAngleType camera_view_angle_type = Camera::ViewAngleType::Iso,
bool for_picking = false,
bool ban_light = false);
static void render_thumbnail_internal(ThumbnailData& thumbnail_data, const ThumbnailsParams& thumbnail_params, PartPlateList& partplate_list, ModelObjectPtrs& model_objects,
const GLVolumeCollection& volumes, std::vector<std::array<float, 4>>& extruder_colors,
const std::shared_ptr<GLShaderProgram>& shader,
Camera::EType camera_type,
Camera::ViewAngleType camera_view_angle_type = Camera::ViewAngleType::Iso,
bool for_picking = false,
bool ban_light = false);
// render thumbnail using an off-screen framebuffer
static void render_thumbnail_framebuffer(ThumbnailData& thumbnail_data, unsigned int w, unsigned int h, const ThumbnailsParams& thumbnail_params,
PartPlateList& partplate_list, ModelObjectPtrs& model_objects, const GLVolumeCollection& volumes, std::vector<std::array<float, 4>>& extruder_colors,
const std::shared_ptr<GLShaderProgram>& shader,
Camera::EType camera_type,
Camera::ViewAngleType camera_view_angle_type = Camera::ViewAngleType::Iso,
bool for_picking = false,
bool ban_light = false);
// render thumbnail using an off-screen framebuffer when GLEW_EXT_framebuffer_object is supported
static void render_thumbnail_framebuffer_ext(ThumbnailData& thumbnail_data, unsigned int w, unsigned int h, const ThumbnailsParams& thumbnail_params,
PartPlateList& partplate_list, ModelObjectPtrs& model_objects, const GLVolumeCollection& volumes, std::vector<std::array<float, 4>>& extruder_colors,
const std::shared_ptr<GLShaderProgram>& shader,
Camera::EType camera_type,
Camera::ViewAngleType camera_view_angle_type = Camera::ViewAngleType::Iso,
bool for_picking = false,
bool ban_light = false);
// render thumbnail using the default framebuffer
static void render_thumbnail_legacy(ThumbnailData & thumbnail_data,
unsigned int w,
unsigned int h,
const ThumbnailsParams & thumbnail_params,
PartPlateList & partplate_list,
ModelObjectPtrs & model_objects,
const GLVolumeCollection & volumes,
std::vector<std::array<float, 4>> &extruder_colors,
// render thumbnail using an off-screen framebuffer
static void render_thumbnail_framebuffer(const std::shared_ptr<OpenGLManager>& p_ogl_manager, ThumbnailData& thumbnail_data, unsigned int w, unsigned int h, const ThumbnailsParams& thumbnail_params,
PartPlateList& partplate_list, ModelObjectPtrs& model_objects, const GLVolumeCollection& volumes, std::vector<std::array<float, 4>>& extruder_colors,
const std::shared_ptr<GLShaderProgram>& shader,
Camera::EType camera_type,
Camera::ViewAngleType camera_view_angle_type = Camera::ViewAngleType::Iso,
@ -1331,10 +1292,6 @@ private:
void _render_silhouette_effect();
void _composite_silhouette_effect();
void _init_fullscreen_mesh() const;
void _composite_main_frame(bool off_screen_rendering_enabled) const;
void _debug_draw_camera(const Camera& t_camera);
void _debug_draw_aabb();
@ -1342,6 +1299,18 @@ private:
void _init_unit_cube();
void _append_to_frame_callback(const FrameCallback& cb);
static void _init_fullscreen_mesh();
static void _rebuild_postprocessing_pipeline(const std::shared_ptr<OpenGLManager>& p_ogl_manager, const std::string& input_framebuffer_name, std::string& output_framebuffer_name, uint32_t width, uint32_t height);
static void _render_thumbnail_internal(ThumbnailData& thumbnail_data, const ThumbnailsParams& thumbnail_params, PartPlateList& partplate_list, ModelObjectPtrs& model_objects,
const GLVolumeCollection& volumes, std::vector<std::array<float, 4>>& extruder_colors,
const std::shared_ptr<GLShaderProgram>& shader,
Camera::EType camera_type,
Camera::ViewAngleType camera_view_angle_type = Camera::ViewAngleType::Iso,
bool for_picking = false,
bool ban_light = false);
};
const ModelVolume *get_model_volume(const GLVolume &v, const Model &model);

70
src/slic3r/GUI/OpenGLManager.cpp
View File

@ -732,15 +732,28 @@ void OpenGLManager::_bind_frame_buffer(const std::string& name, EMSAAType msaa_t
glsafe(BBS_GL_EXTENSION_FUNC(::glBindFramebuffer)(BBS_GL_EXTENSION_PARAMETER(GL_FRAMEBUFFER), 0));
return;
}
const auto& iter = m_name_to_framebuffer.find(name);
if (iter == m_name_to_framebuffer.end()) {
uint32_t width = t_width == 0 ? m_viewport_width : t_width;
uint32_t height = t_height == 0 ? m_viewport_height : t_height;
if (s_picking_frame == name) {
width = 1;
height = 1;
}
const auto& p_frame_buffer = std::make_shared<FrameBuffer>(width, height, msaa_type);
FrameBufferParams t_fb_params;
t_fb_params.m_width = width;
t_fb_params.m_height = height;
t_fb_params.m_msaa_type = msaa_type;
const auto& iter = m_name_to_framebuffer.find(name);
bool needs_to_recreate = false;
if (iter == m_name_to_framebuffer.end()) {
needs_to_recreate = true;
}
else {
needs_to_recreate = !iter->second->is_format_equal(t_fb_params);
}
if (needs_to_recreate) {
const auto& p_frame_buffer = std::make_shared<FrameBuffer>(t_fb_params);
m_name_to_framebuffer.insert_or_assign(name, p_frame_buffer);
}
@ -749,10 +762,10 @@ void OpenGLManager::_bind_frame_buffer(const std::string& name, EMSAAType msaa_t
if (current_framebuffer) {
current_framebuffer->unbind();
}
}
m_name_to_framebuffer[name]->bind();
m_current_binded_framebuffer = m_name_to_framebuffer[name];
}
}
void OpenGLManager::_unbind_frame_buffer(const std::string& name)
{
@ -962,6 +975,16 @@ void OpenGLManager::set_line_width(float width) const
}
}
void OpenGLManager::set_legacy_framebuffer_enabled(bool is_enabled)
{
m_b_legacy_framebuffer_enabled = is_enabled;
}
bool OpenGLManager::is_legacy_framebuffer_enabled() const
{
return m_b_legacy_framebuffer_enabled;
}
std::string OpenGLManager::framebuffer_type_to_string(EFramebufferType type)
{
switch (type)
@ -1037,10 +1060,10 @@ void OpenGLManager::detect_multisample(int* attribList)
// s_multisample = enable_multisample && wxGLCanvas::IsExtensionSupported("WGL_ARB_multisample");
}
FrameBuffer::FrameBuffer(uint32_t width, uint32_t height, EMSAAType msaa_type)
: m_width(width)
, m_height(height)
, m_msaa_type(msaa_type)
FrameBuffer::FrameBuffer(const FrameBufferParams& params)
: m_width(params.m_width)
, m_height(params.m_height)
, m_msaa_type(params.m_msaa_type)
{
}
@ -1110,7 +1133,8 @@ void FrameBuffer::bind()
}
BOOST_LOG_TRIVIAL(trace) << "Successfully created framebuffer: width = " << m_width << ", heihgt = " << m_height;
}
m_needs_to_solve = (m_gl_id_for_back_fbo != UINT32_MAX);
mark_needs_to_resolve();
glsafe(BBS_GL_EXTENSION_FUNC(::glBindFramebuffer)(BBS_GL_EXTENSION_PARAMETER(GL_FRAMEBUFFER), (UINT32_MAX == m_gl_id_for_back_fbo ? m_gl_id : m_gl_id_for_back_fbo)));
}
@ -1160,6 +1184,29 @@ void FrameBuffer::read_pixel(uint32_t x, uint32_t y, uint32_t width, uint32_t he
glsafe(BBS_GL_EXTENSION_FUNC(::glBindFramebuffer)(BBS_GL_EXTENSION_PARAMETER(GL_FRAMEBUFFER), 0));
}
uint32_t FrameBuffer::get_height() const
{
return m_height;
}
uint32_t FrameBuffer::get_width() const
{
return m_width;
}
EMSAAType FrameBuffer::get_msaa_type() const
{
return m_msaa_type;
}
bool FrameBuffer::is_format_equal(const FrameBufferParams& params) const
{
const bool rt = m_width == params.m_width
&& m_height == params.m_height
&& m_msaa_type == params.m_msaa_type;
return rt;
}
void FrameBuffer::create_no_msaa_fbo(bool with_depth)
{
const OpenGLManager::EFramebufferType framebuffer_type = OpenGLManager::get_framebuffers_type();
@ -1299,6 +1346,11 @@ void FrameBuffer::resolve()
m_needs_to_solve = false;
}
void FrameBuffer::mark_needs_to_resolve()
{
m_needs_to_solve = (m_gl_id_for_back_fbo != UINT32_MAX);
}
OpenGLManager::FrameBufferModifier::FrameBufferModifier(OpenGLManager& ogl_manager, const std::string& frame_buffer_name, EMSAAType msaa_type)
: m_ogl_manager(ogl_manager)
, m_frame_buffer_name(frame_buffer_name)

20
src/slic3r/GUI/OpenGLManager.hpp
View File

@ -45,9 +45,16 @@ enum class EPixelDataType : uint16_t
Float
};
struct FrameBufferParams
{
uint32_t m_width{ 0 };
uint32_t m_height{ 0 };
EMSAAType m_msaa_type{ EMSAAType::Disabled };
};
struct FrameBuffer
{
FrameBuffer(uint32_t width, uint32_t height, EMSAAType msaa_type);
FrameBuffer(const FrameBufferParams& params);
~FrameBuffer();
void bind();
@ -61,6 +68,13 @@ struct FrameBuffer
void read_pixel(uint32_t x, uint32_t y, uint32_t width, uint32_t height, EPixelFormat format, EPixelDataType type, void* pixels);
uint32_t get_height() const;
uint32_t get_width() const;
EMSAAType get_msaa_type() const;
bool is_format_equal(const FrameBufferParams& params) const;
private:
enum EBlitOptionType
{
@ -74,6 +88,7 @@ private:
void create_msaa_fbo();
bool check_frame_buffer_status() const;
void resolve();
void mark_needs_to_resolve();
private:
uint32_t m_width{ 0 };
uint32_t m_height{ 0 };
@ -201,6 +216,7 @@ private:
EMSAAType m_msaa_type{ EMSAAType::X4 };
EVAOType m_vao_type{ EVAOType::Unknown };
uint32_t m_vao{ 0 };
bool m_b_legacy_framebuffer_enabled{ true };
static GLInfo s_gl_info;
#ifdef __APPLE__
// Part of hack to remove crash when closing the application on OSX 10.9.5 when building against newer wxWidgets
@ -235,6 +251,8 @@ public:
void unbind_vao();
void release_vao();
void set_line_width(float width) const;
void set_legacy_framebuffer_enabled(bool is_enabled);
bool is_legacy_framebuffer_enabled() const;
void set_msaa_type(const std::string& type);
void set_msaa_type(EMSAAType type);

4
src/slic3r/GUI/Plater.cpp
View File

@ -12061,9 +12061,13 @@ void Plater::update_all_plate_thumbnails(bool force_update)
PartPlate* plate = get_partplate_list().get_plate(i);
ThumbnailsParams thumbnail_params = { {}, false, true, true, true, i};
if (force_update || !plate->thumbnail_data.is_valid()) {
thumbnail_params.background_color = Vec4f(0.0f, 0.0f, 0.0f, 0.0f);
thumbnail_params.post_processing_enabled = true;
get_view3D_canvas3D()->render_thumbnail(plate->thumbnail_data, plate->plate_thumbnail_width, plate->plate_thumbnail_height, thumbnail_params, Camera::EType::Ortho);
}
if (force_update || !plate->no_light_thumbnail_data.is_valid()) {
thumbnail_params.background_color = Vec4f(0.0f, 0.0f, 0.0f, 0.0f);
thumbnail_params.post_processing_enabled = true;
get_view3D_canvas3D()->render_thumbnail(plate->no_light_thumbnail_data, plate->plate_thumbnail_width, plate->plate_thumbnail_height, thumbnail_params,
Camera::EType::Ortho, Camera::ViewAngleType::Iso, false, true);
}

24
src/slic3r/Utils/CalibUtils.cpp
View File

@ -1360,30 +1360,10 @@ bool CalibUtils::process_and_store_3mf(Model *model, const DynamicPrintConfig &f
}
}
const auto fb_type = Slic3r::GUI::OpenGLManager::get_framebuffers_type();
BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": framebuffer_type: %1%") % Slic3r::GUI::OpenGLManager::framebuffer_type_to_string(fb_type).c_str();
switch (fb_type)
{
case Slic3r::GUI::OpenGLManager::EFramebufferType::Supported:
case Slic3r::GUI::OpenGLManager::EFramebufferType::Arb:
{
Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer(*thumbnail_data,
const auto& p_ogl_manager = Slic3r::GUI::wxGetApp().get_opengl_manager();
Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer(p_ogl_manager, *thumbnail_data,
thumbnail_width, thumbnail_height, thumbnail_params,
partplate_list, model->objects, glvolume_collection, colors_out, shader, Slic3r::GUI::Camera::EType::Ortho);
break;
}
case Slic3r::GUI::OpenGLManager::EFramebufferType::Ext:
{
Slic3r::GUI::GLCanvas3D::render_thumbnail_framebuffer_ext(*thumbnail_data,
thumbnail_width, thumbnail_height, thumbnail_params,
partplate_list, model->objects, glvolume_collection, colors_out, shader, Slic3r::GUI::Camera::EType::Ortho);
break;
}
default:{
Slic3r::GUI::GLCanvas3D::render_thumbnail_legacy(*thumbnail_data, thumbnail_width, thumbnail_height, thumbnail_params, partplate_list, model->objects, glvolume_collection, colors_out, shader, Slic3r::GUI::Camera::EType::Ortho);
break;
}
}
thumbnails.push_back(thumbnail_data);
}