diff --git a/SofaGLFW/CMakeLists.txt b/SofaGLFW/CMakeLists.txt index a8368a7458..b4689b6cbc 100644 --- a/SofaGLFW/CMakeLists.txt +++ b/SofaGLFW/CMakeLists.txt @@ -16,7 +16,7 @@ if( UNIX AND NOT APPLE ) endif () endif () -sofa_find_package(glfw3 3.4 CONFIG QUIET) +#sofa_find_package(glfw3 3.4 CONFIG QUIET) if(TARGET glfw) if(CMAKE_SYSTEM_NAME STREQUAL Windows) @@ -45,19 +45,25 @@ set(SOFAGLFW_SOURCE_DIR src/SofaGLFW) set(HEADER_FILES ${SOFAGLFW_SOURCE_DIR}/config.h.in ${SOFAGLFW_SOURCE_DIR}/init.h + ${SOFAGLFW_SOURCE_DIR}/CaptureSnapshotDrawTool.h ${SOFAGLFW_SOURCE_DIR}/SofaGLFWWindow.h ${SOFAGLFW_SOURCE_DIR}/SofaGLFWBaseGUI.h ${SOFAGLFW_SOURCE_DIR}/BaseGUIEngine.h ${SOFAGLFW_SOURCE_DIR}/NullGUIEngine.h + ${SOFAGLFW_SOURCE_DIR}/SimulationLoop.h ${SOFAGLFW_SOURCE_DIR}/SofaGLFWMouseManager.h + ${SOFAGLFW_SOURCE_DIR}/SceneSnapshot.h ) set(SOURCE_FILES ${SOFAGLFW_SOURCE_DIR}/initSofaGLFW.cpp + ${SOFAGLFW_SOURCE_DIR}/SimulationLoop.cpp ${SOFAGLFW_SOURCE_DIR}/SofaGLFWWindow.cpp ${SOFAGLFW_SOURCE_DIR}/NullGUIEngine.cpp ${SOFAGLFW_SOURCE_DIR}/SofaGLFWBaseGUI.cpp ${SOFAGLFW_SOURCE_DIR}/SofaGLFWMouseManager.cpp + ${SOFAGLFW_SOURCE_DIR}/SceneSnapshot.cpp + ${SOFAGLFW_SOURCE_DIR}/CaptureSnapshotDrawTool.cpp ) if(Sofa.GUI.Common_FOUND) diff --git a/SofaGLFW/src/SofaGLFW/CaptureSnapshotDrawTool.cpp b/SofaGLFW/src/SofaGLFW/CaptureSnapshotDrawTool.cpp new file mode 100644 index 0000000000..374fc24119 --- /dev/null +++ b/SofaGLFW/src/SofaGLFW/CaptureSnapshotDrawTool.cpp @@ -0,0 +1,1299 @@ +#include + +namespace sofaglfw +{ + +CaptureSnapshotDrawTool::CaptureSnapshotDrawTool(std::shared_ptr& sceneSnapshot) + : m_sceneSnapshot(sceneSnapshot) +{ +} + +void CaptureSnapshotDrawTool::drawPoints(const std::vector& points, float size, + const RGBAColor& color) +{ + struct DrawPoints : public DrawToolSnapshot + { + std::vector m_points; + float m_size; + RGBAColor m_color; + + DrawPoints(const std::vector& points, float size, const RGBAColor& color) + : m_points(points), m_size(size), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawPoints(m_points, m_size, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawPoints(points, size, color)); +} + + +void CaptureSnapshotDrawTool::drawPoints(const std::vector& points, float size, + const std::vector& color) +{ + struct DrawPoints : public DrawToolSnapshot + { + std::vector m_points; + float m_size; + std::vector m_color; + + DrawPoints(const std::vector& points, float size, const std::vector& color) + : m_points(points), m_size(size), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawPoints(m_points, m_size, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawPoints(points, size, color)); +} + +void CaptureSnapshotDrawTool::drawLine(const Vec3& p1, const Vec3& p2, const RGBAColor& color) +{ + struct DrawLine : public DrawToolSnapshot + { + Vec3 m_p1, m_p2; + RGBAColor m_color; + + DrawLine(const Vec3& p1, const Vec3& p2, const RGBAColor& color) + : m_p1(p1), m_p2(p2), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawLine(m_p1, m_p2, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawLine(p1, p2, color)); +} + +void CaptureSnapshotDrawTool::drawInfiniteLine(const Vec3& point, const Vec3& direction, + const RGBAColor& color, const bool& vanishing) +{ + struct DrawInfiniteLine : public DrawToolSnapshot + { + Vec3 m_point, m_direction; + RGBAColor m_color; + bool m_vanishing; + + DrawInfiniteLine(const Vec3& point, const Vec3& direction, const RGBAColor& color, bool vanishing) + : m_point(point), m_direction(direction), m_color(color), m_vanishing(vanishing) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawInfiniteLine(m_point, m_direction, m_color, m_vanishing); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawInfiniteLine(point, direction, color, vanishing)); +} + +void CaptureSnapshotDrawTool::drawInfiniteLine(const Vec3& point, const Vec3& direction, + const float& size, const RGBAColor& color, + const bool& vanishing) +{ + struct DrawInfiniteLineSized : public DrawToolSnapshot + { + Vec3 m_point, m_direction; + float m_size; + RGBAColor m_color; + bool m_vanishing; + + DrawInfiniteLineSized(const Vec3& point, const Vec3& direction, float size, const RGBAColor& color, bool vanishing) + : m_point(point), m_direction(direction), m_size(size), m_color(color), m_vanishing(vanishing) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawInfiniteLine(m_point, m_direction, m_size, m_color, m_vanishing); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawInfiniteLineSized(point, direction, size, color, vanishing)); +} + +void CaptureSnapshotDrawTool::drawLines(const std::vector& points, float size, + const RGBAColor& color) +{ + struct DrawLines : public DrawToolSnapshot + { + std::vector m_points; + float m_size; + RGBAColor m_color; + + DrawLines(const std::vector& points, float size, const RGBAColor& color) + : m_points(points), m_size(size), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawLines(m_points, m_size, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawLines(points, size, color)); +} + +void CaptureSnapshotDrawTool::drawLines(const std::vector& points, float size, + const std::vector& colors) +{ + struct DrawLinesCol : public DrawToolSnapshot + { + std::vector m_points; + float m_size; + std::vector m_colors; + + DrawLinesCol(const std::vector& points, float size, const std::vector& colors) + : m_points(points), m_size(size), m_colors(colors) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawLines(m_points, m_size, m_colors); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawLinesCol(points, size, colors)); +} + +void CaptureSnapshotDrawTool::drawLines(const std::vector& points, + const std::vector& index, float size, + const RGBAColor& color) +{ + struct DrawLinesIndexed : public DrawToolSnapshot + { + std::vector m_points; + std::vector m_index; + float m_size; + RGBAColor m_color; + + DrawLinesIndexed(const std::vector& points, const std::vector& index, float size, const RGBAColor& color) + : m_points(points), m_index(index), m_size(size), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawLines(m_points, m_index, m_size, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawLinesIndexed(points, index, size, color)); +} + +void CaptureSnapshotDrawTool::drawLineStrip(const std::vector& points, float size, + const RGBAColor& color) +{ + struct DrawLineStrip : public DrawToolSnapshot + { + std::vector m_points; + float m_size; + RGBAColor m_color; + + DrawLineStrip(const std::vector& points, float size, const RGBAColor& color) + : m_points(points), m_size(size), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawLineStrip(m_points, m_size, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawLineStrip(points, size, color)); +} +void CaptureSnapshotDrawTool::drawLineStrip(const std::vector& points, float size, + const std::vector& colors) +{ + struct DrawLineStrip : public DrawToolSnapshot + { + std::vector m_points; + float m_size; + std::vector m_colors; + + DrawLineStrip(const std::vector& points, float size, const std::vector& colors) + : m_points(points), m_size(size), m_colors(colors) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawLineStrip(m_points, m_size, m_colors); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawLineStrip(points, size, colors)); +} + +void CaptureSnapshotDrawTool::drawLineLoop(const std::vector& points, float size, + const RGBAColor& color) +{ + struct DrawLineLoop : public DrawToolSnapshot + { + std::vector m_points; + float m_size; + RGBAColor m_color; + + DrawLineLoop(const std::vector& points, float size, const RGBAColor& color) + : m_points(points), m_size(size), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawLineLoop(m_points, m_size, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawLineLoop(points, size, color)); +} + +void CaptureSnapshotDrawTool::drawDisk(float radius, double from, double to, int resolution, + const RGBAColor& color) +{ + struct DrawDisk : public DrawToolSnapshot + { + float m_radius; + double m_from, m_to; + int m_resolution; + RGBAColor m_color; + + DrawDisk(float radius, double from, double to, int resolution, const RGBAColor& color) + : m_radius(radius), m_from(from), m_to(to), m_resolution(resolution), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawDisk(m_radius, m_from, m_to, m_resolution, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawDisk(radius, from, to, resolution, color)); +} + +void CaptureSnapshotDrawTool::drawCircle(float radius, float lineThickness, int resolution, + const RGBAColor& color) +{ + struct DrawCircle : public DrawToolSnapshot + { + float m_radius, m_lineThickness; + int m_resolution; + RGBAColor m_color; + + DrawCircle(float radius, float lineThickness, int resolution, const RGBAColor& color) + : m_radius(radius), m_lineThickness(lineThickness), m_resolution(resolution), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawCircle(m_radius, m_lineThickness, m_resolution, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawCircle(radius, lineThickness, resolution, color)); +} + +void CaptureSnapshotDrawTool::drawTriangles(const std::vector& points, const RGBAColor& color) +{ + struct DrawTriangles : public DrawToolSnapshot + { + std::vector m_points; + RGBAColor m_color; + + DrawTriangles(const std::vector& points, const RGBAColor& color) + : m_points(points), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawTriangles(m_points, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawTriangles(points, color)); +} + +void CaptureSnapshotDrawTool::drawTriangles(const std::vector& points, const Vec3& normal, + const RGBAColor& color) +{ + struct DrawTrianglesNorm : public DrawToolSnapshot + { + std::vector m_points; + Vec3 m_normal; + RGBAColor m_color; + + DrawTrianglesNorm(const std::vector& points, const Vec3& normal, const RGBAColor& color) + : m_points(points), m_normal(normal), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawTriangles(m_points, m_normal, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawTrianglesNorm(points, normal, color)); +} + +void CaptureSnapshotDrawTool::drawTriangles(const std::vector& points, + const std::vector& index, + const std::vector& normal, const RGBAColor& color) +{ + struct DrawTrianglesIndexed : public DrawToolSnapshot + { + std::vector m_points; + std::vector m_index; + std::vector m_normal; + RGBAColor m_color; + + DrawTrianglesIndexed(const std::vector& points, const std::vector& index, + const std::vector& normal, const RGBAColor& color) + : m_points(points), m_index(index), m_normal(normal), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawTriangles(m_points, m_index, m_normal, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawTrianglesIndexed(points, index, normal, color)); +} + +void CaptureSnapshotDrawTool::drawTriangles(const std::vector& points, + const std::vector& index, + const std::vector& normal, + const std::vector& color) +{ + struct DrawTrianglesIndexedCol : public DrawToolSnapshot + { + std::vector m_points; + std::vector m_index; + std::vector m_normal; + std::vector m_color; + + DrawTrianglesIndexedCol(const std::vector& points, const std::vector& index, + const std::vector& normal, const std::vector& color) + : m_points(points), m_index(index), m_normal(normal), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawTriangles(m_points, m_index, m_normal, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawTrianglesIndexedCol(points, index, normal, color)); +} + +void CaptureSnapshotDrawTool::drawTriangles(const std::vector& points, + const std::vector& color) +{ + struct DrawTrianglesCol : public DrawToolSnapshot + { + std::vector m_points; + std::vector m_color; + + DrawTrianglesCol(const std::vector& points, const std::vector& color) + : m_points(points), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawTriangles(m_points, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawTrianglesCol(points, color)); +} + +void CaptureSnapshotDrawTool::drawTriangles(const std::vector& points, + const std::vector& normal, + const std::vector& color) +{ + struct DrawTrianglesNormCol : public DrawToolSnapshot + { + std::vector m_points; + std::vector m_normal; + std::vector m_color; + + DrawTrianglesNormCol(const std::vector& points, const std::vector& normal, + const std::vector& color) + : m_points(points), m_normal(normal), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawTriangles(m_points, m_normal, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawTrianglesNormCol(points, normal, color)); +} + +void CaptureSnapshotDrawTool::drawTriangleStrip(const std::vector& points, + const std::vector& normal, + const RGBAColor& color) +{ + struct DrawTriangleStrip : public DrawToolSnapshot + { + std::vector m_points; + std::vector m_normal; + RGBAColor m_color; + + DrawTriangleStrip(const std::vector& points, const std::vector& normal, const RGBAColor& color) + : m_points(points), m_normal(normal), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawTriangleStrip(m_points, m_normal, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawTriangleStrip(points, normal, color)); +} + +void CaptureSnapshotDrawTool::drawTriangleFan(const std::vector& points, + const std::vector& normal, + const RGBAColor& color) +{ + struct DrawTriangleFan : public DrawToolSnapshot + { + std::vector m_points; + std::vector m_normal; + RGBAColor m_color; + + DrawTriangleFan(const std::vector& points, const std::vector& normal, const RGBAColor& color) + : m_points(points), m_normal(normal), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawTriangleFan(m_points, m_normal, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawTriangleFan(points, normal, color)); +} + +void CaptureSnapshotDrawTool::drawFrame(const Vec3& position, const Quaternion& orientation, + const Vec3f& size) +{ + struct DrawFrame : public DrawToolSnapshot + { + Vec3 m_position; + Quaternion m_orientation; + Vec3f m_size; + + DrawFrame(const Vec3& position, const Quaternion& orientation, const Vec3f& size) + : m_position(position), m_orientation(orientation), m_size(size) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawFrame(m_position, m_orientation, m_size); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawFrame(position, orientation, size)); +} + +void CaptureSnapshotDrawTool::drawFrame(const Vec3& position, const Quaternion& orientation, + const Vec3f& size, const RGBAColor& color) +{ + struct DrawFrameCol : public DrawToolSnapshot + { + Vec3 m_position; + Quaternion m_orientation; + Vec3f m_size; + RGBAColor m_color; + + DrawFrameCol(const Vec3& position, const Quaternion& orientation, const Vec3f& size, const RGBAColor& color) + : m_position(position), m_orientation(orientation), m_size(size), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawFrame(m_position, m_orientation, m_size, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawFrameCol(position, orientation, size, color)); +} + +void CaptureSnapshotDrawTool::drawSpheres(const std::vector& points, + const std::vector& radius, const RGBAColor& color) +{ + struct DrawSpheres : public DrawToolSnapshot + { + std::vector m_points; + std::vector m_radius; + RGBAColor m_color; + + DrawSpheres(const std::vector& points, const std::vector& radius, const RGBAColor& color) + : m_points(points), m_radius(radius), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawSpheres(m_points, m_radius, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawSpheres(points, radius, color)); +} + +void CaptureSnapshotDrawTool::drawSpheres(const std::vector& points, float radius, + const RGBAColor& color) +{ + struct DrawSpheresUniform : public DrawToolSnapshot + { + std::vector m_points; + float m_radius; + RGBAColor m_color; + + DrawSpheresUniform(const std::vector& points, float radius, const RGBAColor& color) + : m_points(points), m_radius(radius), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawSpheres(m_points, m_radius, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawSpheresUniform(points, radius, color)); +} + +void CaptureSnapshotDrawTool::drawFakeSpheres(const std::vector& points, + const std::vector& radius, + const RGBAColor& color) +{ + struct DrawFakeSpheres : public DrawToolSnapshot + { + std::vector m_points; + std::vector m_radius; + RGBAColor m_color; + + DrawFakeSpheres(const std::vector& points, const std::vector& radius, const RGBAColor& color) + : m_points(points), m_radius(radius), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawFakeSpheres(m_points, m_radius, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawFakeSpheres(points, radius, color)); +} + +void CaptureSnapshotDrawTool::drawFakeSpheres(const std::vector& points, float radius, + const RGBAColor& color) +{ + struct DrawFakeSpheresUniform : public DrawToolSnapshot + { + std::vector m_points; + float m_radius; + RGBAColor m_color; + + DrawFakeSpheresUniform(const std::vector& points, float radius, const RGBAColor& color) + : m_points(points), m_radius(radius), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawFakeSpheres(m_points, m_radius, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawFakeSpheresUniform(points, radius, color)); +} + +void CaptureSnapshotDrawTool::drawCone(const Vec3& p1, const Vec3& p2, float radius1, float radius2, + const RGBAColor& color, int subd) +{ + struct DrawCone : public DrawToolSnapshot + { + Vec3 m_p1, m_p2; + float m_radius1, m_radius2; + RGBAColor m_color; + int m_subd; + + DrawCone(const Vec3& p1, const Vec3& p2, float radius1, float radius2, const RGBAColor& color, int subd) + : m_p1(p1), m_p2(p2), m_radius1(radius1), m_radius2(radius2), m_color(color), m_subd(subd) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawCone(m_p1, m_p2, m_radius1, m_radius2, m_color, m_subd); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawCone(p1, p2, radius1, radius2, color, subd)); +} + +void CaptureSnapshotDrawTool::drawCube(const float& radius, const RGBAColor& color, const int& subd) +{ + struct DrawCube : public DrawToolSnapshot + { + float m_radius; + RGBAColor m_color; + int m_subd; + + DrawCube(float radius, const RGBAColor& color, int subd) + : m_radius(radius), m_color(color), m_subd(subd) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawCube(m_radius, m_color, m_subd); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawCube(radius, color, subd)); +} + +void CaptureSnapshotDrawTool::drawCylinder(const Vec3& p1, const Vec3& p2, float radius, + const RGBAColor& color, int subd) +{ + struct DrawCylinder : public DrawToolSnapshot + { + Vec3 m_p1, m_p2; + float m_radius; + RGBAColor m_color; + int m_subd; + + DrawCylinder(const Vec3& p1, const Vec3& p2, float radius, const RGBAColor& color, int subd) + : m_p1(p1), m_p2(p2), m_radius(radius), m_color(color), m_subd(subd) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawCylinder(m_p1, m_p2, m_radius, m_color, m_subd); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawCylinder(p1, p2, radius, color, subd)); +} + +void CaptureSnapshotDrawTool::drawCapsule(const Vec3& p1, const Vec3& p2, float radius, + const RGBAColor& color, int subd) +{ + struct DrawCapsule : public DrawToolSnapshot + { + Vec3 m_p1, m_p2; + float m_radius; + RGBAColor m_color; + int m_subd; + + DrawCapsule(const Vec3& p1, const Vec3& p2, float radius, const RGBAColor& color, int subd) + : m_p1(p1), m_p2(p2), m_radius(radius), m_color(color), m_subd(subd) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawCapsule(m_p1, m_p2, m_radius, m_color, m_subd); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawCapsule(p1, p2, radius, color, subd)); +} + +void CaptureSnapshotDrawTool::drawArrow(const Vec3& p1, const Vec3& p2, float radius, + const RGBAColor& color, int subd) +{ + struct DrawArrow : public DrawToolSnapshot + { + Vec3 m_p1, m_p2; + float m_radius; + RGBAColor m_color; + int m_subd; + + DrawArrow(const Vec3& p1, const Vec3& p2, float radius, const RGBAColor& color, int subd) + : m_p1(p1), m_p2(p2), m_radius(radius), m_color(color), m_subd(subd) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawArrow(m_p1, m_p2, m_radius, m_color, m_subd); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawArrow(p1, p2, radius, color, subd)); +} + +void CaptureSnapshotDrawTool::drawArrow(const Vec3& p1, const Vec3& p2, float radius, + float coneLength, const RGBAColor& color, int subd) +{ + struct DrawArrowCL : public DrawToolSnapshot + { + Vec3 m_p1, m_p2; + float m_radius, m_coneLength; + RGBAColor m_color; + int m_subd; + + DrawArrowCL(const Vec3& p1, const Vec3& p2, float radius, float coneLength, const RGBAColor& color, int subd) + : m_p1(p1), m_p2(p2), m_radius(radius), m_coneLength(coneLength), m_color(color), m_subd(subd) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawArrow(m_p1, m_p2, m_radius, m_coneLength, m_color, m_subd); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawArrowCL(p1, p2, radius, coneLength, color, subd)); +} + +void CaptureSnapshotDrawTool::drawArrow(const Vec3& p1, const Vec3& p2, float radius, + float coneLength, float coneRadius, const RGBAColor& color, + int subd) +{ + struct DrawArrowCLR : public DrawToolSnapshot + { + Vec3 m_p1, m_p2; + float m_radius, m_coneLength, m_coneRadius; + RGBAColor m_color; + int m_subd; + + DrawArrowCLR(const Vec3& p1, const Vec3& p2, float radius, float coneLength, float coneRadius, const RGBAColor& color, int subd) + : m_p1(p1), m_p2(p2), m_radius(radius), m_coneLength(coneLength), m_coneRadius(coneRadius), m_color(color), m_subd(subd) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawArrow(m_p1, m_p2, m_radius, m_coneLength, m_coneRadius, m_color, m_subd); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawArrowCLR(p1, p2, radius, coneLength, coneRadius, color, subd)); +} + +void CaptureSnapshotDrawTool::drawCross(const Vec3& p, float length, const RGBAColor& color) +{ + struct DrawCross : public DrawToolSnapshot + { + Vec3 m_p; + float m_length; + RGBAColor m_color; + + DrawCross(const Vec3& p, float length, const RGBAColor& color) + : m_p(p), m_length(length), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawCross(m_p, m_length, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawCross(p, length, color)); +} + +void CaptureSnapshotDrawTool::drawPlus(const float& radius, const RGBAColor& color, const int& subd) +{ + struct DrawPlus : public DrawToolSnapshot + { + float m_radius; + RGBAColor m_color; + int m_subd; + + DrawPlus(float radius, const RGBAColor& color, int subd) + : m_radius(radius), m_color(color), m_subd(subd) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawPlus(m_radius, m_color, m_subd); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawPlus(radius, color, subd)); +} + +void CaptureSnapshotDrawTool::drawPoint(const Vec3& p, const RGBAColor& c) +{ + struct DrawPoint : public DrawToolSnapshot + { + Vec3 m_p; + RGBAColor m_c; + + DrawPoint(const Vec3& p, const RGBAColor& c) + : m_p(p), m_c(c) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawPoint(m_p, m_c); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawPoint(p, c)); +} + +void CaptureSnapshotDrawTool::drawPoint(const Vec3& p, const Vec3& n, const RGBAColor& c) +{ + struct DrawPointNorm : public DrawToolSnapshot + { + Vec3 m_p, m_n; + RGBAColor m_c; + + DrawPointNorm(const Vec3& p, const Vec3& n, const RGBAColor& c) + : m_p(p), m_n(n), m_c(c) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawPoint(m_p, m_n, m_c); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawPointNorm(p, n, c)); +} + +void CaptureSnapshotDrawTool::drawTriangle(const Vec3& p1, const Vec3& p2, const Vec3& p3, + const Vec3& normal) +{ + struct DrawTriangle : public DrawToolSnapshot + { + Vec3 m_p1, m_p2, m_p3, m_normal; + + DrawTriangle(const Vec3& p1, const Vec3& p2, const Vec3& p3, const Vec3& normal) + : m_p1(p1), m_p2(p2), m_p3(p3), m_normal(normal) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawTriangle(m_p1, m_p2, m_p3, m_normal); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawTriangle(p1, p2, p3, normal)); +} + +void CaptureSnapshotDrawTool::drawTriangle(const Vec3& p1, const Vec3& p2, const Vec3& p3, + const Vec3& normal, const RGBAColor& c) +{ + struct DrawTriangleCol : public DrawToolSnapshot + { + Vec3 m_p1, m_p2, m_p3, m_normal; + RGBAColor m_c; + + DrawTriangleCol(const Vec3& p1, const Vec3& p2, const Vec3& p3, const Vec3& normal, const RGBAColor& c) + : m_p1(p1), m_p2(p2), m_p3(p3), m_normal(normal), m_c(c) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawTriangle(m_p1, m_p2, m_p3, m_normal, m_c); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawTriangleCol(p1, p2, p3, normal, c)); +} + +void CaptureSnapshotDrawTool::drawTriangle(const Vec3& p1, const Vec3& p2, const Vec3& p3, + const Vec3& normal, const RGBAColor& c1, + const RGBAColor& c2, const RGBAColor& c3) +{ + struct DrawTriangleVCol : public DrawToolSnapshot + { + Vec3 m_p1, m_p2, m_p3, m_normal; + RGBAColor m_c1, m_c2, m_c3; + + DrawTriangleVCol(const Vec3& p1, const Vec3& p2, const Vec3& p3, const Vec3& normal, + const RGBAColor& c1, const RGBAColor& c2, const RGBAColor& c3) + : m_p1(p1), m_p2(p2), m_p3(p3), m_normal(normal), m_c1(c1), m_c2(c2), m_c3(c3) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawTriangle(m_p1, m_p2, m_p3, m_normal, m_c1, m_c2, m_c3); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawTriangleVCol(p1, p2, p3, normal, c1, c2, c3)); +} + +void CaptureSnapshotDrawTool::drawTriangle(const Vec3& p1, const Vec3& p2, const Vec3& p3, + const Vec3& normal1, const Vec3& normal2, + const Vec3& normal3, const RGBAColor& c1, + const RGBAColor& c2, const RGBAColor& c3) +{ + struct DrawTriangleVNormVCol : public DrawToolSnapshot + { + Vec3 m_p1, m_p2, m_p3, m_n1, m_n2, m_n3; + RGBAColor m_c1, m_c2, m_c3; + + DrawTriangleVNormVCol(const Vec3& p1, const Vec3& p2, const Vec3& p3, + const Vec3& normal1, const Vec3& normal2, const Vec3& normal3, + const RGBAColor& c1, const RGBAColor& c2, const RGBAColor& c3) + : m_p1(p1), m_p2(p2), m_p3(p3), m_n1(normal1), m_n2(normal2), m_n3(normal3), + m_c1(c1), m_c2(c2), m_c3(c3) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawTriangle(m_p1, m_p2, m_p3, m_n1, m_n2, m_n3, m_c1, m_c2, m_c3); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawTriangleVNormVCol(p1, p2, p3, normal1, normal2, normal3, c1, c2, c3)); +} + +void CaptureSnapshotDrawTool::drawQuad(const Vec3& p1, const Vec3& p2, const Vec3& p3, + const Vec3& p4, const Vec3& normal) +{ + struct DrawQuad : public DrawToolSnapshot + { + Vec3 m_p1, m_p2, m_p3, m_p4, m_normal; + + DrawQuad(const Vec3& p1, const Vec3& p2, const Vec3& p3, const Vec3& p4, const Vec3& normal) + : m_p1(p1), m_p2(p2), m_p3(p3), m_p4(p4), m_normal(normal) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawQuad(m_p1, m_p2, m_p3, m_p4, m_normal); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawQuad(p1, p2, p3, p4, normal)); +} + +void CaptureSnapshotDrawTool::drawQuad(const Vec3& p1, const Vec3& p2, const Vec3& p3, + const Vec3& p4, const Vec3& normal, const RGBAColor& c) +{ + struct DrawQuadCol : public DrawToolSnapshot + { + Vec3 m_p1, m_p2, m_p3, m_p4, m_normal; + RGBAColor m_c; + + DrawQuadCol(const Vec3& p1, const Vec3& p2, const Vec3& p3, const Vec3& p4, const Vec3& normal, const RGBAColor& c) + : m_p1(p1), m_p2(p2), m_p3(p3), m_p4(p4), m_normal(normal), m_c(c) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawQuad(m_p1, m_p2, m_p3, m_p4, m_normal, m_c); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawQuadCol(p1, p2, p3, p4, normal, c)); +} + +void CaptureSnapshotDrawTool::drawQuad(const Vec3& p1, const Vec3& p2, const Vec3& p3, + const Vec3& p4, const Vec3& normal, const RGBAColor& c1, + const RGBAColor& c2, const RGBAColor& c3, + const RGBAColor& c4) +{ + struct DrawQuadVCol : public DrawToolSnapshot + { + Vec3 m_p1, m_p2, m_p3, m_p4, m_normal; + RGBAColor m_c1, m_c2, m_c3, m_c4; + + DrawQuadVCol(const Vec3& p1, const Vec3& p2, const Vec3& p3, const Vec3& p4, const Vec3& normal, + const RGBAColor& c1, const RGBAColor& c2, const RGBAColor& c3, const RGBAColor& c4) + : m_p1(p1), m_p2(p2), m_p3(p3), m_p4(p4), m_normal(normal), m_c1(c1), m_c2(c2), m_c3(c3), m_c4(c4) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawQuad(m_p1, m_p2, m_p3, m_p4, m_normal, m_c1, m_c2, m_c3, m_c4); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawQuadVCol(p1, p2, p3, p4, normal, c1, c2, c3, c4)); +} + +void CaptureSnapshotDrawTool::drawQuad(const Vec3& p1, const Vec3& p2, const Vec3& p3, + const Vec3& p4, const Vec3& normal1, const Vec3& normal2, + const Vec3& normal3, const Vec3& normal4, + const RGBAColor& c1, const RGBAColor& c2, + const RGBAColor& c3, const RGBAColor& c4) +{ + struct DrawQuadVNormVCol : public DrawToolSnapshot + { + Vec3 m_p1, m_p2, m_p3, m_p4, m_n1, m_n2, m_n3, m_n4; + RGBAColor m_c1, m_c2, m_c3, m_c4; + + DrawQuadVNormVCol(const Vec3& p1, const Vec3& p2, const Vec3& p3, const Vec3& p4, + const Vec3& normal1, const Vec3& normal2, const Vec3& normal3, const Vec3& normal4, + const RGBAColor& c1, const RGBAColor& c2, const RGBAColor& c3, const RGBAColor& c4) + : m_p1(p1), m_p2(p2), m_p3(p3), m_p4(p4), m_n1(normal1), m_n2(normal2), m_n3(normal3), m_n4(normal4), + m_c1(c1), m_c2(c2), m_c3(c3), m_c4(c4) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawQuad(m_p1, m_p2, m_p3, m_p4, m_n1, m_n2, m_n3, m_n4, m_c1, m_c2, m_c3, m_c4); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawQuadVNormVCol(p1, p2, p3, p4, normal1, normal2, normal3, normal4, c1, c2, c3, c4)); +} + +void CaptureSnapshotDrawTool::drawQuads(const std::vector& points, const RGBAColor& color) +{ + struct DrawQuads : public DrawToolSnapshot + { + std::vector m_points; + RGBAColor m_color; + + DrawQuads(const std::vector& points, const RGBAColor& color) + : m_points(points), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawQuads(m_points, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawQuads(points, color)); +} + +void CaptureSnapshotDrawTool::drawQuads(const std::vector& points, + const std::vector& colors) +{ + struct DrawQuadsCol : public DrawToolSnapshot + { + std::vector m_points; + std::vector m_colors; + + DrawQuadsCol(const std::vector& points, const std::vector& colors) + : m_points(points), m_colors(colors) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawQuads(m_points, m_colors); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawQuadsCol(points, colors)); +} + +void CaptureSnapshotDrawTool::drawTetrahedron(const Vec3& p0, const Vec3& p1, const Vec3& p2, + const Vec3& p3, const RGBAColor& color) +{ + struct DrawTetrahedron : public DrawToolSnapshot + { + Vec3 m_p0, m_p1, m_p2, m_p3; + RGBAColor m_color; + + DrawTetrahedron(const Vec3& p0, const Vec3& p1, const Vec3& p2, const Vec3& p3, const RGBAColor& color) + : m_p0(p0), m_p1(p1), m_p2(p2), m_p3(p3), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawTetrahedron(m_p0, m_p1, m_p2, m_p3, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawTetrahedron(p0, p1, p2, p3, color)); +} + +void CaptureSnapshotDrawTool::drawScaledTetrahedron(const Vec3& p0, const Vec3& p1, const Vec3& p2, + const Vec3& p3, const RGBAColor& color, + const float scale) +{ + struct DrawScaledTetrahedron : public DrawToolSnapshot + { + Vec3 m_p0, m_p1, m_p2, m_p3; + RGBAColor m_color; + float m_scale; + + DrawScaledTetrahedron(const Vec3& p0, const Vec3& p1, const Vec3& p2, const Vec3& p3, const RGBAColor& color, float scale) + : m_p0(p0), m_p1(p1), m_p2(p2), m_p3(p3), m_color(color), m_scale(scale) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawScaledTetrahedron(m_p0, m_p1, m_p2, m_p3, m_color, m_scale); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawScaledTetrahedron(p0, p1, p2, p3, color, scale)); +} + +void CaptureSnapshotDrawTool::drawTetrahedra(const std::vector& points, + const RGBAColor& color) +{ + struct DrawTetrahedra : public DrawToolSnapshot + { + std::vector m_points; + RGBAColor m_color; + + DrawTetrahedra(const std::vector& points, const RGBAColor& color) + : m_points(points), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawTetrahedra(m_points, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawTetrahedra(points, color)); +} + +void CaptureSnapshotDrawTool::drawScaledTetrahedra(const std::vector& points, + const RGBAColor& color, const float scale) +{ + struct DrawScaledTetrahedra : public DrawToolSnapshot + { + std::vector m_points; + RGBAColor m_color; + float m_scale; + + DrawScaledTetrahedra(const std::vector& points, const RGBAColor& color, float scale) + : m_points(points), m_color(color), m_scale(scale) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawScaledTetrahedra(m_points, m_color, m_scale); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawScaledTetrahedra(points, color, scale)); +} + +void CaptureSnapshotDrawTool::drawHexahedron(const Vec3& p0, const Vec3& p1, const Vec3& p2, + const Vec3& p3, const Vec3& p4, const Vec3& p5, + const Vec3& p6, const Vec3& p7, const RGBAColor& color) +{ + struct DrawHexahedron : public DrawToolSnapshot + { + Vec3 m_p0, m_p1, m_p2, m_p3, m_p4, m_p5, m_p6, m_p7; + RGBAColor m_color; + + DrawHexahedron(const Vec3& p0, const Vec3& p1, const Vec3& p2, const Vec3& p3, + const Vec3& p4, const Vec3& p5, const Vec3& p6, const Vec3& p7, const RGBAColor& color) + : m_p0(p0), m_p1(p1), m_p2(p2), m_p3(p3), m_p4(p4), m_p5(p5), m_p6(p6), m_p7(p7), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawHexahedron(m_p0, m_p1, m_p2, m_p3, m_p4, m_p5, m_p6, m_p7, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawHexahedron(p0, p1, p2, p3, p4, p5, p6, p7, color)); +} + +void CaptureSnapshotDrawTool::drawHexahedra(const std::vector& points, const RGBAColor& color) +{ + struct DrawHexahedra : public DrawToolSnapshot + { + std::vector m_points; + RGBAColor m_color; + + DrawHexahedra(const std::vector& points, const RGBAColor& color) + : m_points(points), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawHexahedra(m_points, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawHexahedra(points, color)); +} + +void CaptureSnapshotDrawTool::drawScaledHexahedra(const std::vector& points, + const RGBAColor& color, const float scale) +{ + struct DrawScaledHexahedra : public DrawToolSnapshot + { + std::vector m_points; + RGBAColor m_color; + float m_scale; + + DrawScaledHexahedra(const std::vector& points, const RGBAColor& color, float scale) + : m_points(points), m_color(color), m_scale(scale) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawScaledHexahedra(m_points, m_color, m_scale); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawScaledHexahedra(points, color, scale)); +} + +void CaptureSnapshotDrawTool::drawSphere(const Vec3& p, float radius) +{ + struct DrawSphere : public DrawToolSnapshot + { + Vec3 m_p; + float m_radius; + + DrawSphere(const Vec3& p, float radius) + : m_p(p), m_radius(radius) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawSphere(m_p, m_radius); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawSphere(p, radius)); +} + +void CaptureSnapshotDrawTool::drawSphere(const Vec3& p, float radius, const RGBAColor& color) +{ + struct DrawSphereCol : public DrawToolSnapshot + { + Vec3 m_p; + float m_radius; + RGBAColor m_color; + + DrawSphereCol(const Vec3& p, float radius, const RGBAColor& color) + : m_p(p), m_radius(radius), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawSphere(m_p, m_radius, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawSphereCol(p, radius, color)); +} + +void CaptureSnapshotDrawTool::drawEllipsoid(const Vec3& p, const Vec3& radii) +{ + struct DrawEllipsoid : public DrawToolSnapshot + { + Vec3 m_p, m_radii; + + DrawEllipsoid(const Vec3& p, const Vec3& radii) + : m_p(p), m_radii(radii) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawEllipsoid(m_p, m_radii); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawEllipsoid(p, radii)); +} + +void CaptureSnapshotDrawTool::drawBoundingBox(const Vec3& min, const Vec3& max, float size) +{ + struct DrawBoundingBox : public DrawToolSnapshot + { + Vec3 m_min, m_max; + float m_size; + + DrawBoundingBox(const Vec3& min, const Vec3& max, float size) + : m_min(min), m_max(max), m_size(size) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->drawBoundingBox(m_min, m_max, m_size); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new DrawBoundingBox(min, max, size)); +} + +void CaptureSnapshotDrawTool::draw3DText(const Vec3& p, float scale, const RGBAColor& color, + const char* text) +{ + struct Draw3DText : public DrawToolSnapshot + { + Vec3 m_p; + float m_scale; + RGBAColor m_color; + std::string m_text; + + Draw3DText(const Vec3& p, float scale, const RGBAColor& color, const char* text) + : m_p(p), m_scale(scale), m_color(color), m_text(text) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->draw3DText(m_p, m_scale, m_color, m_text.c_str()); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new Draw3DText(p, scale, color, text)); +} + +void CaptureSnapshotDrawTool::draw3DText_Indices(const std::vector& positions, float scale, + const RGBAColor& color) +{ + struct Draw3DTextIndices : public DrawToolSnapshot + { + std::vector m_positions; + float m_scale; + RGBAColor m_color; + + Draw3DTextIndices(const std::vector& positions, float scale, const RGBAColor& color) + : m_positions(positions), m_scale(scale), m_color(color) {} + + void draw(sofa::helper::visual::DrawTool* drawTool) const override + { + drawTool->draw3DText_Indices(m_positions, m_scale, m_color); + } + }; + + m_sceneSnapshot->m_draws.emplace_back(new Draw3DTextIndices(positions, scale, color)); +} + +} // namespace sofaglfw diff --git a/SofaGLFW/src/SofaGLFW/CaptureSnapshotDrawTool.h b/SofaGLFW/src/SofaGLFW/CaptureSnapshotDrawTool.h new file mode 100644 index 0000000000..745cd4c866 --- /dev/null +++ b/SofaGLFW/src/SofaGLFW/CaptureSnapshotDrawTool.h @@ -0,0 +1,150 @@ +#pragma once +#include +#include + +#include "SceneSnapshot.h" + +namespace sofaglfw +{ + +class SOFAGLFW_API CaptureSnapshotDrawTool : public sofa::helper::visual::DrawTool +{ + std::shared_ptr m_sceneSnapshot; +public: + explicit CaptureSnapshotDrawTool(std::shared_ptr& sceneSnapshot); + + void init() override{} + void drawPoints(const std::vector& points, float size, const RGBAColor& color) override; + void drawPoints(const std::vector& points, float size, + const std::vector& color) override; + void drawLine(const Vec3& p1, const Vec3& p2, const RGBAColor& color) override; + void drawInfiniteLine(const Vec3& point, const Vec3& direction, const RGBAColor& color, + const bool& vanishing) override; + void drawInfiniteLine(const Vec3& point, const Vec3& direction, const float& size, + const RGBAColor& color, const bool& vanishing) override; + void drawLines(const std::vector& points, float size, const RGBAColor& color) override; + void drawLines(const std::vector& points, float size, + const std::vector& colors) override; + void drawLines(const std::vector& points, const std::vector& index, float size, + const RGBAColor& color) override; + void drawLineStrip(const std::vector& points, float size, + const RGBAColor& color) override; + void drawLineStrip(const std::vector& points, float size, + const std::vector& colors) override; + void drawLineLoop(const std::vector& points, float size, const RGBAColor& color) override; + void drawDisk(float radius, double from, double to, int resolution, + const RGBAColor& color) override; + void drawCircle(float radius, float lineThickness, int resolution, + const RGBAColor& color) override; + auto drawTriangles(const std::vector& points, const RGBAColor& color) -> void override; + void drawTriangles(const std::vector& points, const Vec3& normal, + const RGBAColor& color) override; + void drawTriangles(const std::vector& points, const std::vector& index, + const std::vector& normal, const RGBAColor& color) override; + void drawTriangles(const std::vector& points, const std::vector& index, + const std::vector& normal, + const std::vector& color) override; + void drawTriangles(const std::vector& points, + const std::vector& color) override; + void drawTriangles(const std::vector& points, const std::vector& normal, + const std::vector& color) override; + void drawTriangleStrip(const std::vector& points, const std::vector& normal, + const RGBAColor& color) override; + void drawTriangleFan(const std::vector& points, const std::vector& normal, + const RGBAColor& color) override; + void drawFrame(const Vec3& position, const Quaternion& orientation, const Vec3f& size) override; + void drawFrame(const Vec3& position, const Quaternion& orientation, const Vec3f& size, + const RGBAColor& color) override; + void drawSpheres(const std::vector& points, const std::vector& radius, + const RGBAColor& color) override; + void drawSpheres(const std::vector& points, float radius, + const RGBAColor& color) override; + void drawFakeSpheres(const std::vector& points, const std::vector& radius, + const RGBAColor& color) override; + void drawFakeSpheres(const std::vector& points, float radius, + const RGBAColor& color) override; + void drawCone(const Vec3& p1, const Vec3& p2, float radius1, float radius2, + const RGBAColor& color, int subd) override; + void drawCube(const float& radius, const RGBAColor& color, const int& subd) override; + void drawCylinder(const Vec3& p1, const Vec3& p2, float radius, const RGBAColor& color, + int subd) override; + void drawCapsule(const Vec3& p1, const Vec3& p2, float radius, const RGBAColor& color, + int subd) override; + void drawArrow(const Vec3& p1, const Vec3& p2, float radius, const RGBAColor& color, + int subd) override; + void drawArrow(const Vec3& p1, const Vec3& p2, float radius, float coneLength, + const RGBAColor& color, int subd) override; + void drawArrow(const Vec3& p1, const Vec3& p2, float radius, float coneLength, float coneRadius, + const RGBAColor& color, int subd) override; + void drawCross(const Vec3& p, float length, const RGBAColor& color) override; + void drawPlus(const float& radius, const RGBAColor& color, const int& subd) override; + void drawPoint(const Vec3& p, const RGBAColor& c) override; + void drawPoint(const Vec3& p, const Vec3& n, const RGBAColor& c) override; + void drawTriangle(const Vec3& p1, const Vec3& p2, const Vec3& p3, const Vec3& normal) override; + void drawTriangle(const Vec3& p1, const Vec3& p2, const Vec3& p3, const Vec3& normal, + const RGBAColor& c) override; + void drawTriangle(const Vec3& p1, const Vec3& p2, const Vec3& p3, const Vec3& normal, + const RGBAColor& c1, const RGBAColor& c2, const RGBAColor& c3) override; + void drawTriangle(const Vec3& p1, const Vec3& p2, const Vec3& p3, const Vec3& normal1, + const Vec3& normal2, const Vec3& normal3, const RGBAColor& c1, + const RGBAColor& c2, const RGBAColor& c3) override; + void drawQuad(const Vec3& p1, const Vec3& p2, const Vec3& p3, const Vec3& p4, + const Vec3& normal) override; + void drawQuad(const Vec3& p1, const Vec3& p2, const Vec3& p3, const Vec3& p4, + const Vec3& normal, const RGBAColor& c) override; + void drawQuad(const Vec3& p1, const Vec3& p2, const Vec3& p3, const Vec3& p4, + const Vec3& normal, const RGBAColor& c1, const RGBAColor& c2, const RGBAColor& c3, + const RGBAColor& c4) override; + void drawQuad(const Vec3& p1, const Vec3& p2, const Vec3& p3, const Vec3& p4, + const Vec3& normal1, const Vec3& normal2, const Vec3& normal3, + const Vec3& normal4, const RGBAColor& c1, const RGBAColor& c2, + const RGBAColor& c3, const RGBAColor& c4) override; + void drawQuads(const std::vector& points, const RGBAColor& color) override; + void drawQuads(const std::vector& points, const std::vector& colors) override; + void drawTetrahedron(const Vec3& p0, const Vec3& p1, const Vec3& p2, const Vec3& p3, + const RGBAColor& color) override; + void drawScaledTetrahedron(const Vec3& p0, const Vec3& p1, const Vec3& p2, const Vec3& p3, + const RGBAColor& color, const float scale) override; + void drawTetrahedra(const std::vector& points, const RGBAColor& color) override; + void drawScaledTetrahedra(const std::vector& points, const RGBAColor& color, + const float scale) override; + void drawHexahedron(const Vec3& p0, const Vec3& p1, const Vec3& p2, const Vec3& p3, + const Vec3& p4, const Vec3& p5, const Vec3& p6, const Vec3& p7, + const RGBAColor& color) override; + void drawHexahedra(const std::vector& points, const RGBAColor& color) override; + void drawScaledHexahedra(const std::vector& points, const RGBAColor& color, + const float scale) override; + void drawSphere(const Vec3& p, float radius) override; + void drawSphere(const Vec3& p, float radius, const RGBAColor& color) override; + void drawEllipsoid(const Vec3& p, const Vec3& radii) override; + void drawBoundingBox(const Vec3& min, const Vec3& max, float size) override; + void draw3DText(const Vec3& p, float scale, const RGBAColor& color, const char* text) override; + void draw3DText_Indices(const std::vector& positions, float scale, + const RGBAColor& color) override; + void pushMatrix() override{} + void popMatrix() override{} + void multMatrix(float*) override{} + void scale(float) override{} + void translate(float x, float y, float z) override{} + void setMaterial(const RGBAColor& color) override{} + void resetMaterial(const RGBAColor& color) override{} + void resetMaterial() override{} + void setPolygonMode(int _mode, bool _wireframe) override{} + void setLightingEnabled(bool _isAnabled) override{} + void enableBlending() override{} + void disableBlending() override{} + void enableLighting() override{} + void disableLighting() override{} + void enableDepthTest() override{} + void disableDepthTest() override{} + void saveLastState() override{} + void restoreLastState() override{} + void writeOverlayText(int x, int y, unsigned fontSize, const RGBAColor& color, + const char* text) override{} + void enablePolygonOffset(float factor, float units) override{} + void disablePolygonOffset() override{} + void readPixels(int x, int y, int w, int h, float* rgb, float* z) override{} +}; + + +} diff --git a/SofaGLFW/src/SofaGLFW/SceneSnapshot.cpp b/SofaGLFW/src/SofaGLFW/SceneSnapshot.cpp new file mode 100644 index 0000000000..c2bde80a3b --- /dev/null +++ b/SofaGLFW/src/SofaGLFW/SceneSnapshot.cpp @@ -0,0 +1,15 @@ +#include + +namespace sofaglfw +{ + +void SceneSnapshot::draw(sofa::helper::visual::DrawTool* drawTool) const +{ + for (const auto& snapshot : m_draws) + { + snapshot->draw(drawTool); + } +} +std::atomic> g_currentSceneSnapshot; + +} diff --git a/SofaGLFW/src/SofaGLFW/SceneSnapshot.h b/SofaGLFW/src/SofaGLFW/SceneSnapshot.h new file mode 100644 index 0000000000..852e33622c --- /dev/null +++ b/SofaGLFW/src/SofaGLFW/SceneSnapshot.h @@ -0,0 +1,33 @@ + +#pragma once +#include +#include +#include + +#include +#include +#include + +namespace sofaglfw +{ + +struct SOFAGLFW_API DrawToolSnapshot +{ + virtual ~DrawToolSnapshot() = default; + virtual void draw(sofa::helper::visual::DrawTool* drawTool) const = 0; +}; + + +class SOFAGLFW_API SceneSnapshot +{ +public: + std::vector> m_draws; + sofa::type::BoundingBox m_bbox; + +public: + void draw(sofa::helper::visual::DrawTool* drawTool) const; +}; + +extern SOFAGLFW_API std::atomic> g_currentSceneSnapshot; + +} diff --git a/SofaGLFW/src/SofaGLFW/SimulationLoop.cpp b/SofaGLFW/src/SofaGLFW/SimulationLoop.cpp new file mode 100644 index 0000000000..9c986665d6 --- /dev/null +++ b/SofaGLFW/src/SofaGLFW/SimulationLoop.cpp @@ -0,0 +1,120 @@ +/****************************************************************************** +* SOFA, Simulation Open-Framework Architecture * +* (c) 2006 INRIA, USTL, UJF, CNRS, MGH * +* * +* This program is free software; you can redistribute it and/or modify it * +* under the terms of the GNU General Public License as published by the Free * +* Software Foundation; either version 2 of the License, or (at your option) * +* any later version. * +* * +* This program is distributed in the hope that it will be useful, but WITHOUT * +* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * +* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * +* more details. * +* * +* You should have received a copy of the GNU General Public License along * +* with this program. If not, see . * +******************************************************************************* +* Authors: The SOFA Team and external contributors (see Authors.txt) * +* * +* Contact information: contact@sofa-framework.org * +******************************************************************************/ +#include +#include +#include + +#include "CaptureSnapshotDrawTool.h" +#include "SceneSnapshot.h" + +namespace sofaglfw +{ + +SimulationLoop::~SimulationLoop() +{ + terminate(); +} + +bool SimulationLoop::simulationIsRunning() const +{ + if (this->groot) + { + return this->groot->getAnimate(); + } + + return false; +} + +void SimulationLoop::step() const +{ + if (simulationIsRunning()) + { + sofa::helper::AdvancedTimer::begin("Animate"); + + sofa::simulation::node::animate(this->groot.get(), this->groot->getDt()); + sofa::simulation::node::updateVisual(this->groot.get()); + + commitVisual(); + + sofa::helper::AdvancedTimer::end("Animate"); + } +} + +void SimulationLoop::loop() const +{ + while (m_running) + { + SIMULATION_LOOP_SCOPE + step(); + } +} +void SimulationLoop::start() +{ + if (!m_thread) + { + m_running = true; + + this->commitVisual(); + + m_thread = std::make_unique([this]() + { + this->loop(); + }); + } +} + +void SimulationLoop::terminate() +{ + m_running = false; + if (m_thread) + { + m_thread->join(); + m_thread = nullptr; + } +} + +void SimulationLoop::captureVisualizationData(std::shared_ptr newScene) const +{ + CaptureSnapshotDrawTool drawTool(newScene); + + auto vparams = sofa::core::visual::VisualParams::defaultInstance(); + + sofa::helper::visual::DrawTool* currentDrawTool{vparams->drawTool()}; + vparams->drawTool() = &drawTool; + + sofa::simulation::node::draw(vparams, this->groot.get()); + + vparams->drawTool() = currentDrawTool; +} + +void SimulationLoop::commitVisual() const +{ + auto newScene = std::make_shared(); + newScene->m_bbox = this->groot->f_bbox.getValue(); + + captureVisualizationData(newScene); + + // update the newly created snapshot + g_currentSceneSnapshot.store(newScene, std::memory_order_release); +} + +} // namespace sofaglfw diff --git a/SofaGLFW/src/SofaGLFW/SimulationLoop.h b/SofaGLFW/src/SofaGLFW/SimulationLoop.h new file mode 100644 index 0000000000..d066c012ed --- /dev/null +++ b/SofaGLFW/src/SofaGLFW/SimulationLoop.h @@ -0,0 +1,68 @@ +/****************************************************************************** +* SOFA, Simulation Open-Framework Architecture * +* (c) 2006 INRIA, USTL, UJF, CNRS, MGH * +* * +* This program is free software; you can redistribute it and/or modify it * +* under the terms of the GNU General Public License as published by the Free * +* Software Foundation; either version 2 of the License, or (at your option) * +* any later version. * +* * +* This program is distributed in the hope that it will be useful, but WITHOUT * +* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * +* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * +* more details. * +* * +* You should have received a copy of the GNU General Public License along * +* with this program. If not, see . * +******************************************************************************* +* Authors: The SOFA Team and external contributors (see Authors.txt) * +* * +* Contact information: contact@sofa-framework.org * +******************************************************************************/ +#pragma once +#include +#include +#include +#include + +#include +#include + +#include "SceneSnapshot.h" + +namespace sofaglfw +{ + +class SOFAGLFW_API SimulationLoop +{ +public: + + using Mutex = std::shared_mutex; + + ~SimulationLoop(); + + /// the sofa root note of the current scene + sofa::simulation::Node::SPtr groot; + + bool simulationIsRunning() const; + + + void step() const; + + void loop() const; + + void start(); + void terminate(); + void captureVisualizationData(std::shared_ptr newScene) const; + + private: + + std::atomic m_running { false }; + std::unique_ptr m_thread; + + + void commitVisual() const; +}; + + +} diff --git a/SofaGLFW/src/SofaGLFW/SofaGLFWBaseGUI.cpp b/SofaGLFW/src/SofaGLFW/SofaGLFWBaseGUI.cpp index 364b7e075c..065c1e6232 100644 --- a/SofaGLFW/src/SofaGLFW/SofaGLFWBaseGUI.cpp +++ b/SofaGLFW/src/SofaGLFW/SofaGLFWBaseGUI.cpp @@ -23,37 +23,35 @@ #define GLFW_INCLUDE_NONE #include - +#include #include #include - -#include - -#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include +#include #include +#include #include #include -#include -#include -#include -#include +#include #include #include #include -#include -#include -#include -#include -#include - -#include -#include #include #include #include +#include "SceneSnapshot.h" + using namespace sofa; using namespace sofa::gui::common; @@ -137,6 +135,9 @@ void SofaGLFWBaseGUI::setSimulation(NodeSPtr groot, const std::string& filename) if (this->groot) { + m_simulationLoop.groot = groot; + m_simulationLoop.start(); + // Initialize the pick handler this->pick->init(this->groot.get()); m_sofaGLFWMouseManager.setPickHandler(getPickHandler()); @@ -457,7 +458,7 @@ void SofaGLFWBaseGUI::setWindowTitle(GLFWwindow* window, const char* title) void SofaGLFWBaseGUI::makeCurrentContext(GLFWwindow* glfwWindow) { glfwMakeContextCurrent(glfwWindow); - glfwSwapInterval( 0 ); //request disabling vsync + glfwSwapInterval( 1 ); //request enabling vsync if (!m_bGlewIsInitialized) { glewInit(); @@ -484,10 +485,6 @@ std::size_t SofaGLFWBaseGUI::runLoop(std::size_t targetNbIterations) while (s_numberOfActiveWindows > 0 && running) { - SIMULATION_LOOP_SCOPE - - // Keep running - runStep(); sofa::type::vector> closedWindows; for (auto& [glfwWindow, sofaGlfwWindow] : s_mapWindows) @@ -500,7 +497,11 @@ std::size_t SofaGLFWBaseGUI::runLoop(std::size_t targetNbIterations) makeCurrentContext(glfwWindow); m_guiEngine->beforeDraw(glfwWindow); - sofaGlfwWindow->draw(this->groot, m_vparams); + + if (auto scene = g_currentSceneSnapshot.load(std::memory_order_acquire)) + { + sofaGlfwWindow->draw(*scene, this->m_glDrawTool.get()); + } drawSelection(m_vparams); @@ -524,6 +525,8 @@ std::size_t SofaGLFWBaseGUI::runLoop(std::size_t targetNbIterations) } else { + m_simulationLoop.terminate(); + // otherwise close this window closedWindows.emplace_back(glfwWindow, sofaGlfwWindow); } @@ -617,24 +620,13 @@ void SofaGLFWBaseGUI::initVisual() setWindowBackgroundImage("textures/SOFA_logo.bmp", 0); } -void SofaGLFWBaseGUI::runStep() -{ - if(simulationIsRunning()) - { - helper::AdvancedTimer::begin("Animate"); - - node::animate(this->groot.get(), this->groot->getDt()); - node::updateVisual(this->groot.get()); - - helper::AdvancedTimer::end("Animate"); - } -} - void SofaGLFWBaseGUI::terminate() { if (!m_bGlfwIsInitialized) return; + m_simulationLoop.terminate(); + if (m_guiEngine) m_guiEngine->terminate(); diff --git a/SofaGLFW/src/SofaGLFW/SofaGLFWBaseGUI.h b/SofaGLFW/src/SofaGLFW/SofaGLFWBaseGUI.h index da5d53876b..878a29bd9a 100644 --- a/SofaGLFW/src/SofaGLFW/SofaGLFWBaseGUI.h +++ b/SofaGLFW/src/SofaGLFW/SofaGLFWBaseGUI.h @@ -21,17 +21,19 @@ ******************************************************************************/ #pragma once -#include -#include -#include - #include #include +#include +#include +#include +#include +#include #include +#include + #include -#include -#include +#include "SceneSnapshot.h" struct GLFWwindow; struct GLFWmonitor; @@ -148,12 +150,13 @@ class SOFAGLFW_API SofaGLFWBaseGUI : public BaseViewer static void content_scale_callback(GLFWwindow* window, float xscale, float yscale); void makeCurrentContext(GLFWwindow* sofaWindow); - void runStep(); inline static std::map s_mapWindows{}; inline static std::map s_mapGUIs{}; inline static std::size_t s_numberOfActiveWindows = 0; + SimulationLoop m_simulationLoop; + bool m_bGlfwIsInitialized{ false }; bool m_bGlewIsInitialized{ false }; diff --git a/SofaGLFW/src/SofaGLFW/SofaGLFWWindow.cpp b/SofaGLFW/src/SofaGLFW/SofaGLFWWindow.cpp index 9e7452481a..ee1b46e54e 100644 --- a/SofaGLFW/src/SofaGLFW/SofaGLFWWindow.cpp +++ b/SofaGLFW/src/SofaGLFW/SofaGLFWWindow.cpp @@ -67,7 +67,7 @@ void SofaGLFWWindow::close() } -void SofaGLFWWindow::draw(simulation::NodeSPtr groot, core::visual::VisualParams* vparams) +void SofaGLFWWindow::draw(const SceneSnapshot& sceneSnapshot, sofa::helper::visual::DrawTool* drawTool) { glClearColor(m_backgroundColor.r(), m_backgroundColor.g(), m_backgroundColor.b(), m_backgroundColor.a()); glClearDepth(1.0); @@ -86,16 +86,18 @@ void SofaGLFWWindow::draw(simulation::NodeSPtr groot, core::visual::VisualParams msg_error("SofaGLFWGUI") << "No camera defined."; return; } + + int width, height; + glfwGetFramebufferSize(m_glfwWindow, &width, &height); - - if (groot->f_bbox.getValue().isValid()) - { - vparams->sceneBBox() = groot->f_bbox.getValue(); - m_currentCamera->setBoundingBox(vparams->sceneBBox().minBBox(), vparams->sceneBBox().maxBBox()); + if (sceneSnapshot.m_bbox.isValid()) + { + // vparams->sceneBBox() = sceneSnapshot.m_bbox; + m_currentCamera->setBoundingBox(sceneSnapshot.m_bbox.minBBox(), sceneSnapshot.m_bbox.maxBBox()); } m_currentCamera->computeZ(); - m_currentCamera->d_widthViewport.setValue(vparams->viewport()[2]); - m_currentCamera->d_heightViewport.setValue(vparams->viewport()[3]); + m_currentCamera->d_widthViewport.setValue(width); + m_currentCamera->d_heightViewport.setValue(height); // matrices double lastModelviewMatrix [16]; @@ -104,7 +106,7 @@ void SofaGLFWWindow::draw(simulation::NodeSPtr groot, core::visual::VisualParams m_currentCamera->getOpenGLProjectionMatrix(lastProjectionMatrix); m_currentCamera->getOpenGLModelViewMatrix(lastModelviewMatrix); - glViewport(0, 0, vparams->viewport()[2], vparams->viewport()[3]); + glViewport(0, 0, width, height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glMultMatrixd(lastProjectionMatrix); @@ -114,13 +116,12 @@ void SofaGLFWWindow::draw(simulation::NodeSPtr groot, core::visual::VisualParams glMultMatrixd(lastModelviewMatrix); // Update the visual params - vparams->zNear() = m_currentCamera->getZNear(); - vparams->zFar() = m_currentCamera->getZFar(); - vparams->setProjectionMatrix(lastProjectionMatrix); - vparams->setModelViewMatrix(lastModelviewMatrix); + // vparams->zNear() = m_currentCamera->getZNear(); + // vparams->zFar() = m_currentCamera->getZFar(); + // vparams->setProjectionMatrix(lastProjectionMatrix); + // vparams->setModelViewMatrix(lastModelviewMatrix); - simulation::node::draw(vparams, groot.get()); - + sceneSnapshot.draw(drawTool); } void SofaGLFWWindow::setBackgroundColor(const RGBAColor& newColor) diff --git a/SofaGLFW/src/SofaGLFW/SofaGLFWWindow.h b/SofaGLFW/src/SofaGLFW/SofaGLFWWindow.h index 2c4e0935ed..430d785b1c 100644 --- a/SofaGLFW/src/SofaGLFW/SofaGLFWWindow.h +++ b/SofaGLFW/src/SofaGLFW/SofaGLFWWindow.h @@ -47,7 +47,7 @@ class SOFAGLFW_API SofaGLFWWindow SofaGLFWWindow(GLFWwindow* glfwWindow, sofa::component::visual::BaseCamera::SPtr camera); virtual ~SofaGLFWWindow() = default; - void draw(sofa::simulation::NodeSPtr groot, sofa::core::visual::VisualParams* vparams); + void draw(const SceneSnapshot& sceneSnapshot, sofa::helper::visual::DrawTool* drawTool); void close(); void mouseMoveEvent(int xpos, int ypos,SofaGLFWBaseGUI* gui);