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

Replaced all "long long" types with int64_t

Browse source 
Replaced all "unsigned long long" types with uint64_t.
These "new" types better communicate their meaning and they are
guaranteed to behave the same on all platforms & compilers.
This commit is contained in:
Vojtech Bubnik 2020-12-10 08:40:08 +01:00
parent fbf2978190
commit bd79036d13
9 changed files with 52 additions and 45 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
src/libslic3r/GCode/GCodeProcessor.hpp
View file

@ -7,6 +7,7 @@
#include "libslic3r/PrintConfig.hpp" #include "libslic3r/PrintConfig.hpp"
#include "libslic3r/CustomGCode.hpp" #include "libslic3r/CustomGCode.hpp"
#include <cstdint>
#include <array> #include <array>
#include <vector> #include <vector>
#include <string> #include <string>
@ -298,7 +299,7 @@ namespace Slic3r {
PrintEstimatedTimeStatistics time_statistics; PrintEstimatedTimeStatistics time_statistics;
#if ENABLE_GCODE_VIEWER_STATISTICS #if ENABLE_GCODE_VIEWER_STATISTICS
long long time{ 0 }; int64_t time{ 0 };
void reset() void reset()
{ {
time = 0; time = 0;

3
src/libslic3r/SLAPrint.hpp
View file

@ -1,6 +1,7 @@
#ifndef slic3r_SLAPrint_hpp_ #ifndef slic3r_SLAPrint_hpp_
#define slic3r_SLAPrint_hpp_ #define slic3r_SLAPrint_hpp_
#include <cstdint>
#include <mutex> #include <mutex>
#include "PrintBase.hpp" #include "PrintBase.hpp"
#include "SLA/RasterBase.hpp" #include "SLA/RasterBase.hpp"
@ -37,7 +38,7 @@ using _SLAPrintObjectBase =
// Layers according to quantized height levels. This will be consumed by // Layers according to quantized height levels. This will be consumed by
// the printer (rasterizer) in the SLAPrint class. // the printer (rasterizer) in the SLAPrint class.
// using coord_t = long long; // using coord_t = int64_t;
enum SliceOrigin { soSupport, soModel }; enum SliceOrigin { soSupport, soModel };

22
src/slic3r/GUI/GCodeViewer.cpp
View file

@ -1011,11 +1011,11 @@ void GCodeViewer::load_toolpaths(const GCodeProcessor::Result& gcode_result)
m_max_bounding_box.merge(m_paths_bounding_box.max + m_sequential_view.marker.get_bounding_box().size()[2] * Vec3d::UnitZ()); m_max_bounding_box.merge(m_paths_bounding_box.max + m_sequential_view.marker.get_bounding_box().size()[2] * Vec3d::UnitZ());
auto log_memory_usage = [this](const std::string& label, const std::vector<std::vector<float>>& vertices, const std::vector<MultiIndexBuffer>& indices) { auto log_memory_usage = [this](const std::string& label, const std::vector<std::vector<float>>& vertices, const std::vector<MultiIndexBuffer>& indices) {
long long vertices_size = 0; int64_t vertices_size = 0;
for (size_t i = 0; i < vertices.size(); ++i) { for (size_t i = 0; i < vertices.size(); ++i) {
vertices_size += SLIC3R_STDVEC_MEMSIZE(vertices[i], float); vertices_size += SLIC3R_STDVEC_MEMSIZE(vertices[i], float);
} }
long long indices_size = 0; int64_t indices_size = 0;
for (size_t i = 0; i < indices.size(); ++i) { for (size_t i = 0; i < indices.size(); ++i) {
for (size_t j = 0; j < indices[i].size(); ++j) { for (size_t j = 0; j < indices[i].size(); ++j) {
indices_size += SLIC3R_STDVEC_MEMSIZE(indices[i][j], unsigned int); indices_size += SLIC3R_STDVEC_MEMSIZE(indices[i][j], unsigned int);
@ -1432,7 +1432,7 @@ void GCodeViewer::load_toolpaths(const GCodeProcessor::Result& gcode_result)
buffer.vertices.count = buffer_vertices.size() / buffer.vertices.vertex_size_floats(); buffer.vertices.count = buffer_vertices.size() / buffer.vertices.vertex_size_floats();
#if ENABLE_GCODE_VIEWER_STATISTICS #if ENABLE_GCODE_VIEWER_STATISTICS
m_statistics.vertices_gpu_size += buffer_vertices.size() * sizeof(float); m_statistics.vertices_gpu_size += buffer_vertices.size() * sizeof(float);
m_statistics.max_vertices_in_vertex_buffer = std::max(m_statistics.max_vertices_in_vertex_buffer, static_cast<long long>(buffer.vertices.count)); m_statistics.max_vertices_in_vertex_buffer = std::max(m_statistics.max_vertices_in_vertex_buffer, static_cast<int64_t>(buffer.vertices.count));
#endif // ENABLE_GCODE_VIEWER_STATISTICS #endif // ENABLE_GCODE_VIEWER_STATISTICS
glsafe(::glGenBuffers(1, &buffer.vertices.id)); glsafe(::glGenBuffers(1, &buffer.vertices.id));
@ -1538,7 +1538,7 @@ void GCodeViewer::load_toolpaths(const GCodeProcessor::Result& gcode_result)
ibuffer.count = buffer_indices.size(); ibuffer.count = buffer_indices.size();
#if ENABLE_GCODE_VIEWER_STATISTICS #if ENABLE_GCODE_VIEWER_STATISTICS
m_statistics.indices_gpu_size += ibuffer.count * sizeof(unsigned int); m_statistics.indices_gpu_size += ibuffer.count * sizeof(unsigned int);
m_statistics.max_indices_in_index_buffer = std::max(m_statistics.max_indices_in_index_buffer, static_cast<long long>(ibuffer.count)); m_statistics.max_indices_in_index_buffer = std::max(m_statistics.max_indices_in_index_buffer, static_cast<int64_t>(ibuffer.count));
#endif // ENABLE_GCODE_VIEWER_STATISTICS #endif // ENABLE_GCODE_VIEWER_STATISTICS
if (ibuffer.count > 0) { if (ibuffer.count > 0) {
@ -2803,7 +2803,7 @@ void GCodeViewer::render_statistics() const
ImGuiWrapper& imgui = *wxGetApp().imgui(); ImGuiWrapper& imgui = *wxGetApp().imgui();
auto add_time = [this, &imgui](const std::string& label, long long time) { auto add_time = [this, &imgui](const std::string& label, int64_t time) {
char buf[1024]; char buf[1024];
sprintf(buf, "%lld ms (%s)", time, get_time_dhms(static_cast<float>(time) * 0.001f).c_str()); sprintf(buf, "%lld ms (%s)", time, get_time_dhms(static_cast<float>(time) * 0.001f).c_str());
imgui.text_colored(ImGuiWrapper::COL_ORANGE_LIGHT, label); imgui.text_colored(ImGuiWrapper::COL_ORANGE_LIGHT, label);
@ -2811,7 +2811,7 @@ void GCodeViewer::render_statistics() const
imgui.text(buf); imgui.text(buf);
}; };
auto add_memory = [this, &imgui](const std::string& label, long long memory) { auto add_memory = [this, &imgui](const std::string& label, int64_t memory) {
static const float mb = 1024.0f * 1024.0f; static const float mb = 1024.0f * 1024.0f;
static const float inv_mb = 1.0f / mb; static const float inv_mb = 1.0f / mb;
static const float gb = 1024.0f * mb; static const float gb = 1024.0f * mb;
@ -2826,7 +2826,7 @@ void GCodeViewer::render_statistics() const
imgui.text(buf); imgui.text(buf);
}; };
auto add_counter = [this, &imgui](const std::string& label, long long counter) { auto add_counter = [this, &imgui](const std::string& label, int64_t counter) {
char buf[1024]; char buf[1024];
sprintf(buf, "%lld", counter); sprintf(buf, "%lld", counter);
imgui.text_colored(ImGuiWrapper::COL_ORANGE_LIGHT, label); imgui.text_colored(ImGuiWrapper::COL_ORANGE_LIGHT, label);
@ -2890,11 +2890,11 @@ void GCodeViewer::render_statistics() const
} }
#endif // ENABLE_GCODE_VIEWER_STATISTICS #endif // ENABLE_GCODE_VIEWER_STATISTICS
void GCodeViewer::log_memory_used(const std::string& label, long long additional) const void GCodeViewer::log_memory_used(const std::string& label, int64_t additional) const
{ {
if (Slic3r::get_logging_level() >= 5) { if (Slic3r::get_logging_level() >= 5) {
long long paths_size = 0; int64_t paths_size = 0;
long long render_paths_size = 0; int64_t render_paths_size = 0;
for (const TBuffer& buffer : m_buffers) { for (const TBuffer& buffer : m_buffers) {
paths_size += SLIC3R_STDVEC_MEMSIZE(buffer.paths, Path); paths_size += SLIC3R_STDVEC_MEMSIZE(buffer.paths, Path);
render_paths_size += SLIC3R_STDVEC_MEMSIZE(buffer.render_paths, RenderPath); render_paths_size += SLIC3R_STDVEC_MEMSIZE(buffer.render_paths, RenderPath);
@ -2903,7 +2903,7 @@ void GCodeViewer::log_memory_used(const std::string& label, long long additional
render_paths_size += SLIC3R_STDVEC_MEMSIZE(path.offsets, size_t); render_paths_size += SLIC3R_STDVEC_MEMSIZE(path.offsets, size_t);
} }
} }
long long layers_size = SLIC3R_STDVEC_MEMSIZE(m_layers.get_zs(), double); int64_t layers_size = SLIC3R_STDVEC_MEMSIZE(m_layers.get_zs(), double);
layers_size += SLIC3R_STDVEC_MEMSIZE(m_layers.get_endpoints(), Layers::Endpoints); layers_size += SLIC3R_STDVEC_MEMSIZE(m_layers.get_endpoints(), Layers::Endpoints);
BOOST_LOG_TRIVIAL(trace) << label BOOST_LOG_TRIVIAL(trace) << label
<< format_memsize_MB(additional + paths_size + render_paths_size + layers_size) << format_memsize_MB(additional + paths_size + render_paths_size + layers_size)

37
src/slic3r/GUI/GCodeViewer.hpp
View file

@ -5,6 +5,7 @@
#include "libslic3r/GCode/GCodeProcessor.hpp" #include "libslic3r/GCode/GCodeProcessor.hpp"
#include "GLModel.hpp" #include "GLModel.hpp"
#include <cstdint>
#include <float.h> #include <float.h>
namespace Slic3r { namespace Slic3r {
@ -311,26 +312,26 @@ class GCodeViewer
struct Statistics struct Statistics
{ {
// time // time
long long results_time{ 0 }; int64_t results_time{ 0 };
long long load_time{ 0 }; int64_t load_time{ 0 };
long long refresh_time{ 0 }; int64_t refresh_time{ 0 };
long long refresh_paths_time{ 0 }; int64_t refresh_paths_time{ 0 };
// opengl calls // opengl calls
long long gl_multi_points_calls_count{ 0 }; int64_t gl_multi_points_calls_count{ 0 };
long long gl_multi_lines_calls_count{ 0 }; int64_t gl_multi_lines_calls_count{ 0 };
long long gl_multi_triangles_calls_count{ 0 }; int64_t gl_multi_triangles_calls_count{ 0 };
// memory // memory
long long results_size{ 0 }; int64_t results_size{ 0 };
long long vertices_gpu_size{ 0 }; int64_t vertices_gpu_size{ 0 };
long long indices_gpu_size{ 0 }; int64_t indices_gpu_size{ 0 };
long long paths_size{ 0 }; int64_t paths_size{ 0 };
long long render_paths_size{ 0 }; int64_t render_paths_size{ 0 };
// other // other
long long travel_segments_count{ 0 }; int64_t travel_segments_count{ 0 };
long long wipe_segments_count{ 0 }; int64_t wipe_segments_count{ 0 };
long long extrude_segments_count{ 0 }; int64_t extrude_segments_count{ 0 };
long long max_vertices_in_vertex_buffer{ 0 }; int64_t max_vertices_in_vertex_buffer{ 0 };
long long max_indices_in_index_buffer{ 0 }; int64_t max_indices_in_index_buffer{ 0 };
void reset_all() { void reset_all() {
reset_times(); reset_times();
@ -509,7 +510,7 @@ private:
return role < erCount && (m_extrusions.role_visibility_flags & (1 << role)) != 0; return role < erCount && (m_extrusions.role_visibility_flags & (1 << role)) != 0;
} }
bool is_visible(const Path& path) const { return is_visible(path.role); } bool is_visible(const Path& path) const { return is_visible(path.role); }
void log_memory_used(const std::string& label, long long additional = 0) const; void log_memory_used(const std::string& label, int64_t additional = 0) const;
}; };
} // namespace GUI } // namespace GUI

2
src/slic3r/GUI/GLCanvas3D.cpp
View file

@ -1681,7 +1681,7 @@ void GLCanvas3D::render()
imgui.begin(std::string("Render statistics"), ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse); imgui.begin(std::string("Render statistics"), ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse);
imgui.text("Last frame:"); imgui.text("Last frame:");
ImGui::SameLine(); ImGui::SameLine();
long long average = m_render_stats.get_average(); int64_t average = m_render_stats.get_average();
imgui.text(std::to_string(average)); imgui.text(std::to_string(average));
ImGui::SameLine(); ImGui::SameLine();
imgui.text("ms"); imgui.text("ms");

11
src/slic3r/GUI/GLCanvas3D.hpp
View file

@ -4,6 +4,7 @@
#include <stddef.h> #include <stddef.h>
#include <memory> #include <memory>
#include <chrono> #include <chrono>
#include <cstdint>
#include "GLToolbar.hpp" #include "GLToolbar.hpp"
#include "Event.hpp" #include "Event.hpp"
@ -322,12 +323,12 @@ class GLCanvas3D
#if ENABLE_RENDER_STATISTICS #if ENABLE_RENDER_STATISTICS
class RenderStats class RenderStats
{ {
std::queue<std::pair<long long, long long>> m_frames; std::queue<std::pair<int64_t, int64_t>> m_frames;
long long m_curr_total{ 0 }; int64_t m_curr_total{ 0 };
public: public:
void add_frame(long long frame) { void add_frame(int64_t frame) {
long long now = wxGetLocalTimeMillis().GetValue(); int64_t now = wxGetLocalTimeMillis().GetValue();
if (!m_frames.empty() && now - m_frames.front().first > 1000) { if (!m_frames.empty() && now - m_frames.front().first > 1000) {
m_curr_total -= m_frames.front().second; m_curr_total -= m_frames.front().second;
m_frames.pop(); m_frames.pop();
@ -335,7 +336,7 @@ class GLCanvas3D
m_curr_total += frame; m_curr_total += frame;
m_frames.push({ now, frame }); m_frames.push({ now, frame });
} }
long long get_average() const { return m_frames.empty() ? 0 : m_curr_total / m_frames.size(); } int64_t get_average() const { return m_frames.empty() ? 0 : m_curr_total / m_frames.size(); }
}; };
#endif // ENABLE_RENDER_STATISTICS #endif // ENABLE_RENDER_STATISTICS

7
src/slic3r/GUI/InstanceCheck.cpp
View file

@ -17,6 +17,7 @@
#include <fcntl.h> #include <fcntl.h>
#include <errno.h> #include <errno.h>
#include <optional> #include <optional>
#include <cstdint>
#ifdef _WIN32 #ifdef _WIN32
#include <strsafe.h> #include <strsafe.h>
@ -83,9 +84,9 @@ namespace instance_check_internal
//check if other instances has same instance hash //check if other instances has same instance hash
//if not it is not same version(binary) as this version //if not it is not same version(binary) as this version
HANDLE handle = GetProp(hwnd, L"Instance_Hash_Minor"); HANDLE handle = GetProp(hwnd, L"Instance_Hash_Minor");
unsigned long long other_instance_hash = PtrToUint(handle); uint64_t other_instance_hash = PtrToUint(handle);
unsigned long long other_instance_hash_major; uint64_t other_instance_hash_major;
unsigned long long my_instance_hash = GUI::wxGetApp().get_instance_hash_int(); uint64_t my_instance_hash = GUI::wxGetApp().get_instance_hash_int();
handle = GetProp(hwnd, L"Instance_Hash_Major"); handle = GetProp(hwnd, L"Instance_Hash_Major");
other_instance_hash_major = PtrToUint(handle); other_instance_hash_major = PtrToUint(handle);
other_instance_hash_major = other_instance_hash_major << 32; other_instance_hash_major = other_instance_hash_major << 32;

5
tests/libnest2d/libnest2d_tests_main.cpp
View file

@ -1,6 +1,7 @@
#include <catch_main.hpp> #include <catch_main.hpp>
#include <fstream> #include <fstream>
#include <cstdint>
#include <libnest2d/libnest2d.hpp> #include <libnest2d/libnest2d.hpp>
#include "printer_parts.hpp" #include "printer_parts.hpp"
@ -472,7 +473,7 @@ TEST_CASE("ArrangeRectanglesLoose", "[Nesting]")
namespace { namespace {
using namespace libnest2d; using namespace libnest2d;
template<long long SCALE = 1, class It> template<int64_t SCALE = 1, class It>
void exportSVG(const char *loc, It from, It to) { void exportSVG(const char *loc, It from, It to) {
static const char* svg_header = static const char* svg_header =
@ -512,7 +513,7 @@ R"raw(<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
// } // }
} }
template<long long SCALE = 1> template<int64_t SCALE = 1>
void exportSVG(std::vector<std::reference_wrapper<Item>>& result, int idx = 0) { void exportSVG(std::vector<std::reference_wrapper<Item>>& result, int idx = 0) {
exportSVG((std::string("out") + std::to_string(idx) + ".svg").c_str(), exportSVG((std::string("out") + std::to_string(idx) + ".svg").c_str(),
result.begin(), result.end()); result.begin(), result.end());

5
tests/sla_print/sla_print_tests.cpp
View file

@ -1,6 +1,7 @@
#include <unordered_set> #include <unordered_set>
#include <unordered_map> #include <unordered_map>
#include <random> #include <random>
#include <cstdint>
#include "sla_test_utils.hpp" #include "sla_test_utils.hpp"
@ -63,7 +64,7 @@ TEST_CASE("Support point generator should be deterministic if seeded",
point_gen.execute(slices, slicegrid); point_gen.execute(slices, slicegrid);
auto get_chksum = [](const std::vector<sla::SupportPoint> &pts){ auto get_chksum = [](const std::vector<sla::SupportPoint> &pts){
long long chksum = 0; int64_t chksum = 0;
for (auto &pt : pts) { for (auto &pt : pts) {
auto p = scaled(pt.pos); auto p = scaled(pt.pos);
chksum += p.x() + p.y() + p.z(); chksum += p.x() + p.y() + p.z();
@ -72,7 +73,7 @@ TEST_CASE("Support point generator should be deterministic if seeded",
return chksum; return chksum;
}; };
long long checksum = get_chksum(point_gen.output()); int64_t checksum = get_chksum(point_gen.output());
size_t ptnum = point_gen.output().size(); size_t ptnum = point_gen.output().size();
REQUIRE(point_gen.output().size() > 0); REQUIRE(point_gen.output().size() > 0);