#ifndef EFL_GENERATED_EVAS_3D_NODE_HH
#define EFL_GENERATED_EVAS_3D_NODE_HH

extern "C"
{
#include <Efl.h>
}
#include <Eo.hh>

#include <eo_cxx_interop.hh>

extern "C"
{
#include "evas_3d_node.eo.h"
}

#include "evas_3d_object.eo.hh"
#include "evas_common_interface.eo.hh"

struct evas_3d_node
      : evas_3d_object,
      efl::eo::detail::extension_inheritance<evas::common_interface>::template type< ::evas_3d_node>

{
   /// @brief Eo Constructor.
   ///
   /// Constructs the object from an Eo* pointer stealing its ownership.
   ///
   /// @param eo The Eo object pointer.
   ///
   explicit evas_3d_node(Eo* eo)
      : evas_3d_object(eo)
   {}

   /// @brief nullptr_t Constructor.
   ///
   /// Constructs an empty (null) object.
   ///
   explicit evas_3d_node(std::nullptr_t)
      : evas_3d_object(nullptr)
   {}

   /// @brief Constructor.
   ///
   /// @param type 
   ///
   evas_3d_node(Evas_3D_Node_Type type_, efl::eo::parent_type _p = (efl::eo::parent = nullptr))
      : evas_3d_node(_c0(type_, _p))
   {}

   /// @brief Copy Constructor.
   ///
   evas_3d_node(evas_3d_node const& other)
      : evas_3d_object(eo_ref(other._eo_ptr()))
   {}

   ~evas_3d_node() {}

   /// @brief Pure virtual update_notify function..
   /// Update request for the object.
   ///
   void update_notify() const
   {
      eo_do(_eo_ptr(), ::evas_3d_object_update_notify());
   }

   /// @brief Pure virtual change_notify function..
   /// Update request for the object.
   ///
   /// @param state State that is changed
   /// @param ref The Object that caused the change
   ///
   void change_notify(Evas_3D_State state_, Evas_3D_Object * ref_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_object_change_notify(state_, ref_));
   }

   /// @param inherit Whether to inherit parent position
   ///
   bool position_inherit_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_3d_node_position_inherit_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @param inherit Whether to inherit parent position
   ///
   void position_inherit_set(bool inherit_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_node_position_inherit_set(efl::eolian::to_c(inherit_)));
   }

   /// @param inherit Whether to inherit parent orientation
   ///
   bool orientation_inherit_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_3d_node_orientation_inherit_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @param inherit Whether to inherit parent orientation
   ///
   void orientation_inherit_set(bool inherit_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_node_orientation_inherit_set(efl::eolian::to_c(inherit_)));
   }

   /// @param inherit Whether to inherit parent scale
   ///
   bool scale_inherit_get() const
   {
      Eina_Bool _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_3d_node_scale_inherit_get());
      return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
   }

   /// @param inherit Whether to inherit parent scale
   ///
   void scale_inherit_set(bool inherit_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_node_scale_inherit_set(efl::eolian::to_c(inherit_)));
   }

   /// @param camera The camera
   ///
   Evas_3D_Camera * camera_get() const
   {
      Evas_3D_Camera * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_3d_node_camera_get());
      return _tmp_ret;
   }

   /// @param camera The camera
   ///
   void camera_set(Evas_3D_Camera * camera_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_node_camera_set(camera_));
   }

   /// @param light The light
   ///
   Evas_3D_Light * light_get() const
   {
      Evas_3D_Light * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_3d_node_light_get());
      return _tmp_ret;
   }

   /// @param light The light
   ///
   void light_set(Evas_3D_Light * light_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_node_light_set(light_));
   }

   /// @param frame The animation frame number.
   ///
   int mesh_frame_get(Evas_3D_Mesh * mesh_) const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_3d_node_mesh_frame_get(mesh_));
      return _tmp_ret;
   }

   /// @param frame The animation frame number.
   ///
   void mesh_frame_set(Evas_3D_Mesh * mesh_, int frame_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_node_mesh_frame_set(mesh_, frame_));
   }

   Evas_3D_Node_Type type_get() const
   {
      Evas_3D_Node_Type _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_3d_node_type_get());
      return _tmp_ret;
   }

   /// @param member Node object to be added.
   ///
   void member_add(Evas_3D_Node * member_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_node_member_add(member_));
   }

   /// @param member Member node to be deleted from the given node.
   ///
   void member_del(Evas_3D_Node * member_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_node_member_del(member_));
   }

   Evas_3D_Node * parent_get() const
   {
      Evas_3D_Node * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_3d_node_parent_get());
      return _tmp_ret;
   }

   efl::eina::crange_list< Evas_3D_Node * > member_list_get() const
   {
      const Eina_List * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_3d_node_member_list_get());
      return efl::eolian::to_cxx<efl::eina::crange_list< Evas_3D_Node * >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
   }

   /// @param x X coordinate of the position.
   /// @param y Y coordinate of the position.
   /// @param z Z coordinate of the position.
   ///
   void position_set(Evas_Real x_, Evas_Real y_, Evas_Real z_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_node_position_set(x_, y_, z_));
   }

   /// @param x X term of the orientation quaternion (w, x, y, z)
   /// @param y Y term of the orientation quaternion (w, x, y, z)
   /// @param z Z term of the orientation quaternion (w, x, y, z)
   /// @param w W term of the orientation quaternion (w, x, y, z)
   ///
   void orientation_set(Evas_Real x_, Evas_Real y_, Evas_Real z_, Evas_Real w_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_node_orientation_set(x_, y_, z_, w_));
   }

   /// @param angle Rotation angle.
   /// @param x X term of the rotation axis.
   /// @param y Y term of the rotation axis.
   /// @param z Z term of the rotation axis.
   ///
   void orientation_angle_axis_set(Evas_Real angle_, Evas_Real x_, Evas_Real y_, Evas_Real z_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_node_orientation_angle_axis_set(angle_, x_, y_, z_));
   }

   /// @param x Scale factor along X-axis.
   /// @param y Scale factor along Y-axis.
   /// @param z Scale factor along Z-axis.
   ///
   void scale_set(Evas_Real x_, Evas_Real y_, Evas_Real z_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_node_scale_set(x_, y_, z_));
   }

   /// @param space 
   /// @param[out] x Pointer to receive X coordinate of the position.
   /// @param[out] y Pointer to receive Y coordinate of the position.
   /// @param[out] z Pointer to receive Z coordinate of the position.
   ///
   void position_get(Evas_3D_Space space_, Evas_Real* x_, Evas_Real* y_, Evas_Real* z_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_node_position_get(space_, x_, y_, z_));
   }

   /// @param space 
   /// @param[out] x Pointer to receive X term of the orientation quaternion.
   /// @param[out] y Pointer to receive Y term of the orientation quaternion.
   /// @param[out] z Pointer to receive Z term of the orientation quaternion.
   /// @param[out] w Pointer to receive W term of the orientation quaternion.
   ///
   void orientation_get(Evas_3D_Space space_, Evas_Real* x_, Evas_Real* y_, Evas_Real* z_, Evas_Real* w_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_node_orientation_get(space_, x_, y_, z_, w_));
   }

   /// @param space 
   /// @param[out] x Pointer to receive Scale factor along X-axis.
   /// @param[out] y Pointer to receive Scale factor along X-axis.
   /// @param[out] z Pointer to receive Scale factor along X-axis.
   ///
   void scale_get(Evas_3D_Space space_, Evas_Real* x_, Evas_Real* y_, Evas_Real* z_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_node_scale_get(space_, x_, y_, z_));
   }

   /// @param target_space Space where the target position belongs to.
   /// @param x X coordinate of the target position.
   /// @param y Y coordinate of the target position.
   /// @param z Z coordinate of the target position.
   /// @param up_space Space where the up vector belongs to.
   /// @param ux X term of the up vector.
   /// @param uy Y term of the up vector.
   /// @param uz Z term of the up vector.
   ///
   void look_at_set(Evas_3D_Space target_space_, Evas_Real x_, Evas_Real y_, Evas_Real z_, Evas_3D_Space up_space_, Evas_Real ux_, Evas_Real uy_, Evas_Real uz_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_node_look_at_set(target_space_, x_, y_, z_, up_space_, ux_, uy_, uz_));
   }

   /// @param mesh The mesh to be added.
   ///
   void mesh_add(Evas_3D_Mesh * mesh_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_node_mesh_add(mesh_));
   }

   /// @param mesh The mesh to be deleted.
   ///
   void mesh_del(Evas_3D_Mesh * mesh_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_node_mesh_del(mesh_));
   }

   efl::eina::crange_list< Evas_3D_Mesh * > mesh_list_get() const
   {
      const Eina_List * _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_3d_node_mesh_list_get());
      return efl::eolian::to_cxx<efl::eina::crange_list< Evas_3D_Mesh * >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
   }

   /// @param x Coordinates of vector.
   /// @param y 
   /// @param z 
   /// @param x2 
   /// @param y2 
   /// @param z2 
   ///
   void bounding_box_get(Evas_Real * x_, Evas_Real * y_, Evas_Real * z_, Evas_Real * x2_, Evas_Real * y2_, Evas_Real * z2_) const
   {
      eo_do(_eo_ptr(), ::evas_3d_node_bounding_box_get(x_, y_, z_, x2_, y2_, z2_));
   }

   /// @param camera_node 
   ///
   int obb_frustum_check(Evas_3D_Node * camera_node_) const
   {
      int _tmp_ret;
      eo_do(_eo_ptr(), _tmp_ret = ::evas_3d_node_obb_frustum_check(camera_node_));
      return _tmp_ret;
   }

   static Eo_Class const* _eo_class()
   {
      return(EVAS_3D_NODE_CLASS);
   }

