GitHub-Proxy/PrusaSlicer
1
0
Fork 0
mirror of https://git.mirrors.martin98.com/https://github.com/prusa3d/PrusaSlicer.git synced 2025-07-31 04:52:01 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Some refactoring and cleanup

Browse Source
This commit is contained in:
enricoturri1966 2023-10-26 10:44:23 +02:00 committed by Lukas Matena
parent 87da6d18b8
commit 8073bdea90
14 changed files with 233 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1175,15 +1175,13 @@ void GCodeViewer::render()
std::memcpy(converted_view_matrix.data(), view_matrix.data(), 16 * sizeof(float));
libvgcode::Mat4x4f converted_projetion_matrix;
std::memcpy(converted_projetion_matrix.data(), projection_matrix.data(), 16 * sizeof(float));
libvgcode::Vec3f converted_camera_position;
std::memcpy(converted_camera_position.data(), camera_position.data(), 3 * sizeof(float));
libvgcode::Vec3f converted_tool_marker_position;
std::memcpy(converted_tool_marker_position.data(), m_sequential_view.current_position.data(), 3 * sizeof(float));
m_gcode_viewer_2.set_cog_marker_scale_factor(m_cog_marker_fixed_screen_size ? 10.0f * m_cog_marker_size * camera.get_inv_zoom() : m_cog_marker_size);
m_gcode_viewer_2.set_tool_marker_position(converted_tool_marker_position);
m_gcode_viewer_2.set_tool_marker_scale_factor(m_tool_marker_fixed_screen_size ? 10.0f * m_tool_marker_size * camera.get_inv_zoom() : m_tool_marker_size);
m_gcode_viewer_2.render(converted_view_matrix, converted_projetion_matrix, converted_camera_position);
m_gcode_viewer_2.render(converted_view_matrix, converted_projetion_matrix);
}
else
#endif // ENABLE_NEW_GCODE_VIEWER

12
src/slic3r/GUI/LibVGCode/CogMarker.cpp
View File

@ -63,7 +63,7 @@ void CogMarker::init(uint8_t resolution, float radius)
const float xy = radius * std::cos(stack_angle);
const float z = radius * std::sin(stack_angle);
if (i == 0 || i == stack_count) {
const Vec3f pos = toVec3f(xy, 0.0f, z);
const Vec3f pos = { xy, 0.0f, z };
const Vec3f norm = normalize(pos);
add_vertex(pos, norm, vertices);
}
@ -71,7 +71,7 @@ void CogMarker::init(uint8_t resolution, float radius)
for (uint16_t j = 0; j < sector_count; ++j) {
// from 0 to 2pi
const float sector_angle = sector_step * float(j);
const Vec3f pos = toVec3f(xy * std::cos(sector_angle), xy * std::sin(sector_angle), z);
const Vec3f pos = { xy * std::cos(sector_angle), xy * std::sin(sector_angle), z };
const Vec3f norm = normalize(pos);
add_vertex(pos, norm, vertices);
}
@ -145,14 +145,14 @@ void CogMarker::render()
}
void CogMarker::update(const Vec3f& position, float mass)
{
m_total_position = m_total_position + toVec3f(mass * position[0], mass * position[1], mass * position[2]);
{
m_total_position = m_total_position + mass * position;
m_total_mass += mass;
}
void CogMarker::reset()
{
m_total_position = toVec3f(0.0f);
m_total_position = { 0.0f, 0.0f, 0.0f };
m_total_mass = 0.0f;
}
@ -160,7 +160,7 @@ Vec3f CogMarker::get_position() const
{
assert(m_total_mass > 0.0f);
const float inv_total_mass = 1.0f / m_total_mass;
return { m_total_position[0] * inv_total_mass, m_total_position[1] * inv_total_mass, m_total_position[2] * inv_total_mass };
return inv_total_mass * m_total_position;
}
} // namespace libvgcode

2
src/slic3r/GUI/LibVGCode/CogMarker.hpp
View File

@ -52,7 +52,7 @@ private:
// Values used to calculate the center of gravity
//
float m_total_mass{ 0.0f };
Vec3f m_total_position{ toVec3f(0.0f) };
Vec3f m_total_position{ 0.0f, 0.0f, 0.0f };
uint16_t m_indices_count{ 0 };
unsigned int m_vao_id{ 0 };

