2013-06-26 23:27:30 -07:00
|
|
|
#ifndef _EVAS_H
|
|
|
|
|
# error You shall not include this header directly
|
|
|
|
|
#endif
|
2013-04-24 12:56:24 -07:00
|
|
|
|
2018-02-26 11:47:57 -08:00
|
|
|
#ifndef _EFL_CANVAS_VG_NODE_EO_CLASS_TYPE
|
|
|
|
|
#define _EFL_CANVAS_VG_NODE_EO_CLASS_TYPE
|
|
|
|
|
|
2018-04-04 04:38:34 -07:00
|
|
|
typedef Eo Efl_Canvas_Vg_Node;
|
2018-02-26 11:47:57 -08:00
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef _EFL_CANVAS_ANIMATION_EO_CLASS_TYPE
|
|
|
|
|
#define _EFL_CANVAS_ANIMATION_EO_CLASS_TYPE
|
|
|
|
|
|
|
|
|
|
typedef Eo Efl_Canvas_Animation;
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef _EFL_CANVAS_ANIMATION_ALPHA_EO_CLASS_TYPE
|
|
|
|
|
#define _EFL_CANVAS_ANIMATION_ALPHA_EO_CLASS_TYPE
|
|
|
|
|
|
|
|
|
|
typedef Eo Efl_Canvas_Animation_Alpha;
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef _EFL_CANVAS_ANIMATION_ROTATE_EO_CLASS_TYPE
|
|
|
|
|
#define _EFL_CANVAS_ANIMATION_ROTATE_EO_CLASS_TYPE
|
|
|
|
|
|
|
|
|
|
typedef Eo Efl_Canvas_Animation_Rotate;
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef _EFL_CANVAS_ANIMATION_SCALE_EO_CLASS_TYPE
|
|
|
|
|
#define _EFL_CANVAS_ANIMATION_SCALE_EO_CLASS_TYPE
|
|
|
|
|
|
|
|
|
|
typedef Eo Efl_Canvas_Animation_Scale;
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef _EFL_CANVAS_ANIMATION_TRANSLATE_EO_CLASS_TYPE
|
|
|
|
|
#define _EFL_CANVAS_ANIMATION_TRANSLATE_EO_CLASS_TYPE
|
|
|
|
|
|
|
|
|
|
typedef Eo Efl_Canvas_Animation_Translate;
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef _EFL_CANVAS_ANIMATION_GROUP_EO_CLASS_TYPE
|
|
|
|
|
#define _EFL_CANVAS_ANIMATION_GROUP_EO_CLASS_TYPE
|
|
|
|
|
|
|
|
|
|
typedef Eo Efl_Canvas_Animation_Group;
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef _EFL_CANVAS_ANIMATION_GROUP_PARALLEL_EO_CLASS_TYPE
|
|
|
|
|
#define _EFL_CANVAS_ANIMATION_GROUP_PARALLEL_EO_CLASS_TYPE
|
|
|
|
|
|
|
|
|
|
typedef Eo Efl_Canvas_Animation_Group_Parallel;
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef _EFL_CANVAS_ANIMATION_GROUP_SEQUENTIAL_EO_CLASS_TYPE
|
|
|
|
|
#define _EFL_CANVAS_ANIMATION_GROUP_SEQUENTIAL_EO_CLASS_TYPE
|
|
|
|
|
|
|
|
|
|
typedef Eo Efl_Canvas_Animation_Group_Sequential;
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef _EFL_CANVAS_ANIMATION_PLAYER_EO_CLASS_TYPE
|
|
|
|
|
#define _EFL_CANVAS_ANIMATION_PLAYER_EO_CLASS_TYPE
|
|
|
|
|
|
|
|
|
|
typedef Eo Efl_Canvas_Animation_Player;
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef _EFL_CANVAS_ANIMATION_PLAYER_ALPHA_EO_CLASS_TYPE
|
|
|
|
|
#define _EFL_CANVAS_ANIMATION_PLAYER_ALPHA_EO_CLASS_TYPE
|
|
|
|
|
|
|
|
|
|
typedef Eo Efl_Canvas_Animation_Player_Alpha;
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef _EFL_CANVAS_ANIMATION_PLAYER_ROTATE_EO_CLASS_TYPE
|
|
|
|
|
#define _EFL_CANVAS_ANIMATION_PLAYER_ROTATE_EO_CLASS_TYPE
|
|
|
|
|
|
|
|
|
|
typedef Eo Efl_Canvas_Animation_Player_Rotate;
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef _EFL_CANVAS_ANIMATION_PLAYER_SCALE_EO_CLASS_TYPE
|
|
|
|
|
#define _EFL_CANVAS_ANIMATION_PLAYER_SCALE_EO_CLASS_TYPE
|
|
|
|
|
|
|
|
|
|
typedef Eo Efl_Canvas_Animation_Player_Scale;
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef _EFL_CANVAS_ANIMATION_PLAYER_TRANSLATE_EO_CLASS_TYPE
|
|
|
|
|
#define _EFL_CANVAS_ANIMATION_PLAYER_TRANSLATE_EO_CLASS_TYPE
|
|
|
|
|
|
|
|
|
|
typedef Eo Efl_Canvas_Animation_Player_Translate;
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef _EFL_CANVAS_ANIMATION_PLAYER_GROUP_EO_CLASS_TYPE
|
|
|
|
|
#define _EFL_CANVAS_ANIMATION_PLAYER_GROUP_EO_CLASS_TYPE
|
|
|
|
|
|
|
|
|
|
typedef Eo Efl_Canvas_Animation_Player_Group;
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef _EFL_CANVAS_ANIMATION_GROUP_PARALLEL_EO_CLASS_TYPE
|
|
|
|
|
#define _EFL_CANVAS_ANIMATION_GROUP_PARALLEL_EO_CLASS_TYPE
|
|
|
|
|
|
|
|
|
|
typedef Eo Efl_Canvas_Animation_Group_Parallel;
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef _EFL_CANVAS_ANIMATION_GROUP_SEQUENTIAL_EO_CLASS_TYPE
|
|
|
|
|
#define _EFL_CANVAS_ANIMATION_GROUP_SEQUENTIAL_EO_CLASS_TYPE
|
|
|
|
|
|
|
|
|
|
typedef Eo Efl_Canvas_Animation_Group_Sequential;
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
2018-04-10 06:24:28 -07:00
|
|
|
struct _Efl_Canvas_Animation_Player_Event_Running
|
2018-02-26 11:47:57 -08:00
|
|
|
{
|
|
|
|
|
double progress;
|
|
|
|
|
};
|
|
|
|
|
|
2018-04-30 08:20:03 -07:00
|
|
|
struct _Efl_Canvas_Object_Animation_Event
|
2018-04-10 06:09:39 -07:00
|
|
|
{
|
2018-04-30 08:07:27 -07:00
|
|
|
const Efl_Event_Description *event_desc;
|
2018-04-30 08:20:03 -07:00
|
|
|
};
|
2018-04-10 06:09:39 -07:00
|
|
|
|
2013-04-24 12:56:24 -07:00
|
|
|
/**
|
2014-03-30 04:08:46 -07:00
|
|
|
* @ingroup Evas_Object_Rectangle
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
|
|
|
|
* @{
|
|
|
|
|
*/
|
2016-06-02 02:55:51 -07:00
|
|
|
#include "canvas/efl_canvas_rectangle.eo.h"
|
2013-04-24 12:56:24 -07:00
|
|
|
/**
|
|
|
|
|
* @}
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
2019-12-10 00:39:59 -08:00
|
|
|
* @ingroup Efl_Canvas_Textblock
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-03-30 04:08:46 -07:00
|
|
|
* @{
|
2013-04-24 12:56:24 -07:00
|
|
|
*/
|
Efl.Text.Cursor
Summary:
Implementation of new cursor text object.
This Patch Contains :
1- Remove Efl.Text.Cursor & Efl.Text_Markup_Interactive interfaces and replace them with one Class Efl.Text.Cursor
=> there are some modifications on cursor methods
2- Update all related classes to use Efl.Text.Cursor object instead of the old interfaces
3- If class uses Efl.Text_Cursor_Cursor (handle), mainly annotation it will stay as it is until we update other annotations into attribute_factory
4- Add main cursor property into efl.text.interactive
5- Add cursor_new method in efl.ui.text (I think we may move it into efl.text.interactive interface)
There still some parts that need discussion: especially cursor movement functionality, I prefer to move function with Enum, instead of special function for each movement.
```
enum @beta Efl.Text.Cursor_Move_Type
{
[[Text cursor movement types]]
char_next, [[Advances to the next character]]
char_prev, [[Advances to the previous character]]
cluster_next, [[Advances to the next grapheme cluster]]
cluster_prev, [[Advances to the previous grapheme cluster]]
paragraph_start, [[Advances to the first character in this paragraph]]
paragraph_end, [[Advances to the last character in this paragraph]]
word_start, [[Advance to current word start]]
word_end, [[Advance to current word end]]
line_start, [[Advance to current line first character]]
line_end, [[Advance to current line last character]]
paragraph_first, [[Advance to current paragraph first character]]
paragraph_last, [[Advance to current paragraph last character]]
paragraph_next, [[Advances to the start of the next text node]]
paragraph_prev [[Advances to the end of the previous text node]]
}
move {
[[Move the cursor]]
params {
@in type: Efl.Text.Cursor_Move_Type; [[The type of movement]]
}
return: bool; [[True if actually moved]]
}
```
or old way:
```
char_next {
[[Advances to the next character]]
// FIXME: Make the number of characters we moved by? Useful for all the other functions
return: bool; [[True if actually moved]]
}
char_prev {
[[Advances to the previous character]]
return: bool; [[True if actually moved]]
}
char_delete {
[[Deletes a single character from position pointed by given cursor.]]
}
cluster_next {
[[Advances to the next grapheme cluster]]
return: bool; [[True if actually moved]]
}
cluster_prev {
[[Advances to the previous grapheme cluster]]
return: bool; [[True if actually moved]]
}
// FIXME: paragraph_end is inconsistent with word_end. The one goes to the last character and the other after the last character.
paragraph_start {
[[Advances to the first character in this paragraph]]
return: bool; [[True if actually moved]]
}
paragraph_end {
[[Advances to the last character in this paragraph]]
return: bool; [[True if actually moved]]
}
word_start {
[[Advance to current word start]]
return: bool; [[True if actually moved]]
}
word_end {
[[Advance to current word end]]
return: bool; [[True if actually moved]]
}
line_start {
[[Advance to current line first character]]
return: bool; [[True if actually moved]]
}
line_end {
[[Advance to current line last character]]
return: bool; [[True if actually moved]]
}
paragraph_first {
[[Advance to current paragraph first character]]
return: bool; [[True if actually moved]]
}
paragraph_last {
[[Advance to current paragraph last character]]
return: bool; [[True if actually moved]]
}
paragraph_next {
[[Advances to the start of the next text node]]
return: bool; [[True if actually moved]]
}
paragraph_prev {
[[Advances to the end of the previous text node]]
return: bool; [[True if actually moved]]
}
```
Reviewers: woohyun, tasn, segfaultxavi
Reviewed By: woohyun
Subscribers: a.srour, bu5hm4n, segfaultxavi, cedric, #reviewers, #committers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D10542
2019-11-22 00:35:54 -08:00
|
|
|
#include "canvas/efl_text_cursor.eo.h"
|
Efl.Text.Attribute_Factory
Summary:
Implementation of new Efl.Text.Attribute_Factory class which replace the annotation interface.
Currently, we have two public methods:
```
void efl_text_attribute_factory_attribute_insert(const Efl_Text_Cursor *start, const Efl_Text_Cursor *end, const char *format)
unsigned int efl_text_attribute_factory_attribute_clear(const Efl_Text_Cursor *start, const Efl_Text_Cursor *end);
```
Other methods will be internal methods, for the time being, we will redesign internal methods
Reviewers: woohyun, tasn, segfaultxavi, bu5hm4n, zmike
Subscribers: zmike, q66, cedric, segfaultxavi, bu5hm4n, a.srour, #committers, #reviewers
Tags: #efl
Differential Revision: https://phab.enlightenment.org/D10646
2019-11-26 20:04:31 -08:00
|
|
|
#include "canvas/efl_text_attribute_factory.eo.h"
|
2019-12-10 00:39:59 -08:00
|
|
|
#include "canvas/efl_canvas_textblock.eo.h"
|
|
|
|
|
#include "canvas/efl_canvas_textblock_factory.eo.h"
|
2013-04-24 12:56:24 -07:00
|
|
|
/**
|
|
|
|
|
* @}
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
2014-03-30 04:08:46 -07:00
|
|
|
* @ingroup Evas_Object_Polygon
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-03-30 04:08:46 -07:00
|
|
|
* @{
|
2013-04-24 12:56:24 -07:00
|
|
|
*/
|
2016-03-14 14:59:33 -07:00
|
|
|
#include "canvas/efl_canvas_polygon.eo.h"
|
2013-04-24 12:56:24 -07:00
|
|
|
/**
|
2014-03-30 04:08:46 -07:00
|
|
|
* @}
|
2013-04-24 12:56:24 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
2014-03-30 04:08:46 -07:00
|
|
|
* @ingroup Evas_Smart_Object_Group
|
2013-04-24 12:56:24 -07:00
|
|
|
*
|
2014-03-30 04:08:46 -07:00
|
|
|
* @{
|
2013-04-24 12:56:24 -07:00
|
|
|
*/
|
2016-06-17 01:26:08 -07:00
|
|
|
#include "canvas/efl_canvas_group.eo.h"
|
2013-04-24 12:56:24 -07:00
|
|
|
/**
|
2014-03-30 04:08:46 -07:00
|
|
|
* @}
|
2013-04-24 12:56:24 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
2014-03-30 04:08:46 -07:00
|
|
|
* @}
|
2013-04-24 12:56:24 -07:00
|
|
|
*/
|
|
|
|
|
|
2019-10-31 10:20:33 -07:00
|
|
|
/* Input events */
|
2019-10-31 12:43:16 -07:00
|
|
|
#include "canvas/efl_input_types.eot.h"
|
2019-10-31 10:20:33 -07:00
|
|
|
#include "canvas/efl_input_device.eo.h"
|
|
|
|
|
#include "canvas/efl_canvas_pointer.eo.h"
|
|
|
|
|
#include "canvas/efl_canvas_scene.eo.h"
|
|
|
|
|
#include "canvas/efl_input_state.eo.h"
|
|
|
|
|
#include "canvas/efl_input_event.eo.h"
|
|
|
|
|
#include "canvas/efl_input_pointer.eo.h"
|
|
|
|
|
#include "canvas/efl_input_key.eo.h"
|
|
|
|
|
#include "canvas/efl_input_hold.eo.h"
|
|
|
|
|
#include "canvas/efl_input_interface.eo.h"
|
|
|
|
|
#include "canvas/efl_input_focus.eo.h"
|
|
|
|
|
#include "canvas/efl_input_clickable.eo.h"
|
|
|
|
|
|
2018-02-21 10:38:39 -08:00
|
|
|
#include "canvas/efl_canvas_animation_types.eot.h"
|
2017-08-24 04:45:52 -07:00
|
|
|
|
2019-05-14 00:37:20 -07:00
|
|
|
#include "gesture/efl_canvas_gesture_types.eot.h"
|
|
|
|
|
#include "gesture/efl_canvas_gesture_touch.eo.h"
|
|
|
|
|
#include "gesture/efl_canvas_gesture.eo.h"
|
|
|
|
|
#include "gesture/efl_canvas_gesture_tap.eo.h"
|
|
|
|
|
#include "gesture/efl_canvas_gesture_long_tap.eo.h"
|
|
|
|
|
#include "gesture/efl_canvas_gesture_double_tap.eo.h"
|
|
|
|
|
#include "gesture/efl_canvas_gesture_triple_tap.eo.h"
|
|
|
|
|
#include "gesture/efl_canvas_gesture_momentum.eo.h"
|
|
|
|
|
#include "gesture/efl_canvas_gesture_flick.eo.h"
|
|
|
|
|
#include "gesture/efl_canvas_gesture_zoom.eo.h"
|
|
|
|
|
#include "gesture/efl_canvas_gesture_recognizer.eo.h"
|
|
|
|
|
#include "gesture/efl_canvas_gesture_recognizer_tap.eo.h"
|
|
|
|
|
#include "gesture/efl_canvas_gesture_recognizer_long_tap.eo.h"
|
|
|
|
|
#include "gesture/efl_canvas_gesture_recognizer_double_tap.eo.h"
|
|
|
|
|
#include "gesture/efl_canvas_gesture_recognizer_triple_tap.eo.h"
|
|
|
|
|
#include "gesture/efl_canvas_gesture_recognizer_momentum.eo.h"
|
|
|
|
|
#include "gesture/efl_canvas_gesture_recognizer_flick.eo.h"
|
|
|
|
|
#include "gesture/efl_canvas_gesture_recognizer_zoom.eo.h"
|
|
|
|
|
#include "gesture/efl_canvas_gesture_manager.eo.h"
|
|
|
|
|
#include "gesture/efl_gesture_events.eo.h"
|
|
|
|
|
|
2016-06-20 21:26:15 -07:00
|
|
|
#include "canvas/efl_canvas_object.eo.h"
|
2019-11-07 02:24:21 -08:00
|
|
|
#include "canvas/efl_canvas_object_animation.eo.h"
|
2018-02-21 10:38:39 -08:00
|
|
|
#include "canvas/efl_canvas_animation.eo.h"
|
|
|
|
|
#include "canvas/efl_canvas_animation_alpha.eo.h"
|
|
|
|
|
#include "canvas/efl_canvas_animation_rotate.eo.h"
|
|
|
|
|
#include "canvas/efl_canvas_animation_scale.eo.h"
|
|
|
|
|
#include "canvas/efl_canvas_animation_translate.eo.h"
|
|
|
|
|
#include "canvas/efl_canvas_animation_group.eo.h"
|
|
|
|
|
#include "canvas/efl_canvas_animation_group_parallel.eo.h"
|
|
|
|
|
#include "canvas/efl_canvas_animation_group_sequential.eo.h"
|
2018-04-04 03:46:41 -07:00
|
|
|
#include "canvas/efl_canvas_event_grabber.eo.h"
|
evas: add new event_grabber smart-ish object
adding an "event rect" is a common use case for rectangles, but I needed
a smarter event rect so I sent one off to school and it came back like this.
an event_grabber is a smart object which functions like a normal event rect
which has color(0,0,0,0), but with an important difference: it can have smart
members. event propagation works differently for an event_grabber:
normal:
event -> layer -> smart(obj1,obj2,obj3) ->(?) other objects
in this case, obj1,obj2,obj3 are all "inside" the smart object and their stacking
will always be considered as being inside the smart object. rendering is also
tied to the smart object in this case, as is clipping.
an event which reaches a smart object will be sent to the objects inside,
and then may continue through the smart object if there are no objects which
block repeating.
event_grabber:
event -> layer -> event_grabber -> obj1,obj2,obj3 -> STOP
in this case, obj1,obj2,obj3 are unmodified after being added to the event_grabber
and can be stacked, rendered, and clipped completely independently of the
event_grabber.
the event_grabber is considered an "event_parent" for this case. member objects
are not "inside" the event_grabber, and they are unable to receive events on
their own. instead, the event_grabber, which must be stacked above all its
members, receives events and propagates them top->down through its member objects.
if none of the member objects block the repeat of an event then the event will
still be blocked from further propagation past the event_grabber.
object lifetimes are independent of the event_grabber; deleting the event_grabber
has no effect on its members.
@feature
2017-06-09 17:16:08 -07:00
|
|
|
|
2014-05-10 03:00:34 -07:00
|
|
|
/**
|
|
|
|
|
* @defgroup Evas_3D Evas 3D Extensions
|
|
|
|
|
*
|
|
|
|
|
* Evas extension to support 3D rendering.
|
|
|
|
|
*
|
|
|
|
|
* @ingroup Evas
|
|
|
|
|
*/
|
|
|
|
|
|
2017-05-16 01:54:37 -07:00
|
|
|
#include "canvas/evas_canvas3d_types.eot.h"
|
|
|
|
|
|
2014-05-10 03:00:34 -07:00
|
|
|
/**
|
2015-06-17 07:31:14 -07:00
|
|
|
* @page evas_canvas3d_main Evas 3D
|
2014-05-10 03:00:34 -07:00
|
|
|
*
|
|
|
|
|
* @since 1.10
|
|
|
|
|
*
|
|
|
|
|
* @section toc Table of Contents
|
|
|
|
|
*
|
2015-06-17 07:31:14 -07:00
|
|
|
* @li @ref evas_canvas3d_intro
|
|
|
|
|
* @li @ref evas_canvas3d_example
|
2014-05-10 03:00:34 -07:00
|
|
|
*
|
2015-06-17 07:31:14 -07:00
|
|
|
* @section evas_canvas3d_intro Introduction
|
2014-05-10 03:00:34 -07:00
|
|
|
*
|
|
|
|
|
* Evas 3D is an extension to support 3D scene graph rendering into 2D Evas
|
2017-05-03 03:38:41 -07:00
|
|
|
* canvases, with tree-based scene graph manipulation and other typical 3D
|
|
|
|
|
* rendering techniques.
|
|
|
|
|
*
|
|
|
|
|
* 3D objects are used to describe three dimensional scenes and to provide
|
|
|
|
|
* interfaces to connect the scene to an Evas image object for rendering.
|
|
|
|
|
*
|
|
|
|
|
* Scenes are constructed by locating cameras and lights and selecting desired
|
|
|
|
|
* meshes, and organizing Node objects into hierarchical n-ary tree data structures.
|
|
|
|
|
* The scene is stacked on the canvas with existing Evas objects, which permits
|
|
|
|
|
* intermingling 3D rendered content in existing 2D application layouts.
|
|
|
|
|
*
|
|
|
|
|
* Rendering techniques supported by Evas 3D include flat and phong
|
|
|
|
|
* shading, normal and texture mapping, and triangle meshes. Existing
|
|
|
|
|
* Evas objects may also be used as textures inside the 3D scene,
|
|
|
|
|
* including EFL widgets and even application windows. This latter
|
|
|
|
|
* capability makes it possible to create a 3D version of an arbitrary
|
|
|
|
|
* EFL application with minimal code changes.
|
2014-05-10 03:00:34 -07:00
|
|
|
*
|
2015-06-17 07:31:14 -07:00
|
|
|
* @section evas_canvas3d_example Introductory Example
|
2014-05-10 03:00:34 -07:00
|
|
|
*
|
|
|
|
|
* @include evas-3d-cube.c
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
2015-06-17 07:31:14 -07:00
|
|
|
* @defgroup Evas_Canvas3D_Types Types & Enums
|
2014-05-10 03:00:34 -07:00
|
|
|
* @ingroup Evas_3D
|
|
|
|
|
*
|
2017-04-04 06:20:24 -07:00
|
|
|
* Primitive type definitions and enumerations.
|
2014-05-10 03:00:34 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
2015-06-17 07:31:14 -07:00
|
|
|
* @defgroup Evas_Canvas3D_Object Generic 3D Object Descriptions
|
2014-05-10 03:00:34 -07:00
|
|
|
* @ingroup Evas_3D
|
|
|
|
|
*
|
2017-05-03 03:38:41 -07:00
|
|
|
* The Evas_Canvas3D_Object structure is an abstract base for other Evas
|
|
|
|
|
* 3D objects (scenes, nodes, lights, meshes, textures, and materials)
|
|
|
|
|
* with reference counting and propagation of modifications via
|
|
|
|
|
* reference tracking. This permits, for example, when a scene object
|
|
|
|
|
* is modified (marked dirty), a number of image objects rendering that
|
|
|
|
|
* object to be notified to update themselves, without needing to call
|
|
|
|
|
* update functions manually.
|
2014-05-10 03:00:34 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
2015-06-17 07:31:14 -07:00
|
|
|
* @defgroup Evas_Canvas3D_Scene Scene Object
|
2014-05-10 03:00:34 -07:00
|
|
|
* @ingroup Evas_3D
|
|
|
|
|
*
|
2017-05-03 03:38:41 -07:00
|
|
|
* The Evas_Canvas3D_Scene structure represents a captured image of a
|
|
|
|
|
* scene graph through its viewing camera. A scene can be associated
|
|
|
|
|
* with an image object for canvas display via the
|
|
|
|
|
* evas_object_image_scene_set() function.
|
2014-05-10 03:00:34 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
2015-06-17 07:31:14 -07:00
|
|
|
* @defgroup Evas_Canvas3D_Node Node Object
|
2014-05-10 03:00:34 -07:00
|
|
|
* @ingroup Evas_3D
|
|
|
|
|
*
|
2017-05-03 03:38:41 -07:00
|
|
|
* The Evas_Canvas3D_Node structure defines the position, orientation,
|
|
|
|
|
* and scale of canvas objects (cameras, lights, meshes, etc.) in a 3D
|
|
|
|
|
* space. These nodes can be organized into a hierarchical n-ary tree
|
|
|
|
|
* structure to construct a scene graph.
|
2014-05-10 03:00:34 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
2015-06-17 07:31:14 -07:00
|
|
|
* @defgroup Evas_Canvas3D_Camera Camera Object
|
2014-05-10 03:00:34 -07:00
|
|
|
* @ingroup Evas_3D
|
|
|
|
|
*
|
2017-05-03 03:38:41 -07:00
|
|
|
* The Evas_Canvas3D_Camera structure defines properties used to
|
|
|
|
|
* generate 2D pictures of a given scene graph, similar in concept to
|
|
|
|
|
* focus length and film size for a real world camera.
|
|
|
|
|
*
|
|
|
|
|
* A given camera definition can be used to take multiple pictures of
|
|
|
|
|
* the scene by establishing multiple nodes for the
|
|
|
|
|
* Evas_Canvas3D_Camera, each of which are located at different
|
|
|
|
|
* positions and with different orientations. Convenience routines
|
|
|
|
|
* evas_canvas3d_node_position_set() and
|
|
|
|
|
* evas_canvas3d_node_look_at_set() are provided to adjust the position
|
|
|
|
|
* and viewing direction for these nodes.
|
2014-05-10 03:00:34 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
2015-06-17 07:31:14 -07:00
|
|
|
* @defgroup Evas_Canvas3D_Light Light Object
|
2014-05-10 03:00:34 -07:00
|
|
|
* @ingroup Evas_3D
|
|
|
|
|
*
|
2017-05-03 03:38:41 -07:00
|
|
|
* The Evas_Canvas3D_Light structure defines various light source
|
|
|
|
|
* properties. Reflection models include: Ambient, diffuse, and
|
|
|
|
|
* specular. Light models include directional, point, and spot. The
|
|
|
|
|
* position and direction for the light is tracked by the node that
|
|
|
|
|
* contains the light.
|
2014-05-10 03:00:34 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
2015-06-17 07:31:14 -07:00
|
|
|
* @defgroup Evas_Canvas3D_Mesh Mesh Object
|
2014-05-10 03:00:34 -07:00
|
|
|
* @ingroup Evas_3D
|
|
|
|
|
*
|
2017-05-03 03:38:41 -07:00
|
|
|
* The Evas_Canvas3D_Mesh structure manages key-frame based mesh
|
|
|
|
|
* animations for geometrical objects like character models, terrain,
|
|
|
|
|
* buildings, and other such visible objects. Each mesh frame can have
|
|
|
|
|
* its own material and geometric data. Blending functions, fog
|
|
|
|
|
* effects, level of detail boundaries, and shadow properties are also
|
|
|
|
|
* supported.
|
|
|
|
|
*
|
|
|
|
|
* Like other data objects, a mesh definition is located and oriented in
|
|
|
|
|
* the canvas with one or more nodes, with the mesh transformed from its
|
|
|
|
|
* modeling coordinate space to the node's coordinate space. The frame
|
|
|
|
|
* number is also tracked by the node, permitting creation of multiple
|
|
|
|
|
* nodes in the canvas each set to a different animation frame, for
|
|
|
|
|
* example.
|
|
|
|
|
*
|
|
|
|
|
* Unlike camera and light objects, multiple meshes can be contained in
|
|
|
|
|
* a single node.
|
2014-05-10 03:00:34 -07:00
|
|
|
*/
|
|
|
|
|
|
2015-05-26 09:49:15 -07:00
|
|
|
/**
|
2015-06-17 07:31:14 -07:00
|
|
|
* @defgroup Evas_Canvas3D_Primitive Primitive Object
|
2015-05-26 09:49:15 -07:00
|
|
|
* @ingroup Evas_3D
|
|
|
|
|
*
|
2017-05-03 03:38:41 -07:00
|
|
|
* The Evas_Canvas3D_Primitive structure defines the data for
|
|
|
|
|
* generating meshes for various types of primitive shapes such as
|
|
|
|
|
* cubes, cylinders, spheres, surfaces, terrain, etc. Use the
|
|
|
|
|
* evas_canvas3d_mesh_from_primitive_set() function to generate a
|
|
|
|
|
* mesh's frame of this primitive.
|
2015-05-26 09:49:15 -07:00
|
|
|
*/
|
|
|
|
|
|
2014-05-10 03:00:34 -07:00
|
|
|
/**
|
2015-06-17 07:31:14 -07:00
|
|
|
* @defgroup Evas_Canvas3D_Texture Texture Object
|
2014-05-10 03:00:34 -07:00
|
|
|
* @ingroup Evas_3D
|
|
|
|
|
*
|
2017-05-03 03:38:41 -07:00
|
|
|
* The Evas_Canvas3D_Texture structure associates a 2D bitmap image to a
|
|
|
|
|
* material for a surface. Image data for the texture can be loaded
|
|
|
|
|
* from memory, a file, or an Evas_Object. Use the
|
|
|
|
|
* evas_canvas3d_material_texture_set() function to add the texture to
|
|
|
|
|
* an Evas_Canvas3DMaterial's slot.
|
2014-05-10 03:00:34 -07:00
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/**
|
2015-06-17 07:31:14 -07:00
|
|
|
* @defgroup Evas_Canvas3D_Material Material Object
|
2014-05-10 03:00:34 -07:00
|
|
|
* @ingroup Evas_3D
|
|
|
|
|
*
|
2017-05-03 03:38:41 -07:00
|
|
|
* The Evas_Canvas3D_Material structure defines a set of material
|
|
|
|
|
* attributes used for determining the color of mesh surfaces. Each
|
|
|
|
|
* attribute is defined by a color value and texture map. The five
|
|
|
|
|
* attributes are: ambient, diffuse, specular, emission, and normal.
|
2014-05-10 03:00:34 -07:00
|
|
|
*/
|
|
|
|
|
|
2015-05-26 09:49:15 -07:00
|
|
|
/**
|
2015-06-17 07:31:14 -07:00
|
|
|
* @typedef Evas_Canvas3D_Surface_Func
|
2015-05-26 09:49:15 -07:00
|
|
|
*
|
2017-05-03 03:38:41 -07:00
|
|
|
* The Evas_Canvas3D_Surface_Func type of functions are used to
|
|
|
|
|
* create parametric surfaces as primitives. These compute the
|
|
|
|
|
* vertex x,y,z values for given v,u values.
|
|
|
|
|
*
|
|
|
|
|
* @param out_x The x component of the calculated value.
|
|
|
|
|
* @param out_y The y component of the calculated value.
|
|
|
|
|
* @param out_z The z component of the calculated value.
|
|
|
|
|
* @param a is the v value.
|
|
|
|
|
* @param b is the u value.
|
|
|
|
|
|
|
|
|
|
* @see Evas_Canvas3D_Primitive
|
2015-05-26 09:49:15 -07:00
|
|
|
*
|
|
|
|
|
* @since 1.15
|
2015-06-17 07:31:14 -07:00
|
|
|
* @ingroup Evas_Canvas3D_Primitive
|
2015-05-26 09:49:15 -07:00
|
|
|
*/
|
2015-06-17 07:31:14 -07:00
|
|
|
typedef void (Evas_Canvas3D_Surface_Func)(Evas_Real *out_x,
|
2015-05-26 09:49:15 -07:00
|
|
|
Evas_Real *out_y,
|
|
|
|
|
Evas_Real *out_z,
|
|
|
|
|
Evas_Real a,
|
|
|
|
|
Evas_Real b);
|
|
|
|
|
|
2015-08-24 03:00:57 -07:00
|
|
|
#include "canvas/evas_canvas3d_object.eo.h"
|
2014-04-14 03:03:47 -07:00
|
|
|
|
2015-06-17 07:31:14 -07:00
|
|
|
#include "canvas/evas_canvas3d_texture.eo.h"
|
2014-04-14 03:03:47 -07:00
|
|
|
|
2015-06-17 07:31:14 -07:00
|
|
|
#include "canvas/evas_canvas3d_material.eo.h"
|
2014-04-14 03:03:47 -07:00
|
|
|
|
2015-06-17 07:31:14 -07:00
|
|
|
#include "canvas/evas_canvas3d_light.eo.h"
|
2014-04-14 03:03:47 -07:00
|
|
|
|
2015-06-17 07:31:14 -07:00
|
|
|
#include "canvas/evas_canvas3d_primitive.eo.h"
|
2015-05-26 09:49:15 -07:00
|
|
|
|
2015-08-24 03:00:57 -07:00
|
|
|
#include "canvas/evas_canvas3d_mesh.eo.h"
|
|
|
|
|
|
2015-06-17 07:31:14 -07:00
|
|
|
#include "canvas/evas_canvas3d_node.eo.h"
|
2014-04-14 03:03:47 -07:00
|
|
|
|
2015-08-24 03:00:57 -07:00
|
|
|
#include "canvas/evas_canvas3d_camera.eo.h"
|
|
|
|
|
|
2015-06-17 07:31:14 -07:00
|
|
|
#include "canvas/evas_canvas3d_scene.eo.h"
|
2014-04-14 03:59:38 -07:00
|
|
|
|
2016-06-14 07:19:50 -07:00
|
|
|
#include "canvas/efl_canvas_scene3d.eo.h"
|
|
|
|
|
|
2016-06-09 01:30:05 -07:00
|
|
|
#include "canvas/efl_canvas_image_internal.eo.h"
|
2016-03-16 03:37:04 -07:00
|
|
|
#include "canvas/efl_canvas_image.eo.h"
|
2016-03-14 03:10:54 -07:00
|
|
|
#include "canvas/efl_canvas_snapshot.eo.h"
|
|
|
|
|
#include "canvas/efl_canvas_proxy.eo.h"
|
2019-02-20 12:32:41 -08:00
|
|
|
#include "canvas/efl_gfx_mapping.eo.h"
|
2016-03-14 03:10:54 -07:00
|
|
|
|
2019-10-01 21:21:35 -07:00
|
|
|
#include "canvas/efl_gfx_vg_value_provider.eo.h"
|
2015-04-03 07:12:59 -07:00
|
|
|
/**
|
|
|
|
|
* @ingroup Evas_Object_VG
|
|
|
|
|
*
|
|
|
|
|
* @{
|
|
|
|
|
*/
|
2018-09-10 01:27:42 -07:00
|
|
|
#include "canvas/efl_canvas_vg_object.eo.h"
|
2015-04-03 07:12:59 -07:00
|
|
|
/**
|
|
|
|
|
* @}
|
|
|
|
|
*/
|
|
|
|
|
|
2018-02-20 12:24:09 -08:00
|
|
|
#include "canvas/efl_canvas_vg_node.eo.h"
|
|
|
|
|
#include "canvas/efl_canvas_vg_container.eo.h"
|
|
|
|
|
#include "canvas/efl_canvas_vg_shape.eo.h"
|
2019-07-21 21:37:47 -07:00
|
|
|
#include "canvas/efl_canvas_vg_image.eo.h"
|
2018-02-20 12:24:09 -08:00
|
|
|
#include "canvas/efl_canvas_vg_gradient.eo.h"
|
|
|
|
|
#include "canvas/efl_canvas_vg_gradient_linear.eo.h"
|
|
|
|
|
#include "canvas/efl_canvas_vg_gradient_radial.eo.h"
|
