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>

  namespace maquina
  {
    class Value;

    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::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 system_path(const wchar_t* path);


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


    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 project_path(const wchar_t* system_path);

    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);

    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::wstring& 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 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 Value setting(const char* path);


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