private:
   static Eo* _c0(Evas_3D_Node_Type type_, efl::eo::parent_type _p)
   {
      return eo_add_ref(EVAS_3D_NODE_CLASS, _p._eo_raw, evas_3d_node_constructor(type_));
   }

};
template <typename T>
void _evas_3d_node_update_notify_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   static_cast<T*>(self->this_)->update_notify();
}

template <typename T>
void _evas_3d_node_change_notify_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_3D_State state_, Evas_3D_Object * ref_)
{
   static_cast<T*>(self->this_)->change_notify(state_, ref_);
}

template <typename T>
bool _evas_3d_node_position_inherit_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->position_inherit_get();
}

template <typename T>
void _evas_3d_node_position_inherit_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Eina_Bool inherit_)
{
   static_cast<T*>(self->this_)->position_inherit_set(efl::eolian::to_cxx<bool>(inherit_, std::tuple<std::false_type>()));
}

template <typename T>
bool _evas_3d_node_orientation_inherit_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->orientation_inherit_get();
}

template <typename T>
void _evas_3d_node_orientation_inherit_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Eina_Bool inherit_)
{
   static_cast<T*>(self->this_)->orientation_inherit_set(efl::eolian::to_cxx<bool>(inherit_, std::tuple<std::false_type>()));
}

