class Evas.Canvas3D.Node (Evas.Canvas3D.Object, Evas.Common_Interface)
{
   legacy_prefix: null;
   data: Evas_Canvas3D_Node_Data;
   methods {
      constructor {
         [[Constructor.]]
         legacy: null;
         params {
            @in type: Evas.Canvas3D.Node_Type;
         }
      }
      type_get @const {
         [[Get the type of the given node.

           See also @Evas.Canvas3D.Node.member_add.]]
         return: Evas.Canvas3D.Node_Type ; [[The type of the given node.]]
      }
      member_add {
         [[Add a member node to the given node.

           Nodes can be constructed into N-ary tree structure like other ordinary scene
           graph. Basically a node inherit transforms from its parent.

           See also @Evas.Canvas3D.Node.parent_get.]]

         params {
            @in member: Evas.Canvas3D.Node *;  [[Node object to be added.]]
         }
      }
      member_del {
         [[Delete a member node from the given node.

           See also @Evas.Canvas3D.Node.member_add.]]
         params {
            @in member: Evas.Canvas3D.Node *;  [[Member node to be deleted from the given node.]]
         }
      }

      parent_get @const {
         [[Get the parent node of the given node.

           See also @Evas.Canvas3D.Node.member_add.]]
         return: Evas.Canvas3D.Node *; [[The parent node of the given node.]]
      }

      member_list_get @const {
         [[Get the list of member nodes of the given node.

           See also @Evas.Canvas3D.Node.member_add.]]
         return: const(list<Evas.Canvas3D.Node *>)*; [[The list of member nodes if any or $null if there are none.]]
      }
      position_set {
         [[Set the position of the given node.

           According to the inheritance flag, (x, y, z) can be a world space position or
           parent space position.

           Default position is (0.0, 0.0, 0.0).

           See also @Evas.Canvas3D.Node.position_inherit.set.]]
         params {
            @in x: Evas_Real;  [[X coordinate of the position.]]
            @in y: Evas_Real;  [[Y coordinate of the position.]]
            @in z: Evas_Real;  [[Z coordinate of the position.]]
         }
      }
      orientation_set {
         [[Set the orientation of the given node using quaternion.

           According the the inheritance flag, (w, x, y, z) can be a world space
           orientation or parent space orientation.

           Default orientation is (1.0, 0.0, 0.0, 0.0) (identity quaternion).

           See also @Evas.Canvas3D.Node.orientation_inherit.set.]]
         params {
            @in x: Evas_Real;  [[X term of the orientation quaternion (w, x, y, z.]]
            @in y: Evas_Real;  [[Y term of the orientation quaternion (w, x, y, z.]]
            @in z: Evas_Real;  [[Z term of the orientation quaternion (w, x, y, z.]]
            @in w: Evas_Real;  [[W term of the orientation quaternion (w, x, y, z.]]
         }
      }

      orientation_angle_axis_set {
         [[Set the orientation of the given node using axis-angle.

           See also @Evas.Canvas3D.Node.orientation_set.]]
         params {
            @in angle: Evas_Real;  [[Rotation angle.]]
            @in x: Evas_Real;      [[X term of the rotation axis.]]
            @in y: Evas_Real;      [[Y term of the rotation axis.]]
            @in z: Evas_Real;      [[Z term of the rotation axis.]]
         }
      }

      scale_set {
         [[Set the scale of the given node.

           According to the inheritance flag, (x, y, z) can be a world space scale or
           parent space scale. Be careful when using non-uniform scale factor with
           inheritance, each transform attributes are not affected by other attributes.

           Default scale is (1.0, 1.0, 1.0).

           See also @Evas.Canvas3D.Node.scale_inherit.set.]]
         params {
            @in x: Evas_Real;      [[Scale factor along X-axis.]]
            @in y: Evas_Real;      [[Scale factor along Y-axis.]]
            @in z: Evas_Real;      [[Scale factor along Z-axis.]]
         }
      }

      position_get @const {
         [[Get the position of the given node.

           See also @Evas.Canvas3D.Node.position_set.]]
         params {
            @in space: Evas.Canvas3D.Space; [[The given node.]]
            @out x: Evas_Real;              [[Pointer to receive X coordinate of the position.]]
            @out y: Evas_Real;              [[Pointer to receive Y coordinate of the position.]]
            @out z: Evas_Real;              [[Pointer to receive Z coordinate of the position.]]
         }
      }

      orientation_get @const {
         [[Get the orientation of the given node as quaternion.

           See also @Evas.Canvas3D.Node.orientation_set.]]
         params {
            @in space: Evas.Canvas3D.Space; [[The given node.]]
            @out x: Evas_Real;              [[Pointer to receive X term of the orientation quaternion.]]
            @out y: Evas_Real;              [[Pointer to receive Y term of the orientation quaternion.]]
            @out z: Evas_Real;              [[Pointer to receive Z term of the orientation quaternion.]]
            @out w: Evas_Real;              [[Pointer to receive W term of the orientation quaternion.]]
         }
      }

      scale_get @const {
         [[Get the scale of the given node.

           See also @Evas.Canvas3D.Node.scale_get.]]
         params {
            @in space: Evas.Canvas3D.Space; [[The given node.]]
            @out x: Evas_Real;              [[Pointer to receive Scale factor along X-axis.]]
            @out y: Evas_Real;              [[Pointer to receive Scale factor along X-axis.]]
            @out z: Evas_Real;              [[Pointer to receive Scale factor along X-axis.]]
         }
      }

      look_at_set {
         [[Rotate the given node to look at desired position.

           This function rotate the given node so that its forward vector (negative
           Z-axis) points to the desired position and the up vector coincide with the
           given up vector.

           See also @Evas.Canvas3D.Node.orientation_set.]]
         params {
            @in target_space: Evas.Canvas3D.Space;  [[Space where the target position belongs to.]]
            @in x: Evas_Real;                       [[X coordinate of the target position.]]
            @in y: Evas_Real;                       [[Y coordinate of the target position.]]
            @in z: Evas_Real;                       [[Z coordinate of the target position.]]
            @in up_space: Evas.Canvas3D.Space;      [[Space where the up vector belongs to.]]
            @in ux: Evas_Real;                      [[X term of the up vector.]]
            @in uy: Evas_Real;                      [[Y term of the up vector.]]
            @in uz: Evas_Real;                      [[Z term of the up vector.]]
         }
      }

      mesh_add {
         [[Add a mesh to the given node.

           If the node is not of type EVAS_CANVAS3D_NODE_TYPE_MESH, error message will be
           generated and nothing happens.

           See also @Evas.Canvas3D.Node.member_add.]]
         params {
            @in mesh: Evas.Canvas3D.Mesh *;      [[The mesh to be added.]]
         }
      }

      mesh_del {
         [[Delete a mesh from the given node.

           If the node is not of type EVAS_CANVAS3D_NODE_TYPE_MESH or the given mesh does not
           belong to the given node, error message will be gnerated and nothing happens.

           See also @Evas.Canvas3D.Node.mesh_add.]]
         params {
            @in mesh: Evas.Canvas3D.Mesh *;      [[The mesh to be deleted.]]
         }
      }

      mesh_list_get @const {
         [[Get the list of meshes of the given node.

           If the node is not of type EVAS_CANVAS3D_NODE_TYPE_MESH, error message will be
           generated and $null will be returned. If there're no meshes in the given
           node, $null will be returned.

           See also @Evas.Canvas3D.Node.mesh_add.]]
         return: const(list<Evas.Canvas3D.Mesh *>)*; [[The list of meshes if any, or $null if there're none.]]
      }

      bounding_box_get{
         [[Get axis-aligned bounding box (AABB) of the given node.]]
         params {
            @in x: Evas_Real *; [[Pointer to receive X coordinate of the first point of AABB.]]
            @in y: Evas_Real *; [[Pointer to receive Y coordinate of the first point of AABB.]]
            @in z: Evas_Real *; [[Pointer to receive Z coordinate of the first point of AABB.]]
            @in x2: Evas_Real *; [[Pointer to receive X coordinate of the second point of AABB.]]
            @in y2: Evas_Real *; [[Pointer to receive Y coordinate of the second point of AABB.]]
            @in z2: Evas_Real *; [[Pointer to receive Z coordinate of the second point of AABB.]]
         }
      }

      bounding_sphere_get {
         [[Get bounding sphere of the given node.]]
         params {

            @in x: Evas_Real *; [[Pointer to receive X coordinate of the center of sphere.]]
            @in y: Evas_Real *; [[Pointer to receive Y coordinate of the center of sphere.]]
            @in z: Evas_Real *; [[Pointer to receive Z coordinate of center of sphere.]]
            @in r: Evas_Real *; [[Pointer to receive radius of center of sphere.]]
         }
      }

      @property position_inherit {
         set {
            [[Set the position inheritance flag of the given node.

              When inheritance is enabled, a node's world space position is determined by
              adding the parent node's world position and the node's position, otherwise,
              the node's position will be the world space position.]]
         }
         get {
            [[Get the position inheritance flag of the given node.

              See also @Evas.Canvas3D.Node.position_inherit.set.]]
         }
         values {
            inherit: bool; [[Whether to inherit parent position.]]
         }
      }

      @property orientation_inherit {
         set {
            [[Set the orientation inheritance flag of the given node.

              When inheritance is enabled, a node's world space orientation is determined
              by multiplying the parent node's world orientation and the node's
              orientation, otherwise, the node's orientation will be the world space
              orientation.]]
         }
         get {
            [[Get the orientation inheritance flag of the given node.

              See also @Evas.Canvas3D.Node.orientation_inherit.set.]]
         }
         values {
            inherit: bool; [[Whether to inherit parent orientation.]]
         }
      }

      @property scale_inherit {
         set {
            [[Set the scale inheritance flag of the given node.

              When inheritance is enabled, a node's world space scale is determined by
              multiplying the parent node's world scale and the node's scale, otherwise,
              the node's scale will be the world space scale.]]
         }
         get {
            [[Get the scale inheritance flag of the given node.

              See also @Evas.Canvas3D.Node.scale_inherit.set.]]
         }
         values {
            inherit: bool; [[Whether to inherit parent scale.]]
         }
      }

      @property camera {
         set {
            [[Set a camera to the given node.

              If the node is not of type EVAS_CANVAS3D_NODE_TYPE_CAMERA, error message will be
              generated and nothing happens.

              See also @Evas.Canvas3D.Node.member_add.]]
         }
         get {
            [[Get the camera of the given node.

              See also @Evas.Canvas3D.Node.camera.set.]]
         }
         values {
            // FIXME: Evas_Canvas3D_Camera is necessary, but that introduces a cycle
            camera: Evas.Canvas3D.Object *; [[The camera of the given node if any, or $null if there're none.]]
         }
      }

      @property light {
         set {
            [[Set the light of the given node.

              If the node is not of type EVAS_CANVAS3D_NODE_TYPE_LIGHT, error message will be
              generated and nothing happens.

              See also @Evas.Canvas3D.Node.member_add.]]
         }
         get {
            [[Get the light of the given node.

              See also @Evas.Canvas3D.Node.light.set.]]
         }
         values {
            light: Evas.Canvas3D.Light *; [[The light of the given node if any, or $null if there're none.]]
         }
      }

      @property mesh_frame {
         set {
            [[Set the animation frame number of the given node for the given mesh.

              If the node is not of type EVAS_CANVAS3D_NODE_TYPE_MESH or the given mesh does not
              belong to the given mesh error mesh will be generated and nothing happens.

              Default mesh frame is 0.

              See also @Evas.Canvas3D.Node.mesh_add.]]
         }
         get {
            [[Set the animation frame number of the given node for the given mesh.

              If the node is not of type EVAS_CANVAS3D_NODE_TYPE_MESH or the given mesh does not
              belong to the given mesh error mesh will be generated and nothing happens.

              See also @Evas.Canvas3D.Node.mesh_add.]]
         }
         keys {
            mesh: Evas.Canvas3D.Mesh *; [[The given mesh.]]
         }
         values {
            frame: int; [[The animation frame number.]]
         }
      }

      @property billboard_target {
         set {
            [[Set behavior of node like billboard object.]]
         }
         get {
            [[Get the target node for billboard object.

              See also @Evas.Canvas3D.Node.billboard_target.set.]]
         }
         values {
            target: Evas.Canvas3D.Node *; [[The pointer to target node for billboard object,
                                            or $null if there're none.]]
         }
      }
   }
   implements {
      Eo.Base.destructor;
      Evas.Canvas3D.Object.update_notify;
      Evas.Canvas3D.Object.change_notify;
      Evas.Canvas3D.Object.callback_register;
      Evas.Canvas3D.Object.callback_unregister;
   }
   constructors {
      .constructor;
   }
}
