Utils.h

Go to the documentation of this file.

/*

             *
            ***
           *****
   *********************       Mercenaries Engineering SARL
     *****************              Copyright (C) 2018
       *************
         *********        http://www.mercenaries-engineering.com
        ***********
       ****     ****
      **           **

*/
#pragma once

#include "Export.h"
#include <functional>
#include <gsl/gsl>
#include <Maquina/Scene.h>

  namespace maquina
  {
    class Value;
    class Node;
    class Plug;

    template<class V, class M>
    inline V mul_pos(const V& src, const M& m)
    {
      const auto a = src[0] * m.x[0][0] + src[1] * m.x[1][0] + src[2] * m.x[2][0] + m.x[3][0];
      const auto b = src[0] * m.x[0][1] + src[1] * m.x[1][1] + src[2] * m.x[2][1] + m.x[3][1];
      const auto c = src[0] * m.x[0][2] + src[1] * m.x[1][2] + src[2] * m.x[2][2] + m.x[3][2];

      return {a, b, c};
    }

    template<class V, class M>
    inline V mul_dir(const V& src, const M& m)
    {
      const auto a = src[0] * m.x[0][0] + src[1] * m.x[1][0] + src[2] * m.x[2][0];
      const auto b = src[0] * m.x[0][1] + src[1] * m.x[1][1] + src[2] * m.x[2][1];
      const auto c = src[0] * m.x[0][2] + src[1] * m.x[1][2] + src[2] * m.x[2][2];

      return {a, b, c};
    }

    template<class T>
    inline bool is_identity(const Imath::Matrix44<T>& m)
    {
      return 
        m.x[0][0] == T(1) && 
        m.x[0][1] == T(0) && 
        m.x[0][2] == T(0) && 
        m.x[0][3] == T(0) && 

        m.x[1][0] == T(0) && 
        m.x[1][1] == T(1) && 
        m.x[1][2] == T(0) && 
        m.x[1][3] == T(0) && 

        m.x[2][0] == T(0) && 
        m.x[2][1] == T(0) && 
        m.x[2][2] == T(1) && 
        m.x[2][3] == T(0) && 

        m.x[3][0] == T(0) &&
        m.x[3][1] == T(0) &&
        m.x[3][2] == T(0) &&
        m.x[3][3] == T(1);
    }

    // Compute the closest point to p on a triangle and possibly returns its barycentric coordinates
    MAQUINA_EXPORT Imath::V3f closest_point_on_triangle( const Imath::V3f *triangle, const Imath::V3f &p, float* s_out = nullptr, float* t_out = nullptr);


    MAQUINA_EXPORT int intersect_ray_sphere(const Imath::V3d& o, const Imath::V3d& d, const Imath::V3d& c, float r, float& t0, float& t1);

    // Computes the point on the first segment which is the closest to the second segment
    MAQUINA_EXPORT Imath::V3f closest_point_segment_to_segment(const Imath::V3f *s1, const Imath::V3f *s2);
    MAQUINA_EXPORT Imath::V3d closest_point_segment_to_segment(const Imath::V3d *s1, const Imath::V3d *s2);


    MAQUINA_EXPORT Imath::V3d closest_point_to_line(const Imath::V3d& o, const Imath::V3d& d, const Imath::V3d& p);

    MAQUINA_EXPORT void closest_point_between_lines(const Imath::V3f& o0, const Imath::V3f& d0, const Imath::V3f& o1, const Imath::V3f& d1, float& t0, float& t1);

    // Computes two vectors orthogonal to the first one
    MAQUINA_EXPORT void get_orthogonal_vectors(const Imath::V3d& fx, Imath::V3d& fy, Imath::V3d& fz);


    MAQUINA_EXPORT Imath::M44f blend_to_identity(const Imath::M44f& a, float w);
    MAQUINA_EXPORT Imath::M44d blend_to_identity(const Imath::M44d& a, double w);


    MAQUINA_EXPORT Imath::M44f lerp(const Imath::M44f& a, const Imath::M44f& b, float w);
    MAQUINA_EXPORT Imath::M44d lerp(const Imath::M44d& a, const Imath::M44d& b, double w);

    MAQUINA_EXPORT void ik_3_joints(
      const Imath::V3d& p0, 
      const Imath::V3d& p1, 
      const Imath::V3d& p2, 
      const Imath::V3d& goal, 
      const Imath::V3d& normal, 
      Imath::Quatd& r0, 
      double& a1,        
      Imath::V3d& axis1, 
      bool negate_normal = false // Whether the original normal should be negated or not
    );

    MAQUINA_EXPORT int solve_cubic(float a, float b, float c, float d, float* roots);

    MAQUINA_EXPORT int solve_cubic(double a, double b, double c, double d, double* roots);

    MAQUINA_EXPORT std::vector<uint8_t> deflate(const uint8_t* data, size_t size);

    MAQUINA_EXPORT std::vector<uint8_t> inflate(const uint8_t* data, size_t size);

    MAQUINA_EXPORT std::string base64_encode(const uint8_t* data, size_t size);

    MAQUINA_EXPORT std::vector<uint8_t> base64_decode(const char* text, size_t size);

    MAQUINA_EXPORT std::wstring expand_string(const wchar_t* path);


    MAQUINA_EXPORT std::wstring system_path(const wchar_t* path);


    MAQUINA_EXPORT std::string system_path(const std::string_view& path);

    MAQUINA_EXPORT std::wstring project_path(const wchar_t* system_path);


    MAQUINA_EXPORT std::string system_path_local(const wchar_t* path);


    MAQUINA_EXPORT std::string comparable_path(std::string s);


    MAQUINA_EXPORT bool same_file(std::string a, std::string b);


    MAQUINA_EXPORT const std::vector<std::pair<std::string, std::wstring>>& path_variables();


    MAQUINA_EXPORT void set_path_variables(const std::vector<std::pair<std::string, std::wstring>>& path_vars);

    MAQUINA_EXPORT std::wstring utf8_to_wstring(const char* uft8);

    MAQUINA_EXPORT std::string wstring_to_utf8(const wchar_t* str);

    MAQUINA_EXPORT std::wstring local_to_wstring(const char* str);

    MAQUINA_EXPORT std::string wstring_to_local(const wchar_t* str);

    MAQUINA_EXPORT std::string to_log(const std::wstring& s);

    MAQUINA_EXPORT std::wstring getenv_w(const char* name);

    MAQUINA_EXPORT bool list_directory_files(const wchar_t*  directory, std::vector<std::wstring>& files, bool relative=false);

    MAQUINA_EXPORT bool file_exists(const wchar_t* file);

    MAQUINA_EXPORT std::string file_extension(const wchar_t* file);

    MAQUINA_EXPORT std::wstring file_name(const wchar_t* file);

    MAQUINA_EXPORT std::wstring parent_path(const wchar_t* file);


    MAQUINA_EXPORT std::wstring project_directory();


    MAQUINA_EXPORT void set_project_directory(const wchar_t* path);

    MAQUINA_EXPORT void drm_init(const std::string& software_name, const std::wstring& license_file_path, const std::string& license_server);

    MAQUINA_EXPORT void drm_release();

    MAQUINA_EXPORT std::pair<bool, std::string> drm_status();

    MAQUINA_EXPORT std::string drm_hostid();

    MAQUINA_EXPORT bool has_tag(const std::string& tags, const char* tag);

    MAQUINA_EXPORT std::string add_tag(const std::string& tags, const char* tag);

    MAQUINA_EXPORT bool has_tag(const Node& node, const char* tag);

    class TagsIteration
    {
      friend TagsIteration tags(const std::string_view& tags_list);

      TagsIteration(const std::string_view& tags);

      class MAQUINA_EXPORT Iterator
      {
      public:
        using iterator_category = std::forward_iterator_tag;
        using value_type = std::string_view;
        using difference_type = std::ptrdiff_t;
        using pointer = std::string_view;
        using reference = std::string_view;

        reference operator*() const;
        bool operator==(const Iterator& other) const;
        bool operator!=(const Iterator &other) const;
        Iterator& operator++();
        Iterator(const std::string_view& tags, size_t start);
      private:
        void _init(size_t start);
        const std::string_view _tags;
        size_t _start, _end;
      };

    public:
      Iterator begin() const;
      Iterator end() const;
    private:
      const std::string_view _tags;
    };

    TagsIteration tags(const std::string_view& tags_list);

    MAQUINA_EXPORT void parallel_for(uint32_t first, 
                                     uint32_t last, 
                                     uint32_t batch_size, 
                                     const std::function<void(uint32_t first, uint32_t last)>& function 
                                    );

    MAQUINA_EXPORT Imath::Box3f compute_aabb(const gsl::span<const Imath::V3f>& points);

    MAQUINA_EXPORT Imath::V3f compute_average(const gsl::span<const Imath::V3f>& points, const gsl::span<const uint32_t>& indices);


    MAQUINA_EXPORT Value setting(const char* path);


    MAQUINA_EXPORT Plug setting_plug(const std::string_view& path);


    MAQUINA_EXPORT void set_setting(const char* path, const Value& value);

    MAQUINA_EXPORT Plug add_setting(const std::string_view& path, const Value& value, std::string description="");


    MAQUINA_EXPORT Scene remap_attribute(const SceneConst& new_scene, const SceneConst& old_scene, const SceneConst& old_attribute,
                                         const std::string& attribute_name, const Shape::Topology& attribute_topology, bool interpolate_vertex);


    MAQUINA_EXPORT std::vector<std::string> split(const StringView& s, const StringView& sep);

    MAQUINA_EXPORT std::string join(const std::vector<std::string>& strings, const StringView& sep);

    struct LazySceneChildResult
    {
      SceneConst scene;         
      std::string path;         
      Imath::M44d world_matrix; 
    };

    // TODO use otional here

    MAQUINA_EXPORT std::shared_ptr<LazySceneChildResult> lazy_scene_child(const SceneConst& scene, const std::string& path, bool shapes_only=false);

    MAQUINA_EXPORT std::pair<std::vector<Node>, std::vector<Plug>> _document_paths(const Node& node);

  }