aboutsummaryrefslogblamecommitdiffstats
path: root/src/lib/evas/canvas/evas_canvas3d_node.eo
blob: 0c19fe910753f26fea183cdbdd5d8ad1fae28291 (plain) (tree)
1
2
3
4
5
6
7
8
9
                           
 
                                               
 
                                
                                 
            
                   
                         
                      
                 
                                                            

          
                       
                                          
 

                                                                          

                  
                                               



                                                                                       
                                                     

                 
                                                                         


                  
                                                    
 
                                                     
                 
                                                                                               


          
                         
                                                 
 
                                                     
                                                                           

       
                              
                                                          
 
                                                     
                                                                                                                 
       


                                                              
                                                                                                                               
       
                    
                                              





                                                                                        
                                                               
                 


                                                                


                       
                                                                  





                                                                                
                                                                  
                 



                                                                                    



                                  
                                                                  
 
                                                          
                 



                                                                   



                 
                                           






                                                                                       
                                                            
                 


                                                                 


          
                           
                                              
 
                                                       
                 
                                                               


                                                                                                


          
                              
                                                               
 
                                                          
                 
                                                               



                                                                                                        


          
                        
                                           
 
                                                    
                 
                                                               


                                                                                             



                   
                                                             




                                                                                     
                                                          
                 
                                                                                                   


                                                                                            
                                                                                             


                                                                                



                
                                        
 
                                                                                         

                                         
                                                     
                 
                                                                        



                
                                             
 
                                                                                             

                                                                                        
                                                   
                 
                                                                          


          
                            
                                                    
 
                                                                                         

                                                                                   
 
                                                   
                                                                                                           

       
                       
                                                                    
                 





                                                                                                    

          
 
                           
                                                   
                 
 



                                                                                               

          
 
                                  
              
                                                                  


                                                                                         
                                                                     

              
                                                                  
 
                                                                  

                 
                                                                  


          
                                     
              
                                                                     



                                                                                         
                            

              
                                                                     
 
                                                                     

                 
                                                                     


          
                               
              
                                                               


                                                                                        
                                                               

              
                                                               
 
                                                               

                 
                                                               


          
                        
              
                                             
 
                                                                                              

                                            
                                                        

              
                                               
 
                                                        

                 
                                                                                    
                                                                                                             


          
                       
              
                                              
 
                                                                                             

                                            
                                                        

              
                                              
 
                                                       

                 
                                                                                                          


          
                            
              
                                                                                  
 
                                                                                                



                                                                                        
                                                      

              
                                                                                  
 
                                                                                                

                                                                                        
                                                      

               
                                                         

                 
                                                       

          
 
                                  
              
                                                           

              
                                                       
 
                                                                  

                 

                                                                                          

          












                                                                

               
                            



                                               
    


                   
 
import evas_canvas3d_types;

class Evas.Canvas3D.Node (Evas.Canvas3D.Object)
{
   [[Evas 3D canvas node class]]
   data: Evas_Canvas3D_Node_Data;
   methods {
      constructor {
         [[Constructor.]]
         legacy: null;
         params {
            @in type: Evas.Canvas3D.Node_Type; [[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.]]
      }
      scene_root_get {
         [[Get hash table of scenes using this node as root.]]

         return: hash<Evas.Canvas3D.Object, uintptr>; [[ scenes using this node as root. FIXME: Actually a scene, not object.]]
      }
      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: ptr(Evas.Real); [[Pointer to receive X coordinate of the first point of AABB.]]
            @in y: ptr(Evas.Real); [[Pointer to receive Y coordinate of the first point of AABB.]]
            @in z: ptr(Evas.Real); [[Pointer to receive Z coordinate of the first point of AABB.]]
            @in x2: ptr(Evas.Real); [[Pointer to receive X coordinate of the second point of AABB.]]
            @in y2: ptr(Evas.Real); [[Pointer to receive Y coordinate of the second point of AABB.]]
            @in z2: ptr(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: ptr(Evas.Real); [[Pointer to receive X coordinate of the center of sphere.]]
            @in y: ptr(Evas.Real); [[Pointer to receive Y coordinate of the center of sphere.]]
            @in z: ptr(Evas.Real); [[Pointer to receive Z coordinate of center of sphere.]]
            @in r: ptr(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.]]
         }
      }
      @property lod_enable {
         set {
            [[Enable behavior of node like LOD object.]]
         }
         get {
            [[Get(check) status of node does node is LOD object.

              See also @Evas.Canvas3D.Node.lod_enable.set.]]
         }
         values {
            enable: bool; [[status property (true/false)]]
         }
      }
   }
   implements {
      Efl.Object.destructor;
      Evas.Canvas3D.Object.update_notify;
      Evas.Canvas3D.Object.change_notify;
      Evas.Canvas3D.Object.callback_register;
      Evas.Canvas3D.Object.callback_unregister;
   }
   constructors {
      .constructor;
   }
}