summaryrefslogtreecommitdiff
path: root/src/lib/evas/canvas/evas_canvas3d_node.eo
blob: 2ffcbac3dc80452e7c483481c4445c4f7e843d90 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
import evas_types;

class Evas.Canvas3D.Node (Evas.Canvas3D.Object)
{
   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.]]
      }
      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: 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.]]
         }
      }
      @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 {
      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;
   }
}