template <typename T>
bool _evas_3d_node_scale_inherit_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->scale_inherit_get();
}

template <typename T>
void _evas_3d_node_scale_inherit_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Eina_Bool inherit_)
{
   static_cast<T*>(self->this_)->scale_inherit_set(efl::eolian::to_cxx<bool>(inherit_, std::tuple<std::false_type>()));
}

template <typename T>
Evas_3D_Camera * _evas_3d_node_camera_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->camera_get();
}

template <typename T>
void _evas_3d_node_camera_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_3D_Camera * camera_)
{
   static_cast<T*>(self->this_)->camera_set(camera_);
}

template <typename T>
Evas_3D_Light * _evas_3d_node_light_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->light_get();
}

template <typename T>
void _evas_3d_node_light_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_3D_Light * light_)
{
   static_cast<T*>(self->this_)->light_set(light_);
}

template <typename T>
int _evas_3d_node_mesh_frame_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_3D_Mesh * mesh_)
{
   return static_cast<T*>(self->this_)->mesh_frame_get(mesh_);
}

template <typename T>
void _evas_3d_node_mesh_frame_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_3D_Mesh * mesh_, int frame_)
{
   static_cast<T*>(self->this_)->mesh_frame_set(mesh_, frame_);
}

template <typename T>
Evas_3D_Node_Type _evas_3d_node_type_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->type_get();
}

template <typename T>
void _evas_3d_node_member_add_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_3D_Node * member_)
{
   static_cast<T*>(self->this_)->member_add(member_);
}

template <typename T>
void _evas_3d_node_member_del_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_3D_Node * member_)
{
   static_cast<T*>(self->this_)->member_del(member_);
}

template <typename T>
Evas_3D_Node * _evas_3d_node_parent_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->parent_get();
}

template <typename T>
efl::eina::crange_list< Evas_3D_Node * > _evas_3d_node_member_list_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->member_list_get();
}

template <typename T>
void _evas_3d_node_position_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Real x_, Evas_Real y_, Evas_Real z_)
{
   static_cast<T*>(self->this_)->position_set(x_, y_, z_);
}

template <typename T>
void _evas_3d_node_orientation_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Real x_, Evas_Real y_, Evas_Real z_, Evas_Real w_)
{
   static_cast<T*>(self->this_)->orientation_set(x_, y_, z_, w_);
}

template <typename T>
void _evas_3d_node_orientation_angle_axis_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Real angle_, Evas_Real x_, Evas_Real y_, Evas_Real z_)
{
   static_cast<T*>(self->this_)->orientation_angle_axis_set(angle_, x_, y_, z_);
}

template <typename T>
void _evas_3d_node_scale_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Real x_, Evas_Real y_, Evas_Real z_)
{
   static_cast<T*>(self->this_)->scale_set(x_, y_, z_);
}

template <typename T>
void _evas_3d_node_position_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_3D_Space space_, Evas_Real* x_, Evas_Real* y_, Evas_Real* z_)
{
   static_cast<T*>(self->this_)->position_get(space_, x_, y_, z_);
}

template <typename T>
void _evas_3d_node_orientation_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_3D_Space space_, Evas_Real* x_, Evas_Real* y_, Evas_Real* z_, Evas_Real* w_)
{
   static_cast<T*>(self->this_)->orientation_get(space_, x_, y_, z_, w_);
}

template <typename T>
void _evas_3d_node_scale_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_3D_Space space_, Evas_Real* x_, Evas_Real* y_, Evas_Real* z_)
{
   static_cast<T*>(self->this_)->scale_get(space_, x_, y_, z_);
}

template <typename T>
void _evas_3d_node_look_at_set_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_3D_Space target_space_, Evas_Real x_, Evas_Real y_, Evas_Real z_, Evas_3D_Space up_space_, Evas_Real ux_, Evas_Real uy_, Evas_Real uz_)
{
   static_cast<T*>(self->this_)->look_at_set(target_space_, x_, y_, z_, up_space_, ux_, uy_, uz_);
}

template <typename T>
void _evas_3d_node_mesh_add_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_3D_Mesh * mesh_)
{
   static_cast<T*>(self->this_)->mesh_add(mesh_);
}