8
src/slic3r/GUI/LibVGCode/OptionTemplate.cpp
View File

@ -50,10 +50,10 @@ void OptionTemplate::init(uint8_t resolution)
//
std::vector<float> top_vertices;
top_vertices.reserve(6 * m_vertices_count);
add_vertex(toVec3f(0.0f, 0.0f, 0.5f), toVec3f(0.0f, 0.0f, 1.0f), top_vertices);
add_vertex({ 0.0f, 0.0f, 0.5f }, { 0.0f, 0.0f, 1.0f }, top_vertices);
for (uint8_t i = 0; i <= m_resolution; ++i) {
const float ii = float(i) * step;
const Vec3f pos = toVec3f(0.5f * ::cos(ii), 0.5f * ::sin(ii), 0.0f);
const Vec3f pos = { 0.5f * ::cos(ii), 0.5f * ::sin(ii), 0.0f };
const Vec3f norm = normalize(pos);
add_vertex(pos, norm, top_vertices);
}
@ -63,10 +63,10 @@ void OptionTemplate::init(uint8_t resolution)
//
std::vector<float> bottom_vertices;
bottom_vertices.reserve(6 * m_vertices_count);
add_vertex(toVec3f(0.0f, 0.0f, -0.5f), toVec3f(0.0f, 0.0f, -1.0f), bottom_vertices);
add_vertex({ 0.0f, 0.0f, -0.5f }, { 0.0f, 0.0f, -1.0f }, bottom_vertices);
for (uint8_t i = 0; i <= m_resolution; ++i) {
const float ii = -float(i) * step;
const Vec3f pos = toVec3f(0.5f * ::cos(ii), 0.5f * ::sin(ii), 0.0f);
const Vec3f pos = { 0.5f * ::cos(ii), 0.5f * ::sin(ii), 0.0f };
const Vec3f norm = normalize(pos);
add_vertex(pos, norm, bottom_vertices);
}

2
src/slic3r/GUI/LibVGCode/PathVertex.hpp
View File