template <typename T>
void _evas_3d_node_mesh_del_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_3D_Mesh * mesh_)
{
   static_cast<T*>(self->this_)->mesh_del(mesh_);
}

template <typename T>
efl::eina::crange_list< Evas_3D_Mesh * > _evas_3d_node_mesh_list_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self)
{
   return static_cast<T*>(self->this_)->mesh_list_get();
}

template <typename T>
void _evas_3d_node_bounding_box_get_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_Real * x_, Evas_Real * y_, Evas_Real * z_, Evas_Real * x2_, Evas_Real * y2_, Evas_Real * z2_)
{
   static_cast<T*>(self->this_)->bounding_box_get(x_, y_, z_, x2_, y2_, z2_);
}

template <typename T>
int _evas_3d_node_obb_frustum_check_wrapper(Eo* objid EINA_UNUSED, efl::eo::detail::Inherit_Private_Data* self, Evas_3D_Node * camera_node_)
{
   return static_cast<T*>(self->this_)->obb_frustum_check(camera_node_);
}

namespace efl { namespace eo { namespace detail {

template<>
struct operations< ::evas_3d_node >
{
   template <typename T>
   struct type
   {
      virtual void update_notify()
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_object_update_notify());
      }

      virtual void change_notify(Evas_3D_State state_, Evas_3D_Object * ref_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_object_change_notify(state_, ref_));
      }

      virtual bool position_inherit_get()
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_3d_node_position_inherit_get());
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void position_inherit_set(bool inherit_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_node_position_inherit_set(efl::eolian::to_c(inherit_)));
      }

      virtual bool orientation_inherit_get()
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_3d_node_orientation_inherit_get());
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void orientation_inherit_set(bool inherit_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_node_orientation_inherit_set(efl::eolian::to_c(inherit_)));
      }

      virtual bool scale_inherit_get()
      {
         Eina_Bool _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_3d_node_scale_inherit_get());
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      virtual void scale_inherit_set(bool inherit_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_node_scale_inherit_set(efl::eolian::to_c(inherit_)));
      }

      virtual Evas_3D_Camera * camera_get()
      {
         Evas_3D_Camera * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_3d_node_camera_get());
            return _tmp_ret;
      }

      virtual void camera_set(Evas_3D_Camera * camera_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_node_camera_set(camera_));
      }

      virtual Evas_3D_Light * light_get()
      {
         Evas_3D_Light * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_3d_node_light_get());
            return _tmp_ret;
      }

      virtual void light_set(Evas_3D_Light * light_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_node_light_set(light_));
      }

      virtual int mesh_frame_get(Evas_3D_Mesh * mesh_)
      {
         int _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_3d_node_mesh_frame_get(mesh_));
            return _tmp_ret;
      }

      virtual void mesh_frame_set(Evas_3D_Mesh * mesh_, int frame_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_node_mesh_frame_set(mesh_, frame_));
      }

      virtual Evas_3D_Node_Type type_get()
      {
         Evas_3D_Node_Type _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_3d_node_type_get());
            return _tmp_ret;
      }

      virtual void member_add(Evas_3D_Node * member_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_node_member_add(member_));
      }

      virtual void member_del(Evas_3D_Node * member_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_node_member_del(member_));
      }

      virtual Evas_3D_Node * parent_get()
      {
         Evas_3D_Node * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_3d_node_parent_get());
            return _tmp_ret;
      }

      virtual efl::eina::crange_list< Evas_3D_Node * > member_list_get()
      {
         const Eina_List * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_3d_node_member_list_get());
            return efl::eolian::to_cxx<efl::eina::crange_list< Evas_3D_Node * >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      virtual void position_set(Evas_Real x_, Evas_Real y_, Evas_Real z_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_node_position_set(x_, y_, z_));
      }

      virtual void orientation_set(Evas_Real x_, Evas_Real y_, Evas_Real z_, Evas_Real w_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_node_orientation_set(x_, y_, z_, w_));
      }

      virtual void orientation_angle_axis_set(Evas_Real angle_, Evas_Real x_, Evas_Real y_, Evas_Real z_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_node_orientation_angle_axis_set(angle_, x_, y_, z_));
      }

      virtual void scale_set(Evas_Real x_, Evas_Real y_, Evas_Real z_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_node_scale_set(x_, y_, z_));
      }

      virtual void position_get(Evas_3D_Space space_, Evas_Real* x_, Evas_Real* y_, Evas_Real* z_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_node_position_get(space_, x_, y_, z_));
      }

      virtual void orientation_get(Evas_3D_Space space_, Evas_Real* x_, Evas_Real* y_, Evas_Real* z_, Evas_Real* w_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_node_orientation_get(space_, x_, y_, z_, w_));
      }

      virtual void scale_get(Evas_3D_Space space_, Evas_Real* x_, Evas_Real* y_, Evas_Real* z_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_node_scale_get(space_, x_, y_, z_));
      }

      virtual void look_at_set(Evas_3D_Space target_space_, Evas_Real x_, Evas_Real y_, Evas_Real z_, Evas_3D_Space up_space_, Evas_Real ux_, Evas_Real uy_, Evas_Real uz_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_node_look_at_set(target_space_, x_, y_, z_, up_space_, ux_, uy_, uz_));
      }

      virtual void mesh_add(Evas_3D_Mesh * mesh_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_node_mesh_add(mesh_));
      }

      virtual void mesh_del(Evas_3D_Mesh * mesh_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_node_mesh_del(mesh_));
      }

      virtual efl::eina::crange_list< Evas_3D_Mesh * > mesh_list_get()
      {
         const Eina_List * _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_3d_node_mesh_list_get());
            return efl::eolian::to_cxx<efl::eina::crange_list< Evas_3D_Mesh * >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      virtual void bounding_box_get(Evas_Real * x_, Evas_Real * y_, Evas_Real * z_, Evas_Real * x2_, Evas_Real * y2_, Evas_Real * z2_)
      {
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               ::evas_3d_node_bounding_box_get(x_, y_, z_, x2_, y2_, z2_));
      }

      virtual int obb_frustum_check(Evas_3D_Node * camera_node_)
      {
         int _tmp_ret = {};
         eo_do_super(static_cast<T*>(this)->_eo_ptr(),
               static_cast<T*>(this)->_eo_class(),
               _tmp_ret = ::evas_3d_node_obb_frustum_check(camera_node_));
            return _tmp_ret;
      }

   };
};


template<>
struct operation_description_class_size< ::evas_3d_node >
{
   static const int value = 32;
};

template <typename T>
int initialize_operation_description(efl::eo::detail::tag<::evas_3d_node>
                                 , Eo_Op_Description* ops)
{
   (void)ops;
   ops[0].func = reinterpret_cast<void*>(& ::_evas_3d_node_update_notify_wrapper<T>);
   ops[0].api_func = reinterpret_cast<void*>(& ::evas_3d_object_update_notify);
   ops[0].op = EO_OP_OVERRIDE;
   ops[0].op_type = EO_OP_TYPE_REGULAR;
   ops[0].doc = NULL;

   ops[1].func = reinterpret_cast<void*>(& ::_evas_3d_node_change_notify_wrapper<T>);
   ops[1].api_func = reinterpret_cast<void*>(& ::evas_3d_object_change_notify);
   ops[1].op = EO_OP_OVERRIDE;
   ops[1].op_type = EO_OP_TYPE_REGULAR;
   ops[1].doc = NULL;

   ops[2].func = reinterpret_cast<void*>(& ::_evas_3d_node_position_inherit_get_wrapper<T>);
   ops[2].api_func = reinterpret_cast<void*>(& ::evas_3d_node_position_inherit_get);
   ops[2].op = EO_OP_OVERRIDE;
   ops[2].op_type = EO_OP_TYPE_REGULAR;
   ops[2].doc = NULL;

   ops[3].func = reinterpret_cast<void*>(& ::_evas_3d_node_position_inherit_set_wrapper<T>);
   ops[3].api_func = reinterpret_cast<void*>(& ::evas_3d_node_position_inherit_set);
   ops[3].op = EO_OP_OVERRIDE;
   ops[3].op_type = EO_OP_TYPE_REGULAR;
   ops[3].doc = NULL;

   ops[4].func = reinterpret_cast<void*>(& ::_evas_3d_node_orientation_inherit_get_wrapper<T>);
   ops[4].api_func = reinterpret_cast<void*>(& ::evas_3d_node_orientation_inherit_get);
   ops[4].op = EO_OP_OVERRIDE;
   ops[4].op_type = EO_OP_TYPE_REGULAR;
   ops[4].doc = NULL;

   ops[5].func = reinterpret_cast<void*>(& ::_evas_3d_node_orientation_inherit_set_wrapper<T>);
   ops[5].api_func = reinterpret_cast<void*>(& ::evas_3d_node_orientation_inherit_set);
   ops[5].op = EO_OP_OVERRIDE;
   ops[5].op_type = EO_OP_TYPE_REGULAR;
   ops[5].doc = NULL;

   ops[6].func = reinterpret_cast<void*>(& ::_evas_3d_node_scale_inherit_get_wrapper<T>);
   ops[6].api_func = reinterpret_cast<void*>(& ::evas_3d_node_scale_inherit_get);
   ops[6].op = EO_OP_OVERRIDE;
   ops[6].op_type = EO_OP_TYPE_REGULAR;
   ops[6].doc = NULL;

   ops[7].func = reinterpret_cast<void*>(& ::_evas_3d_node_scale_inherit_set_wrapper<T>);
   ops[7].api_func = reinterpret_cast<void*>(& ::evas_3d_node_scale_inherit_set);
   ops[7].op = EO_OP_OVERRIDE;
   ops[7].op_type = EO_OP_TYPE_REGULAR;
   ops[7].doc = NULL;

   ops[8].func = reinterpret_cast<void*>(& ::_evas_3d_node_camera_get_wrapper<T>);
   ops[8].api_func = reinterpret_cast<void*>(& ::evas_3d_node_camera_get);
   ops[8].op = EO_OP_OVERRIDE;
   ops[8].op_type = EO_OP_TYPE_REGULAR;
   ops[8].doc = NULL;

   ops[9].func = reinterpret_cast<void*>(& ::_evas_3d_node_camera_set_wrapper<T>);
   ops[9].api_func = reinterpret_cast<void*>(& ::evas_3d_node_camera_set);
   ops[9].op = EO_OP_OVERRIDE;
   ops[9].op_type = EO_OP_TYPE_REGULAR;
   ops[9].doc = NULL;

   ops[10].func = reinterpret_cast<void*>(& ::_evas_3d_node_light_get_wrapper<T>);
   ops[10].api_func = reinterpret_cast<void*>(& ::evas_3d_node_light_get);
   ops[10].op = EO_OP_OVERRIDE;
   ops[10].op_type = EO_OP_TYPE_REGULAR;
   ops[10].doc = NULL;

   ops[11].func = reinterpret_cast<void*>(& ::_evas_3d_node_light_set_wrapper<T>);
   ops[11].api_func = reinterpret_cast<void*>(& ::evas_3d_node_light_set);
   ops[11].op = EO_OP_OVERRIDE;
   ops[11].op_type = EO_OP_TYPE_REGULAR;
   ops[11].doc = NULL;

   ops[12].func = reinterpret_cast<void*>(& ::_evas_3d_node_mesh_frame_get_wrapper<T>);
   ops[12].api_func = reinterpret_cast<void*>(& ::evas_3d_node_mesh_frame_get);
   ops[12].op = EO_OP_OVERRIDE;
   ops[12].op_type = EO_OP_TYPE_REGULAR;
   ops[12].doc = NULL;

   ops[13].func = reinterpret_cast<void*>(& ::_evas_3d_node_mesh_frame_set_wrapper<T>);
   ops[13].api_func = reinterpret_cast<void*>(& ::evas_3d_node_mesh_frame_set);
   ops[13].op = EO_OP_OVERRIDE;
   ops[13].op_type = EO_OP_TYPE_REGULAR;
   ops[13].doc = NULL;

   ops[14].func = reinterpret_cast<void*>(& ::_evas_3d_node_type_get_wrapper<T>);
   ops[14].api_func = reinterpret_cast<void*>(& ::evas_3d_node_type_get);
   ops[14].op = EO_OP_OVERRIDE;
   ops[14].op_type = EO_OP_TYPE_REGULAR;
   ops[14].doc = NULL;

   ops[15].func = reinterpret_cast<void*>(& ::_evas_3d_node_member_add_wrapper<T>);
   ops[15].api_func = reinterpret_cast<void*>(& ::evas_3d_node_member_add);
   ops[15].op = EO_OP_OVERRIDE;
   ops[15].op_type = EO_OP_TYPE_REGULAR;
   ops[15].doc = NULL;

   ops[16].func = reinterpret_cast<void*>(& ::_evas_3d_node_member_del_wrapper<T>);
   ops[16].api_func = reinterpret_cast<void*>(& ::evas_3d_node_member_del);
   ops[16].op = EO_OP_OVERRIDE;
   ops[16].op_type = EO_OP_TYPE_REGULAR;
   ops[16].doc = NULL;

   ops[17].func = reinterpret_cast<void*>(& ::_evas_3d_node_parent_get_wrapper<T>);
   ops[17].api_func = reinterpret_cast<void*>(& ::evas_3d_node_parent_get);
   ops[17].op = EO_OP_OVERRIDE;
   ops[17].op_type = EO_OP_TYPE_REGULAR;
   ops[17].doc = NULL;

   ops[18].func = reinterpret_cast<void*>(& ::_evas_3d_node_member_list_get_wrapper<T>);
   ops[18].api_func = reinterpret_cast<void*>(& ::evas_3d_node_member_list_get);
   ops[18].op = EO_OP_OVERRIDE;
   ops[18].op_type = EO_OP_TYPE_REGULAR;
   ops[18].doc = NULL;

   ops[19].func = reinterpret_cast<void*>(& ::_evas_3d_node_position_set_wrapper<T>);
   ops[19].api_func = reinterpret_cast<void*>(& ::evas_3d_node_position_set);
   ops[19].op = EO_OP_OVERRIDE;
   ops[19].op_type = EO_OP_TYPE_REGULAR;
   ops[19].doc = NULL;

   ops[20].func = reinterpret_cast<void*>(& ::_evas_3d_node_orientation_set_wrapper<T>);
   ops[20].api_func = reinterpret_cast<void*>(& ::evas_3d_node_orientation_set);
   ops[20].op = EO_OP_OVERRIDE;
   ops[20].op_type = EO_OP_TYPE_REGULAR;
   ops[20].doc = NULL;

   ops[21].func = reinterpret_cast<void*>(& ::_evas_3d_node_orientation_angle_axis_set_wrapper<T>);
   ops[21].api_func = reinterpret_cast<void*>(& ::evas_3d_node_orientation_angle_axis_set);
   ops[21].op = EO_OP_OVERRIDE;
   ops[21].op_type = EO_OP_TYPE_REGULAR;
   ops[21].doc = NULL;

   ops[22].func = reinterpret_cast<void*>(& ::_evas_3d_node_scale_set_wrapper<T>);
   ops[22].api_func = reinterpret_cast<void*>(& ::evas_3d_node_scale_set);
   ops[22].op = EO_OP_OVERRIDE;
   ops[22].op_type = EO_OP_TYPE_REGULAR;
   ops[22].doc = NULL;

   ops[23].func = reinterpret_cast<void*>(& ::_evas_3d_node_position_get_wrapper<T>);
   ops[23].api_func = reinterpret_cast<void*>(& ::evas_3d_node_position_get);
   ops[23].op = EO_OP_OVERRIDE;
   ops[23].op_type = EO_OP_TYPE_REGULAR;
   ops[23].doc = NULL;

   ops[24].func = reinterpret_cast<void*>(& ::_evas_3d_node_orientation_get_wrapper<T>);
   ops[24].api_func = reinterpret_cast<void*>(& ::evas_3d_node_orientation_get);
   ops[24].op = EO_OP_OVERRIDE;
   ops[24].op_type = EO_OP_TYPE_REGULAR;
   ops[24].doc = NULL;

   ops[25].func = reinterpret_cast<void*>(& ::_evas_3d_node_scale_get_wrapper<T>);
   ops[25].api_func = reinterpret_cast<void*>(& ::evas_3d_node_scale_get);
   ops[25].op = EO_OP_OVERRIDE;
   ops[25].op_type = EO_OP_TYPE_REGULAR;
   ops[25].doc = NULL;

   ops[26].func = reinterpret_cast<void*>(& ::_evas_3d_node_look_at_set_wrapper<T>);
   ops[26].api_func = reinterpret_cast<void*>(& ::evas_3d_node_look_at_set);
   ops[26].op = EO_OP_OVERRIDE;
   ops[26].op_type = EO_OP_TYPE_REGULAR;
   ops[26].doc = NULL;

   ops[27].func = reinterpret_cast<void*>(& ::_evas_3d_node_mesh_add_wrapper<T>);
   ops[27].api_func = reinterpret_cast<void*>(& ::evas_3d_node_mesh_add);
   ops[27].op = EO_OP_OVERRIDE;
   ops[27].op_type = EO_OP_TYPE_REGULAR;
   ops[27].doc = NULL;

   ops[28].func = reinterpret_cast<void*>(& ::_evas_3d_node_mesh_del_wrapper<T>);
   ops[28].api_func = reinterpret_cast<void*>(& ::evas_3d_node_mesh_del);
   ops[28].op = EO_OP_OVERRIDE;
   ops[28].op_type = EO_OP_TYPE_REGULAR;
   ops[28].doc = NULL;

   ops[29].func = reinterpret_cast<void*>(& ::_evas_3d_node_mesh_list_get_wrapper<T>);
   ops[29].api_func = reinterpret_cast<void*>(& ::evas_3d_node_mesh_list_get);
   ops[29].op = EO_OP_OVERRIDE;
   ops[29].op_type = EO_OP_TYPE_REGULAR;
   ops[29].doc = NULL;

   ops[30].func = reinterpret_cast<void*>(& ::_evas_3d_node_bounding_box_get_wrapper<T>);
   ops[30].api_func = reinterpret_cast<void*>(& ::evas_3d_node_bounding_box_get);
   ops[30].op = EO_OP_OVERRIDE;
   ops[30].op_type = EO_OP_TYPE_REGULAR;
   ops[30].doc = NULL;

   ops[31].func = reinterpret_cast<void*>(& ::_evas_3d_node_obb_frustum_check_wrapper<T>);
   ops[31].api_func = reinterpret_cast<void*>(& ::evas_3d_node_obb_frustum_check);
   ops[31].op = EO_OP_OVERRIDE;
   ops[31].op_type = EO_OP_TYPE_REGULAR;
   ops[31].doc = NULL;

   return 0;
}
inline void
call_constructor(tag< ::evas_3d_node >
               , Eo* eo, Eo_Class const* cls EINA_UNUSED,
               args_class<::evas_3d_node, ::std::tuple<Evas_3D_Node_Type> > const& args)
{
   (void)args;
   eo_do_super(eo, cls, ::evas_3d_node_constructor(::efl::eolian::to_c(args.get<0>())));
}