@ -18,7 +18,7 @@ namespace libvgcode {
struct PathVertex
{
Vec3f position{ toVec3f(0.0f) };
Vec3f position{ 0.0f, 0.0f, 0.0f };
float height{ 0.0f };
float width{ 0.0f };
float feedrate{ 0.0f };

16
src/slic3r/GUI/LibVGCode/ToolMarker.cpp
View File

@ -64,9 +64,9 @@ void ToolMarker::init(uint16_t resolution, float tip_radius, float tip_height, f
const float total_height = tip_height + stem_height;
// tip vertices
add_vertex(toVec3f(0.0f), toVec3f(0.0f, 0.0f, -1.0f), vertices);
add_vertex({ 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, -1.0f }, vertices);
for (uint16_t i = 0; i < resolution; ++i) {
add_vertex(toVec3f(tip_radius * sines[i], tip_radius * cosines[i], tip_height), toVec3f(sines[i], cosines[i], 0.0f), vertices);
add_vertex({ tip_radius * sines[i], tip_radius * cosines[i], tip_height }, { sines[i], cosines[i], 0.0f }, vertices);
}
// tip triangles
@ -77,12 +77,12 @@ void ToolMarker::init(uint16_t resolution, float tip_radius, float tip_height, f
// tip cap outer perimeter vertices
for (uint16_t i = 0; i < resolution; ++i) {
add_vertex(toVec3f(tip_radius * sines[i], tip_radius * cosines[i], tip_height), toVec3f(0.0f, 0.0f, 1.0f), vertices);
add_vertex({ tip_radius * sines[i], tip_radius * cosines[i], tip_height }, { 0.0f, 0.0f, 1.0f }, vertices);
}
// tip cap inner perimeter vertices
for (uint16_t i = 0; i < resolution; ++i) {
add_vertex(toVec3f(stem_radius * sines[i], stem_radius * cosines[i], tip_height), toVec3f(0.0f, 0.0f, 1.0f), vertices);
add_vertex({ stem_radius * sines[i], stem_radius * cosines[i], tip_height }, { 0.0f, 0.0f, 1.0f }, vertices);
}
// tip cap triangles
@ -95,12 +95,12 @@ void ToolMarker::init(uint16_t resolution, float tip_radius, float tip_height, f
// stem bottom vertices
for (uint16_t i = 0; i < resolution; ++i) {
add_vertex(toVec3f(stem_radius * sines[i], stem_radius * cosines[i], tip_height), toVec3f(sines[i], cosines[i], 0.0f), vertices);
add_vertex({ stem_radius * sines[i], stem_radius * cosines[i], tip_height }, { sines[i], cosines[i], 0.0f }, vertices);
}
// stem top vertices
for (uint16_t i = 0; i < resolution; ++i) {
add_vertex(toVec3f(stem_radius * sines[i], stem_radius * cosines[i], total_height), toVec3f(sines[i], cosines[i], 0.0f), vertices);
add_vertex({ stem_radius * sines[i], stem_radius * cosines[i], total_height }, { sines[i], cosines[i], 0.0f }, vertices);
}
// stem triangles
@ -112,9 +112,9 @@ void ToolMarker::init(uint16_t resolution, float tip_radius, float tip_height, f
}
// stem cap vertices
add_vertex(toVec3f(0.0f, 0.0f, total_height), toVec3f(0.0f, 0.0f, 1.0f), vertices);
add_vertex({ 0.0f, 0.0f, total_height }, { 0.0f, 0.0f, 1.0f }, vertices);
for (uint16_t i = 0; i < resolution; ++i) {
add_vertex(toVec3f(stem_radius * sines[i], stem_radius * cosines[i], total_height), toVec3f(0.0f, 0.0f, 1.0f), vertices);
add_vertex({ stem_radius * sines[i], stem_radius * cosines[i], total_height }, { 0.0f, 0.0f, 1.0f }, vertices);
}
// stem cap triangles

2
src/slic3r/GUI/LibVGCode/ToolMarker.hpp
View File

@ -39,7 +39,7 @@ public:
void set_alpha(float alpha);
private:
Vec3f m_position{ toVec3f(0.0f) };
Vec3f m_position{ 0.0f, 0.0f, 0.0f };
Color m_color{ 1.0f, 1.0f, 1.0f };
float m_alpha{ 0.5f };

159
src/slic3r/GUI/LibVGCode/Toolpaths.cpp
View File

@ -12,6 +12,7 @@
#include "Settings.hpp"
#include "Shaders.hpp"
#include "OpenGLUtils.hpp"
#include "Utils.hpp"
//################################################################################################################################
// PrusaSlicer development only -> !!!TO BE REMOVED!!!
@ -27,14 +28,14 @@ namespace libvgcode {
//################################################################################################################################
// PrusaSlicer development only -> !!!TO BE REMOVED!!!
static uint8_t valueof(Slic3r::EMoveType type)
static EMoveType valueof(Slic3r::EMoveType type)
{
return static_cast<uint8_t>(type);
return static_cast<EMoveType>(static_cast<uint8_t>(type));
}
static uint8_t valueof(Slic3r::GCodeExtrusionRole role)
static EGCodeExtrusionRole valueof(Slic3r::GCodeExtrusionRole role)
{
return static_cast<uint8_t>(role);
return static_cast<EGCodeExtrusionRole>(static_cast<uint8_t>(role));
}
static Vec3f toVec3f(const Eigen::Matrix<float, 3, 1, Eigen::DontAlign>& v)
@ -166,6 +167,137 @@ bool decode_colors(const std::vector<std::string>& colors_in, std::vector<Color>
return true;
}
static Mat4x4f inverse(const Mat4x4f& m)
{
// ref: https://stackoverflow.com/questions/1148309/inverting-a-4x4-matrix
std::array<float, 16> inv;
inv[0] = m[5] * m[10] * m[15] -
m[5] * m[11] * m[14] -
m[9] * m[6] * m[15] +
m[9] * m[7] * m[14] +
m[13] * m[6] * m[11] -
m[13] * m[7] * m[10];
inv[4] = -m[4] * m[10] * m[15] +
m[4] * m[11] * m[14] +
m[8] * m[6] * m[15] -
m[8] * m[7] * m[14] -
m[12] * m[6] * m[11] +
m[12] * m[7] * m[10];
inv[8] = m[4] * m[9] * m[15] -
m[4] * m[11] * m[13] -
m[8] * m[5] * m[15] +
m[8] * m[7] * m[13] +
m[12] * m[5] * m[11] -
m[12] * m[7] * m[9];
inv[12] = -m[4] * m[9] * m[14] +
m[4] * m[10] * m[13] +
m[8] * m[5] * m[14] -
m[8] * m[6] * m[13] -
m[12] * m[5] * m[10] +
m[12] * m[6] * m[9];
inv[1] = -m[1] * m[10] * m[15] +
m[1] * m[11] * m[14] +
m[9] * m[2] * m[15] -
m[9] * m[3] * m[14] -
m[13] * m[2] * m[11] +
m[13] * m[3] * m[10];
inv[5] = m[0] * m[10] * m[15] -
m[0] * m[11] * m[14] -
m[8] * m[2] * m[15] +
m[8] * m[3] * m[14] +
m[12] * m[2] * m[11] -
m[12] * m[3] * m[10];
inv[9] = -m[0] * m[9] * m[15] +
m[0] * m[11] * m[13] +
m[8] * m[1] * m[15] -
m[8] * m[3] * m[13] -
m[12] * m[1] * m[11] +
m[12] * m[3] * m[9];
inv[13] = m[0] * m[9] * m[14] -
m[0] * m[10] * m[13] -
m[8] * m[1] * m[14] +
m[8] * m[2] * m[13] +
m[12] * m[1] * m[10] -
m[12] * m[2] * m[9];
inv[2] = m[1] * m[6] * m[15] -
m[1] * m[7] * m[14] -
m[5] * m[2] * m[15] +
m[5] * m[3] * m[14] +
m[13] * m[2] * m[7] -
m[13] * m[3] * m[6];
inv[6] = -m[0] * m[6] * m[15] +
m[0] * m[7] * m[14] +
m[4] * m[2] * m[15] -
m[4] * m[3] * m[14] -
m[12] * m[2] * m[7] +
m[12] * m[3] * m[6];
inv[10] = m[0] * m[5] * m[15] -
m[0] * m[7] * m[13] -
m[4] * m[1] * m[15] +
m[4] * m[3] * m[13] +
m[12] * m[1] * m[7] -
m[12] * m[3] * m[5];
inv[14] = -m[0] * m[5] * m[14] +
m[0] * m[6] * m[13] +
m[4] * m[1] * m[14] -
m[4] * m[2] * m[13] -
m[12] * m[1] * m[6] +
m[12] * m[2] * m[5];
inv[3] = -m[1] * m[6] * m[11] +
m[1] * m[7] * m[10] +
m[5] * m[2] * m[11] -
m[5] * m[3] * m[10] -
m[9] * m[2] * m[7] +
m[9] * m[3] * m[6];
inv[7] = m[0] * m[6] * m[11] -
m[0] * m[7] * m[10] -
m[4] * m[2] * m[11] +
m[4] * m[3] * m[10] +
m[8] * m[2] * m[7] -
m[8] * m[3] * m[6];
inv[11] = -m[0] * m[5] * m[11] +
m[0] * m[7] * m[9] +
m[4] * m[1] * m[11] -
m[4] * m[3] * m[9] -
m[8] * m[1] * m[7] +
m[8] * m[3] * m[5];
inv[15] = m[0] * m[5] * m[10] -
m[0] * m[6] * m[9] -
m[4] * m[1] * m[10] +
m[4] * m[2] * m[9] +
m[8] * m[1] * m[6] -
m[8] * m[2] * m[5];
float det = m[0] * inv[0] + m[1] * inv[4] + m[2] * inv[8] + m[3] * inv[12];
assert(det != 0.0f);
det = 1.0 / det;
std::array<float, 16> ret = {};
for (int i = 0; i < 16; ++i) {
ret[i] = inv[i] * det;
}
return ret;
}
std::string check_shader(GLuint handle)
{
std::string ret;
@ -370,8 +502,8 @@ void Toolpaths::load(const Slic3r::GCodeProcessorResult& gcode_result, const std
for (size_t i = 1; i < gcode_result.moves.size(); ++i) {
const Slic3r::GCodeProcessorResult::MoveVertex& curr = gcode_result.moves[i];
const Slic3r::GCodeProcessorResult::MoveVertex& prev = gcode_result.moves[i - 1];
const EMoveType curr_type = static_cast<EMoveType>(valueof(curr.type));
const EGCodeExtrusionRole curr_role = static_cast<EGCodeExtrusionRole>(valueof(curr.extrusion_role));
const EMoveType curr_type = valueof(curr.type);
const EGCodeExtrusionRole curr_role = valueof(curr.extrusion_role);
EGCodeExtrusionRole extrusion_role;
if (curr_type == EMoveType::Travel) {
@ -430,6 +562,8 @@ void Toolpaths::load(const Slic3r::GCodeProcessorResult& gcode_result, const std
m_valid_lines_bitset = BitSet<>(m_vertices.size());
m_valid_lines_bitset.setAll();
static constexpr const Vec3f ZERO = { 0.0f, 0.0f, 0.0f };
// buffers to send to gpu
std::vector<Vec3f> positions;
std::vector<Vec3f> heights_widths_angles;
@ -440,13 +574,13 @@ void Toolpaths::load(const Slic3r::GCodeProcessorResult& gcode_result, const std
const EMoveType move_type = v.type;
const bool prev_line_valid = i > 0 && m_valid_lines_bitset[i - 1];
const Vec3f prev_line = prev_line_valid ? v.position - m_vertices[i - 1].position : toVec3f(0.0f);
const Vec3f prev_line = prev_line_valid ? v.position - m_vertices[i - 1].position : ZERO;
const bool this_line_valid = i + 1 < m_vertices.size() &&
m_vertices[i + 1].position != v.position &&
m_vertices[i + 1].type == move_type &&
move_type != EMoveType::Seam;
const Vec3f this_line = this_line_valid ? m_vertices[i + 1].position - v.position : toVec3f(0.0f);
const Vec3f this_line = this_line_valid ? m_vertices[i + 1].position - v.position : ZERO;
if (this_line_valid) {
// there is a valid path between point i and i+1.
@ -463,7 +597,7 @@ void Toolpaths::load(const Slic3r::GCodeProcessorResult& gcode_result, const std
positions.emplace_back(position);
const float angle = atan2(prev_line[0] * this_line[1] - prev_line[1] * this_line[0], dot(prev_line, this_line));
heights_widths_angles.push_back(toVec3f(v.height, v.width, angle));
heights_widths_angles.push_back({ v.height, v.width, angle });
}
if (!positions.empty()) {
@ -601,8 +735,11 @@ void Toolpaths::update_colors(const Settings& settings)
glsafe(glBindBuffer(GL_TEXTURE_BUFFER, 0));
}
void Toolpaths::render(const Mat4x4f& view_matrix, const Mat4x4f& projection_matrix, const Vec3f& camera_position, const Settings& settings)
void Toolpaths::render(const Mat4x4f& view_matrix, const Mat4x4f& projection_matrix, const Settings& settings)
{
const Mat4x4f inv_view_matrix = inverse(view_matrix);
const Vec3f camera_position = { inv_view_matrix[12], inv_view_matrix[13], inv_view_matrix[14] };
render_segments(view_matrix, projection_matrix, camera_position);
render_options(view_matrix, projection_matrix);
if (settings.options_visibility.at(EOptionType::ToolMarker))
@ -871,7 +1008,7 @@ Color Toolpaths::select_color(const PathVertex& v, const Settings& settings) con
}
case EViewType::Tool:
{
assert(v.get_extruder_id() < m_tool_colors.size());
assert(static_cast<size_t>(v.extruder_id) < m_tool_colors.size());
return m_tool_colors[v.extruder_id];
}
case EViewType::ColorPrint:

3
src/slic3r/GUI/LibVGCode/Toolpaths.hpp
View File

@ -69,8 +69,7 @@ public:
//
// Render the toolpaths
//
void render(const Mat4x4f& view_matrix, const Mat4x4f& projection_matrix,
const Vec3f& camera_position, const Settings& settings);
void render(const Mat4x4f& view_matrix, const Mat4x4f& projection_matrix, const Settings& settings);
//
// Properties getters

93
src/slic3r/GUI/LibVGCode/Types.hpp
View File

@ -10,86 +10,17 @@
#if ENABLE_NEW_GCODE_VIEWER
//################################################################################################################################
#define LIBVGCODE_USE_EIGEN 0
#if LIBVGCODE_USE_EIGEN
#include <Eigen/Geometry>
#else
#include <map>
#include <array>
#endif // LIBVGCODE_USE_EIGEN
namespace libvgcode {
#if LIBVGCODE_USE_EIGEN
using Vec3f = Eigen::Matrix<float, 3, 1, Eigen::DontAlign>;
using Mat4x4f = Eigen::Matrix<float, 4, 4, Eigen::DontAlign>;
static float dot(const Vec3f& v1, const Vec3f& v2)
{
return v1.dot(v2);
}
static Vec3f normalize(const Vec3f& v)
{
return v.normalized();
}
static float length(const Vec3f& v)
{
return v.norm();
}
#else
using Vec3f = std::array<float, 3>;
using Mat4x4f = std::array<float, 16>;
static float dot(const Vec3f& v1, const Vec3f& v2)
{
return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
}
static Vec3f normalize(const Vec3f& v)
{
const float length = std::sqrt(dot(v, v));
assert(length > 0.0f);
const float inv_length = 1.0f / length;
return { v[0] * inv_length, v[1] * inv_length, v[2] * inv_length };
}
static float length(const Vec3f& v)
{
return std::sqrt(dot(v, v));
}
#endif // LIBVGCODE_USE_EIGEN
static_assert(sizeof(Vec3f) == 3 * sizeof(float));
static Vec3f toVec3f(float value) { return { value, value, value }; };
static Vec3f toVec3f(float x, float y, float z) { return { x, y, z }; };
static bool operator == (const Vec3f& v1, const Vec3f& v2) {
return v1[0] == v2[0] && v1[1] == v2[1] && v1[2] == v2[2];
}
static bool operator != (const Vec3f& v1, const Vec3f& v2) {
return v1[0] != v2[0] || v1[1] != v2[1] || v1[2] != v2[2];
}
static Vec3f operator + (const Vec3f& v1, const Vec3f& v2) {
return { v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2] };
}
static Vec3f operator - (const Vec3f& v1, const Vec3f& v2) {
return { v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2] };
}
static Vec3f operator * (float f, const Vec3f& v) {
return { f * v[0], f * v[1], f * v[2] };
}
using Color = std::array<float, 3>;
static constexpr float PI = 3.141592f;
using Vec3f = std::array<float, 3>;
// 4 by 4 square matrix with column-major order
using Mat4x4f = std::array<float, 16>;
using Color = std::array<float, 3>;
// Alias for GCodeViewer::EViewType defined into GCodeViewer.hpp
enum class EViewType : uint8_t
{
@ -103,7 +34,8 @@ enum class EViewType : uint8_t
LayerTimeLinear,
LayerTimeLogarithmic,
Tool,
ColorPrint
ColorPrint,
COUNT
};
// Alias for EMoveType defined into GCodeProcessor.hpp
@ -119,7 +51,8 @@ enum class EMoveType : uint8_t
CustomGCode,
Travel,
Wipe,
Extrude
Extrude,
COUNT
};
// Alias for GCodeExtrusionRole defined into ExtrusionRole.hpp
@ -139,7 +72,8 @@ enum class EGCodeExtrusionRole : uint8_t
SupportMaterial,
SupportMaterialInterface,
WipeTower,
Custom
Custom,
COUNT
};
// Alias for Preview::OptionType defined into GUI_Preview.hpp
@ -168,11 +102,6 @@ enum class ETimeMode : uint8_t
COUNT
};
static uint8_t valueof(EMoveType type)
{
return static_cast<uint8_t>(type);
}
} // namespace libvgcode
//################################################################################################################################

40
src/slic3r/GUI/LibVGCode/Utils.cpp
View File

@ -9,6 +9,8 @@
///|/
#include "Utils.hpp"
#include <cmath>
//################################################################################################################################
// PrusaSlicer development only -> !!!TO BE REMOVED!!!
#if ENABLE_NEW_GCODE_VIEWER
@ -33,6 +35,44 @@ void add_triangle(uint16_t v1, uint16_t v2, uint16_t v3, std::vector<uint16_t>&
indices.emplace_back(v3);
}
Vec3f normalize(const Vec3f& v)
{
const float length = std::sqrt(dot(v, v));
assert(length > 0.0f);
const float inv_length = 1.0f / length;
return { v[0] * inv_length, v[1] * inv_length, v[2] * inv_length };
}
float dot(const Vec3f& v1, const Vec3f& v2)
{
return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
}
float length(const Vec3f& v)
{
return std::sqrt(dot(v, v));
}
bool operator == (const Vec3f& v1, const Vec3f& v2) {
return v1[0] == v2[0] && v1[1] == v2[1] && v1[2] == v2[2];
}
bool operator != (const Vec3f& v1, const Vec3f& v2) {
return v1[0] != v2[0] || v1[1] != v2[1] || v1[2] != v2[2];
}
Vec3f operator + (const Vec3f& v1, const Vec3f& v2) {
return { v1[0] + v2[0], v1[1] + v2[1], v1[2] + v2[2] };
}
Vec3f operator - (const Vec3f& v1, const Vec3f& v2) {
return { v1[0] - v2[0], v1[1] - v2[1], v1[2] - v2[2] };
}
Vec3f operator * (float f, const Vec3f& v) {
return { f * v[0], f * v[1], f * v[2] };
}
} // namespace libvgcode
//################################################################################################################################

8
src/slic3r/GUI/LibVGCode/Utils.hpp
View File

@ -19,6 +19,14 @@ namespace libvgcode {
extern void add_vertex(const Vec3f& position, const Vec3f& normal, std::vector<float>& vertices);
extern void add_triangle(uint16_t v1, uint16_t v2, uint16_t v3, std::vector<uint16_t>& indices);
extern Vec3f normalize(const Vec3f& v);
extern float dot(const Vec3f& v1, const Vec3f& v2);
extern float length(const Vec3f& v);
extern bool operator == (const Vec3f& v1, const Vec3f& v2);
extern bool operator != (const Vec3f& v1, const Vec3f& v2);
extern Vec3f operator + (const Vec3f& v1, const Vec3f& v2);
extern Vec3f operator - (const Vec3f& v1, const Vec3f& v2);
extern Vec3f operator * (float f, const Vec3f& v);
} // namespace libvgcode

4
src/slic3r/GUI/LibVGCode/Viewer.cpp
View File

@ -110,7 +110,7 @@ void Viewer::load(const Slic3r::GCodeProcessorResult& gcode_result, const std::v
m_settings.update_colors = true;
}
void Viewer::render(const Mat4x4f& view_matrix, const Mat4x4f& projection_matrix, const Vec3f& camera_position)
void Viewer::render(const Mat4x4f& view_matrix, const Mat4x4f& projection_matrix)
{
if (m_settings.update_enabled_entities) {
m_toolpaths.update_enabled_entities(m_view_range, m_settings);
@ -122,7 +122,7 @@ void Viewer::render(const Mat4x4f& view_matrix, const Mat4x4f& projection_matrix
m_settings.update_colors = false;
}
m_toolpaths.render(view_matrix, projection_matrix, camera_position, m_settings);
m_toolpaths.render(view_matrix, projection_matrix, m_settings);
//################################################################################################################################
// Debug

2
src/slic3r/GUI/LibVGCode/Viewer.hpp
View File

@ -36,7 +36,7 @@ public:
void init();
void load(const Slic3r::GCodeProcessorResult& gcode_result, const std::vector<std::string>& str_tool_colors);
void render(const Mat4x4f& view_matrix, const Mat4x4f& projection_matrix, const Vec3f& camera_position);
void render(const Mat4x4f& view_matrix, const Mat4x4f& projection_matrix);
EViewType get_view_type() const;
void set_view_type(EViewType type);