inline void
call_constructor(tag< ::evas_3d_node >
               , Eo* eo, Eo_Class const* cls EINA_UNUSED,
               args_class<::evas_3d_node, ::std::tuple<efl::eo::parent_type> > const& args)
{
   eo_do_super(eo, cls, ::eo_constructor());
   eo_do(eo, ::eo_parent_set(args.get<0>()._eo_raw));
}

template<>
struct extension_inheritance< ::evas_3d_node>
{
   template <typename U>
   struct type
   {
      operator ::evas_3d_node() const
      {
         return ::evas_3d_node(eo_ref(static_cast<U const*>(this)->_eo_ptr()));
      }

      void update_notify()
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_object_update_notify());
      }

      void change_notify(Evas_3D_State state_, Evas_3D_Object * ref_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_object_change_notify(state_, ref_));
      }

      bool position_inherit_get()
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_3d_node_position_inherit_get());
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void position_inherit_set(bool inherit_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_node_position_inherit_set(efl::eolian::to_c(inherit_)));
      }

      bool orientation_inherit_get()
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_3d_node_orientation_inherit_get());
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void orientation_inherit_set(bool inherit_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_node_orientation_inherit_set(efl::eolian::to_c(inherit_)));
      }

      bool scale_inherit_get()
      {
         Eina_Bool _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_3d_node_scale_inherit_get());
            return efl::eolian::to_cxx<bool>(_tmp_ret, std::tuple<std::false_type>());
      }

      void scale_inherit_set(bool inherit_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_node_scale_inherit_set(efl::eolian::to_c(inherit_)));
      }

      Evas_3D_Camera * camera_get()
      {
         Evas_3D_Camera * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_3d_node_camera_get());
            return _tmp_ret;
      }

      void camera_set(Evas_3D_Camera * camera_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_node_camera_set(camera_));
      }

      Evas_3D_Light * light_get()
      {
         Evas_3D_Light * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_3d_node_light_get());
            return _tmp_ret;
      }

      void light_set(Evas_3D_Light * light_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_node_light_set(light_));
      }

      int mesh_frame_get(Evas_3D_Mesh * mesh_)
      {
         int _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_3d_node_mesh_frame_get(mesh_));
            return _tmp_ret;
      }

      void mesh_frame_set(Evas_3D_Mesh * mesh_, int frame_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_node_mesh_frame_set(mesh_, frame_));
      }

      Evas_3D_Node_Type type_get()
      {
         Evas_3D_Node_Type _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_3d_node_type_get());
            return _tmp_ret;
      }

      void member_add(Evas_3D_Node * member_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_node_member_add(member_));
      }

      void member_del(Evas_3D_Node * member_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_node_member_del(member_));
      }

      Evas_3D_Node * parent_get()
      {
         Evas_3D_Node * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_3d_node_parent_get());
            return _tmp_ret;
      }

      efl::eina::crange_list< Evas_3D_Node * > member_list_get()
      {
         const Eina_List * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_3d_node_member_list_get());
            return efl::eolian::to_cxx<efl::eina::crange_list< Evas_3D_Node * >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      void position_set(Evas_Real x_, Evas_Real y_, Evas_Real z_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_node_position_set(x_, y_, z_));
      }

      void orientation_set(Evas_Real x_, Evas_Real y_, Evas_Real z_, Evas_Real w_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_node_orientation_set(x_, y_, z_, w_));
      }

      void orientation_angle_axis_set(Evas_Real angle_, Evas_Real x_, Evas_Real y_, Evas_Real z_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_node_orientation_angle_axis_set(angle_, x_, y_, z_));
      }

      void scale_set(Evas_Real x_, Evas_Real y_, Evas_Real z_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_node_scale_set(x_, y_, z_));
      }

      void position_get(Evas_3D_Space space_, Evas_Real* x_, Evas_Real* y_, Evas_Real* z_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_node_position_get(space_, x_, y_, z_));
      }

      void orientation_get(Evas_3D_Space space_, Evas_Real* x_, Evas_Real* y_, Evas_Real* z_, Evas_Real* w_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_node_orientation_get(space_, x_, y_, z_, w_));
      }

      void scale_get(Evas_3D_Space space_, Evas_Real* x_, Evas_Real* y_, Evas_Real* z_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_node_scale_get(space_, x_, y_, z_));
      }

      void look_at_set(Evas_3D_Space target_space_, Evas_Real x_, Evas_Real y_, Evas_Real z_, Evas_3D_Space up_space_, Evas_Real ux_, Evas_Real uy_, Evas_Real uz_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_node_look_at_set(target_space_, x_, y_, z_, up_space_, ux_, uy_, uz_));
      }

      void mesh_add(Evas_3D_Mesh * mesh_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_node_mesh_add(mesh_));
      }

      void mesh_del(Evas_3D_Mesh * mesh_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_node_mesh_del(mesh_));
      }

      efl::eina::crange_list< Evas_3D_Mesh * > mesh_list_get()
      {
         const Eina_List * _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_3d_node_mesh_list_get());
            return efl::eolian::to_cxx<efl::eina::crange_list< Evas_3D_Mesh * >>(_tmp_ret, std::tuple<std::false_type, std::false_type>());
      }

      void bounding_box_get(Evas_Real * x_, Evas_Real * y_, Evas_Real * z_, Evas_Real * x2_, Evas_Real * y2_, Evas_Real * z2_)
      {
         eo_do(static_cast<U*>(this)->_eo_ptr(), ::evas_3d_node_bounding_box_get(x_, y_, z_, x2_, y2_, z2_));
      }

      int obb_frustum_check(Evas_3D_Node * camera_node_)
      {
         int _tmp_ret = {};
         eo_do(static_cast<U*>(this)->_eo_ptr(), _tmp_ret = ::evas_3d_node_obb_frustum_check(camera_node_));
            return _tmp_ret;
      }

   };
};

inline Eo_Class const* get_eo_class(tag<::evas_3d_node>)
{
   return (EVAS_3D_NODE_CLASS);
}

} } }
#endif // EFL_GENERATED_EVAS_3D_NODE_HH

