cedric pushed a commit to branch master. http://git.enlightenment.org/core/elementary.git/commit/?id=862f7cd104200e08c12bcda9239734231c374af4
commit 862f7cd104200e08c12bcda9239734231c374af4 Author: Oleksandr Shcherbina <o.shcherb...@samsung.com> Date: Tue Feb 17 12:51:14 2015 +0100 elementary: example showing Evas_3D with elementary widgets and testing some of its feature. Summary: This small application for quick testing main features and changes in Evas 3D. Main features: effects shadow, fog, measuring fps, load 3D model, panel for change sets light and camera. Reviewers: Hermet, raster, cedric Differential Revision: https://phab.enlightenment.org/D1953 Signed-off-by: Cedric BAIL <ced...@osg.samsung.com> --- configure.ac | 1 + src/examples/Makefile.am | 1 + src/examples/perfomance/HowTo | 13 + src/examples/perfomance/Makefile.am | 44 ++ src/examples/perfomance/Tools.h | 19 + src/examples/perfomance/backgroung.png | Bin 0 -> 177255 bytes src/examples/perfomance/camera_light.c | 351 +++++++++++ src/examples/perfomance/graphical.c | 680 ++++++++++++++++++++ src/examples/perfomance/graphical_struct.h | 90 +++ src/examples/perfomance/initial_config.xml | 11 + src/examples/perfomance/layout.edc | 170 +++++ src/examples/perfomance/perfomance.c | 972 +++++++++++++++++++++++++++++ src/examples/perfomance/target_texture.png | Bin 0 -> 2123166 bytes src/examples/perfomance/tools_private.h | 50 ++ 14 files changed, 2402 insertions(+) diff --git a/configure.ac b/configure.ac index d688119..8c63e11 100644 --- a/configure.ac +++ b/configure.ac @@ -501,6 +501,7 @@ src/modules/test_map/Makefile src/edje_externals/Makefile src/examples/Makefile src/examples/sphere_hunter/Makefile +src/examples/perfomance/Makefile src/tests/Makefile src/imported/Makefile src/imported/atspi/Makefile diff --git a/src/examples/Makefile.am b/src/examples/Makefile.am index 3a36f90..0fc5492 100644 --- a/src/examples/Makefile.am +++ b/src/examples/Makefile.am @@ -1,6 +1,7 @@ MAINTAINERCLEANFILES = Makefile.in SUBDIRS = sphere_hunter +SUBDIRS += perfomance include ../../Makefile_Elm_Helpers.am diff --git a/src/examples/perfomance/HowTo b/src/examples/perfomance/HowTo new file mode 100644 index 0000000..8417fa0 --- /dev/null +++ b/src/examples/perfomance/HowTo @@ -0,0 +1,13 @@ +It is application for quick checking changes in Evas 3D. + +Dependences (tested on): + efl >= 1.13.0 elementary >= 1.13.0 + xserver-xorg-video-nouveau driver + OpenGL rendering acceleration for elemenatry +Main features: + effects shadow, fog, colorpick + fps (Be careful, don't use changing speed animation and stop animation during measuring). + load 3D models + navigation panel (by right click) + +Warnings: Until 3D destructor work properly, you can have lags after set a lot of 3D models or spheres with precision >=50 diff --git a/src/examples/perfomance/Makefile.am b/src/examples/perfomance/Makefile.am new file mode 100644 index 0000000..2fea32d --- /dev/null +++ b/src/examples/perfomance/Makefile.am @@ -0,0 +1,44 @@ +MAINTAINERCLEANFILES = Makefile.in + +include ../../../Makefile_Elm_Helpers.am + +examplesdir = $(pkgdatadir)/examples/perfomance +filesdir = $(pkgdatadir)/examples/perfomance +files_DATA = + +AM_CPPFLAGS = \ +-Wno-unused-parameter \ +-I. \ +-I$(top_srcdir)/src/lib \ +-I$(top_builddir)/src/lib \ +-DPACKAGE_DATA_DIR="\"$(pkgdatadir)\"" \ +-DPACKAGE_BIN_DIR=\"$(bindir)\" \ +-DPACKAGE_LIB_DIR=\"$(libdir)\" \ +@ELEMENTARY_CFLAGS@ + +LDADD = \ +@ELEMENTARY_LIBS@ \ +$(top_builddir)/src/lib/libelementary.la + +SRCS = perfomance.c camera_light.c graphical.c + +.edc.edj: + $(AM_V_EDJ)$(EDJE_CC) $(EDJE_CC_FLAGS) $< $@ + +if EFL_BUILD_EXAMPLES +files_DATA += $(SRCS) layout.edc layout.edj + +perfomance_SOURCES = \ + perfomance.c \ + camera_light.c \ + graphical.c + +clean-local: + rm -f *.edj + +examples_PROGRAMS = \ + perfomance + +endif + +EXTRA_DIST = layout.edc backgroud.png target_texture.png diff --git a/src/examples/perfomance/Tools.h b/src/examples/perfomance/Tools.h new file mode 100644 index 0000000..c3cf8ca --- /dev/null +++ b/src/examples/perfomance/Tools.h @@ -0,0 +1,19 @@ + +/*initialization navigation panel*/ +Evas_Object * +init_panel_camera_light(Evas_Object *win, Eo* camera_node, Eo* light_node, double posX, double posY); +/*free resources*/ +void +panel_camera_light_fini(Evas_Object *navigation); +/*initialization graphical objects*/ +Evas_Object * +init_graphical_window(Evas_Object *image); +/*Set step of range*/ +Eina_Bool +panel_camera_coord_step_set(Evas_Object *navigation, int step); +Eina_Bool +panel_camera_angle_step_set(Evas_Object *navigation, int step); +Eina_Bool +panel_light_coord_step_set(Evas_Object *navigation, int step); +Eina_Bool +panel_light_angle_step_set(Evas_Object *navigation, int step); diff --git a/src/examples/perfomance/backgroung.png b/src/examples/perfomance/backgroung.png new file mode 100644 index 0000000..190a74f Binary files /dev/null and b/src/examples/perfomance/backgroung.png differ diff --git a/src/examples/perfomance/camera_light.c b/src/examples/perfomance/camera_light.c new file mode 100644 index 0000000..06ad690 --- /dev/null +++ b/src/examples/perfomance/camera_light.c @@ -0,0 +1,351 @@ +#include "tools_private.h" + +Eina_Bool _alloc_memory(Axis_Key **ckey, Panel_Struct **pobj, Axis_Key **lkey) +{ + *ckey = calloc(1, sizeof(Axis_Key)); + *pobj = calloc(1, sizeof(Panel_Struct)); + *lkey = calloc(1, sizeof(Axis_Key)); + + if (!(*ckey) || !(*pobj) || !(*lkey)) + { + fprintf(stdout, "Not enough memory - at %s line %d\n", __FILE__, __LINE__); + return EINA_FALSE; + } + + return EINA_TRUE; +} + +Evas_Object * +init_panel_camera_light(Evas_Object *win, Eo *camera_node, Eo *light_node, double posX, double posY) +{ + Evas_Object *nnavig = NULL, *bx_navigall = NULL; + Evas_Object *bx_navigcamup = NULL, *bx_navigcamlow = NULL, *bx_navigligthup = NULL, *bx_navigligthlow = NULL; + Evas_Object *spX = NULL, *spY = NULL, *spZ = NULL; + Evas_Object *spangle = NULL, *spaX = NULL, *spaY = NULL, *spaZ = NULL; + Evas_Object *splX = NULL, *splY = NULL, *splZ = NULL; + Evas_Object *splangle = NULL, *splaX = NULL, *splaY = NULL, *splaZ = NULL; + Evas_Object *separator = NULL; + Axis_Key *camera_xyz = NULL, *light_xyz = NULL; + Panel_Struct *pobject = NULL; + Evas_Real px = 0, py = 0, pz = 0; + + if (ELM_WIN_UNKNOWN == elm_win_type_get(win)) + { + fprintf(stdout, "Not appropriate parent object - at %s line %d\n", __FILE__, __LINE__); + return NULL; + } + + if (!_alloc_memory(&camera_xyz, &pobject, &light_xyz)) return NULL; + + /*Navigation panel layout*/ + bx_navigall = elm_box_add(win); + elm_box_homogeneous_set(bx_navigall, EINA_TRUE); + evas_object_show(bx_navigall); + + bx_navigcamup = elm_box_add(win); + elm_box_horizontal_set(bx_navigcamup, EINA_TRUE); + elm_box_homogeneous_set(bx_navigcamup, EINA_TRUE); + elm_box_pack_end(bx_navigall, bx_navigcamup); + evas_object_show(bx_navigcamup); + bx_navigcamlow = elm_box_add(win); + elm_box_horizontal_set(bx_navigcamlow, EINA_TRUE); + elm_box_homogeneous_set(bx_navigcamlow, EINA_TRUE); + elm_box_pack_end(bx_navigall, bx_navigcamlow); + evas_object_show(bx_navigcamlow); + + separator = elm_separator_add(win); + elm_separator_horizontal_set(separator, EINA_TRUE); + elm_box_pack_end(bx_navigall, separator); + evas_object_show(separator); + + bx_navigligthup = elm_box_add(win); + elm_box_horizontal_set(bx_navigligthup, EINA_TRUE); + elm_box_homogeneous_set(bx_navigligthup, EINA_TRUE); + elm_box_pack_end(bx_navigall, bx_navigligthup); + evas_object_show(bx_navigligthup); + bx_navigligthlow = elm_box_add(win); + elm_box_horizontal_set(bx_navigligthlow, EINA_TRUE); + elm_box_homogeneous_set(bx_navigligthlow, EINA_TRUE); + elm_box_pack_end(bx_navigall, bx_navigligthlow); + evas_object_show(bx_navigligthlow); + + /*Set UI panel for changing camera and light*/ + /*Init sp camera by default*/ + spX = elm_spinner_add(win); + elm_spinner_editable_set(spX, EINA_TRUE); + elm_spinner_min_max_set(spX, -COORDRANGE, COORDRANGE); + elm_spinner_label_format_set(spX, "camera X: %1.0f"); + elm_spinner_step_set(spX, 1.0); + pobject->cspX = spX; + elm_box_pack_end(bx_navigcamup, spX); + evas_object_show(spX); + evas_object_smart_callback_add(spX, "changed", _camera_light_changeX_cb, camera_node); + + spY = elm_spinner_add(win); + elm_spinner_editable_set(spY, EINA_TRUE); + elm_spinner_min_max_set(spY, -COORDRANGE, COORDRANGE); + elm_spinner_label_format_set(spY, "camera Y: %1.0f"); + elm_spinner_step_set(spY, 1.0); + pobject->cspY = spY; + elm_box_pack_end(bx_navigcamup, spY); + evas_object_show(spY); + evas_object_smart_callback_add(spY, "changed", _camera_light_changeY_cb, camera_node); + + spZ = elm_spinner_add(win); + elm_spinner_editable_set(spZ, EINA_TRUE); + elm_spinner_min_max_set(spZ, -COORDRANGE, COORDRANGE); + elm_spinner_label_format_set(spZ, "camera Z: %1.0f"); + elm_spinner_step_set(spY, 1.0); + pobject->cspZ = spZ; + elm_box_pack_end(bx_navigcamup, spZ); + evas_object_show(spZ); + evas_object_smart_callback_add(spZ, "changed", _camera_light_changeZ_cb, camera_node); + + eo_do(camera_node, evas_3d_node_position_get(EVAS_3D_SPACE_PARENT, &px, &py, &pz)); + elm_spinner_value_set(spX, px); + elm_spinner_value_set(spY, py); + elm_spinner_value_set(spZ, pz); + + spangle = elm_spinner_add(win); + elm_spinner_editable_set(spangle, EINA_TRUE); + elm_spinner_min_max_set(spangle, 0.0, ANGLERANGE); + elm_spinner_label_format_set(spangle, "angle: %1.0f"); + elm_spinner_step_set(spangle, 1.0); + pobject->cspangle = spangle; + evas_object_data_set(spangle, axiskeys, camera_xyz); + elm_box_pack_end(bx_navigcamlow, spangle); + elm_spinner_value_set(spangle, 0.0); + evas_object_show(spangle); + evas_object_smart_callback_add(spangle, "changed", _camera_light_angle_change_cb, camera_node); + + spaX = elm_spinner_add(win); + elm_spinner_min_max_set(spaX, 0.0, 1.0); + elm_spinner_label_format_set(spaX, "axisX: %1.0f"); + elm_spinner_step_set(spaX, 1.0); + elm_box_pack_end(bx_navigcamlow, spaX); + evas_object_show(spaX); + evas_object_smart_callback_add(spaX, "changed", _camera_light_axisX_change_cb, spangle); + + spaY = elm_spinner_add(win); + elm_spinner_min_max_set(spaY, 0.0, 1.0); + elm_spinner_label_format_set(spaY, "axisY: %1.0f"); + elm_spinner_step_set(spaY, 1.0); + elm_box_pack_end(bx_navigcamlow, spaY); + evas_object_show(spaY); + evas_object_smart_callback_add(spaY, "changed", _camera_light_axisY_change_cb, spangle); + + spaZ = elm_spinner_add(win); + elm_spinner_min_max_set(spaZ, 0.0, 1.0); + elm_spinner_label_format_set(spaZ, "axisZ: %1.0f"); + elm_spinner_step_set(spaZ, 1.0); + elm_box_pack_end(bx_navigcamlow, spaZ); + evas_object_show(spaZ); + evas_object_smart_callback_add(spaZ, "changed", _camera_light_axisZ_change_cb, spangle); + + /*Init spl light by default*/ + splX = elm_spinner_add(win); + elm_spinner_editable_set(splX, EINA_TRUE); + elm_spinner_min_max_set(splX, -COORDRANGE, COORDRANGE); + elm_spinner_label_format_set(splX, "light X: %1.0f"); + elm_spinner_step_set(splX, 1.0); + pobject->lspX = splX; + elm_box_pack_end(bx_navigligthup, splX); + evas_object_show(splX); + evas_object_smart_callback_add(splX, "changed", _camera_light_changeX_cb, light_node); + + splY = elm_spinner_add(win); + elm_spinner_editable_set(splY, EINA_TRUE); + elm_spinner_min_max_set(splY, -COORDRANGE, COORDRANGE); + elm_spinner_label_format_set(splY, "light Y: %1.0f"); + elm_spinner_step_set(splY, 1.0); + pobject->lspY = splY; + elm_box_pack_end(bx_navigligthup, splY); + evas_object_show(splY); + evas_object_smart_callback_add(splY, "changed", _camera_light_changeY_cb, light_node); + + splZ = elm_spinner_add(win); + elm_spinner_editable_set(splZ, EINA_TRUE); + elm_spinner_min_max_set(splZ, -COORDRANGE, COORDRANGE); + elm_spinner_label_format_set(splZ, "light Z: %1.0f"); + elm_spinner_step_set(splY, 1.0); + pobject->lspZ = splZ; + elm_box_pack_end(bx_navigligthup, splZ); + evas_object_show(splZ); + evas_object_smart_callback_add(splZ, "changed", _camera_light_changeZ_cb, light_node); + + eo_do(light_node, evas_3d_node_position_get(EVAS_3D_SPACE_PARENT, &px, &py, &pz)); + elm_spinner_value_set(splX, px); + elm_spinner_value_set(splY, py); + elm_spinner_value_set(splZ, pz); + + splangle = elm_spinner_add(win); + elm_spinner_editable_set(splangle, EINA_TRUE); + elm_spinner_min_max_set(splangle, 0.0, ANGLERANGE); + elm_spinner_label_format_set(splangle, "angle: %1.0f"); + elm_spinner_step_set(splangle, 1.0); + pobject->lspangle = splangle; + evas_object_data_set(splangle, axiskeys, light_xyz); + elm_box_pack_end(bx_navigligthlow, splangle); + elm_spinner_value_set(splangle, 0.0); + evas_object_show(splangle); + evas_object_smart_callback_add(splangle, "changed", _camera_light_angle_change_cb, light_node); + + splaX = elm_spinner_add(win); + elm_spinner_min_max_set(splaX, 0.0, 1.0); + elm_spinner_label_format_set(splaX, "axisX: %1.0f"); + elm_spinner_step_set(splaX, 1.0); + elm_box_pack_end(bx_navigligthlow, splaX); + evas_object_show(splaX); + evas_object_smart_callback_add(splaX, "changed", _camera_light_axisX_change_cb, splangle); + + splaY = elm_spinner_add(win); + elm_spinner_min_max_set(splaY, 0.0, 1.0); + elm_spinner_label_format_set(splaY, "axisY: %1.0f"); + elm_spinner_step_set(splaY, 1.0); + elm_box_pack_end(bx_navigligthlow, splaY); + evas_object_show(splaY); + evas_object_smart_callback_add(splaY, "changed", _camera_light_axisY_change_cb, splangle); + + splaZ = elm_spinner_add(win); + elm_spinner_min_max_set(splaZ, 0.0, 1.0); + elm_spinner_label_format_set(splaZ, "axisZ: %1.0f"); + elm_spinner_step_set(splaZ, 1.0); + elm_box_pack_end(bx_navigligthlow, splaZ); + evas_object_show(splaZ); + evas_object_smart_callback_add(spaZ, "changed", _camera_light_axisZ_change_cb, splangle); + + nnavig = elm_notify_add(win); + elm_object_content_set(nnavig, bx_navigall); + elm_notify_align_set(nnavig, posX, posY); + evas_object_data_set(nnavig, pb, pobject); + + return nnavig; +} + +static void +_camera_light_changeX_cb(void *data, Evas_Object *obj, void *event_info) +{ + Evas_Real x, y, z; + + if ((Eo*)data) + { + eo_do((Eo*)data, evas_3d_node_position_get(EVAS_3D_SPACE_PARENT, NULL, &y, &z)); + x = elm_spinner_value_get(obj); + eo_do((Eo*)data, evas_3d_node_position_set(x, y, z)); + } +} +static void +_camera_light_changeY_cb(void *data, Evas_Object *obj, void *event_info) +{ + Evas_Real x, y, z; + + if ((Eo*)data) + { + eo_do((Eo*)data, evas_3d_node_position_get(EVAS_3D_SPACE_PARENT, &x, NULL, &z)); + y = elm_spinner_value_get(obj); + eo_do((Eo*)data, evas_3d_node_position_set(x, y, z)); + } +} +static void +_camera_light_changeZ_cb(void *data, Evas_Object *obj, void *event_info) +{ + Evas_Real x, y, z; + + if ((Eo*)data) + { + eo_do((Eo*)data, evas_3d_node_position_get(EVAS_3D_SPACE_PARENT, &x, &y, NULL)); + z = elm_spinner_value_get(obj); + eo_do((Eo*)data, evas_3d_node_position_set(x, y, z)); + } +} +static void +_camera_light_angle_change_cb(void *data, Evas_Object *obj, void *event_info) +{ + Axis_Key *key = evas_object_data_get(obj, axiskeys); + Evas_Real aw = 0; + if ((Eo*)data) + { + aw = elm_spinner_value_get(obj); + aw = cos(aw * M_PI / 360.0); + eo_do(((Eo*)data), evas_3d_node_orientation_set(key->x, key->y, key->z, aw)); + } +} +static void +_camera_light_axisX_change_cb(void *data, Evas_Object *obj, void *event_info) +{ + Evas_Object *fsa = (Evas_Object*)data; + Axis_Key *key = evas_object_data_get(fsa, axiskeys); + if (key) + key->x = elm_spinner_value_get(obj); +} +static void +_camera_light_axisY_change_cb(void *data, Evas_Object *obj, void *event_info) +{ + Evas_Object *fsa = (Evas_Object*)data; + Axis_Key *key = evas_object_data_get(fsa, axiskeys); + if (key) + key->y = elm_spinner_value_get(obj); +} +static void +_camera_light_axisZ_change_cb(void *data, Evas_Object *obj, void *event_info) +{ + Evas_Object *fsa = (Evas_Object*)data; + Axis_Key *key = evas_object_data_get(fsa, axiskeys); + if (key) + key->z = elm_spinner_value_get(obj); +} + +Eina_Bool +panel_camera_coord_step_set(Evas_Object *navigation, int step) +{ + Panel_Struct *pobject = NULL; + + pobject = evas_object_data_get(navigation, pb); + elm_spinner_step_set(pobject->cspX, step); + elm_spinner_step_set(pobject->cspY, step); + elm_spinner_step_set(pobject->cspZ, step); + return EINA_TRUE; +} + +Eina_Bool +panel_camera_angle_step_set(Evas_Object *navigation, int step) +{ + Panel_Struct *pobject = NULL; + + pobject = evas_object_data_get(navigation, pb); + elm_spinner_step_set(pobject->cspangle, step); + return EINA_TRUE; +} + +Eina_Bool +panel_light_coord_step_set(Evas_Object *navigation, int step) +{ + Panel_Struct *pobject = NULL; + + pobject = evas_object_data_get(navigation, pb); + elm_spinner_step_set(pobject->lspX, step); + elm_spinner_step_set(pobject->lspY, step); + elm_spinner_step_set(pobject->lspZ, step); + return EINA_TRUE; +} + +Eina_Bool +panel_light_angle_step_set(Evas_Object *navigation, int step) +{ + Panel_Struct *pobject = NULL; + + pobject = evas_object_data_get(navigation, pb); + elm_spinner_step_set(pobject->lspangle, step); + return EINA_TRUE; +} + +void panel_camera_light_fini(Evas_Object *navigation) +{ + Panel_Struct *pobject = evas_object_data_get(navigation, pb); + Axis_Key *ckey = evas_object_data_get(pobject->cspangle, axiskeys); + Axis_Key *lkey = evas_object_data_get(pobject->lspangle, axiskeys); + free(pobject); + free(ckey); + free(lkey); +} + diff --git a/src/examples/perfomance/graphical.c b/src/examples/perfomance/graphical.c new file mode 100644 index 0000000..10bc775 --- /dev/null +++ b/src/examples/perfomance/graphical.c @@ -0,0 +1,680 @@ +#define EFL_EO_API_SUPPORT +#define EFL_BETA_API_SUPPORT + +#include <math.h> +#include <stdlib.h> +#include <time.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include <Eo.h> +#include <Evas.h> +#include <Ecore.h> +#include <Ecore_Evas.h> +#include <Eina.h> + +#include "graphical_struct.h" + +#define FOG_COLOR 0.5, 0.5, 0.5 +#define FOG_FACTOR 0.1 + +static inline vec3 +_normalize(const vec3 *v) +{ + double l = sqrt(v->x * v->x + v->y * v->y + v->z * v->z); + vec3 vec; + + vec.x = v->x / l; + vec.y = v->y / l; + vec.z = v->z / l; + + return vec; +} +static void +_sphere_count(int prec, float type_init) +{ + int i, j; + + globalGraphical.vertex_count = (prec + 1) * (prec + 1); + + /* Allocate buffer. */ + if (globalGraphical.places) free(globalGraphical.places); + globalGraphical.places = malloc(sizeof(place) * globalGraphical.vertex_count); + + for (i = 0; i <= prec; i++) + { + double lati = M_PI * (type_init + (double)i * (1 - 2 * type_init) / (double)prec); + double y = cos(lati); + double r = fabs(sin(lati)); + + for (j = 0; j <= prec; j++) + { + double longi = (M_PI * 2.0 * j) / (prec + 1); + place *v = &globalGraphical.places[i * (prec + 1) + j]; + v->position.x = r * sin(longi); + v->position.y = y; + v->position.z = r * cos(longi); + } + } +} +static void +_sphere_init(int prec) +{ + int i, j; + unsigned short *index; + + globalGraphical.vertex_count = (prec + 1) * (prec + 1); + globalGraphical.index_count = prec * prec * 6; + + /* Allocate buffer. */ + if (globalGraphical.vertices) free(globalGraphical.vertices); + if (globalGraphical.indices) free(globalGraphical.indices); + + globalGraphical.vertices = malloc(sizeof(vertex) * globalGraphical.vertex_count); + globalGraphical.indices = malloc(sizeof(unsigned short) * globalGraphical.index_count); + + for (i = 0; i <= prec; i++) + { + double lati = (M_PI * (double)i) / (double)prec; + double y = cos(lati); + double r = fabs(sin(lati)); + + for (j = 0; j <= prec; j++) + { + double longi = (M_PI * 2.0 * j) / prec; + vertex *v = &globalGraphical.vertices[i * (prec + 1) + j]; + + if (j == 0 || j == prec) v->position.x = 0.0; + else v->position.x = r * sin(longi); + + v->position.y = y; + + if (j == 0 || j == prec) v->position.z = r; + else v->position.z = r * cos(longi); + + v->normal = v->position; + + if (v->position.x > 0.0) + { + v->tangent.x = -v->normal.y; + v->tangent.y = v->normal.x; + v->tangent.z = v->normal.z; + } + else + { + v->tangent.x = v->normal.y; + v->tangent.y = -v->normal.x; + v->tangent.z = v->normal.z; + } + + v->color.x = v->position.x; + v->color.y = v->position.y; + v->color.z = v->position.z; + v->color.w = 1.0; + + if (j == prec) v->texcoord.x = 1.0; + else if (j == 0) v->texcoord.x = 0.0; + else v->texcoord.x = (double)j / (double)prec; + + if (i == prec) v->texcoord.y = 1.0; + else if (i == 0) v->texcoord.y = 0.0; + else v->texcoord.y = 1.0 - (double)i / (double)prec; + } + } + + index = &globalGraphical.indices[0]; + + for (i = 0; i < prec; i++) + { + for (j = 0; j < prec; j++) + { + *index++ = i * (prec + 1) + j; + *index++ = i * (prec + 1) + j + 1; + *index++ = (i + 1) * (prec + 1) + j; + + *index++ = (i + 1) * (prec + 1) + j; + *index++ = i * (prec + 1) + j + 1; + *index++ = (i + 1) * (prec + 1) + j + 1; + } + } + + for (i = 0; i < globalGraphical.index_count; i += 3) + { + vertex *v0 = &globalGraphical.vertices[globalGraphical.indices[i + 0]]; + vertex *v1 = &globalGraphical.vertices[globalGraphical.indices[i + 1]]; + vertex *v2 = &globalGraphical.vertices[globalGraphical.indices[i + 2]]; + + vec3 e1, e2; + float du1, du2, dv1, dv2, f; + vec3 tangent; + + e1.x = v1->position.x - v0->position.x; + e1.y = v1->position.y - v0->position.y; + e1.z = v1->position.z - v0->position.z; + + e2.x = v2->position.x - v0->position.x; + e2.y = v2->position.y - v0->position.y; + e2.z = v2->position.z - v0->position.z; + + du1 = v1->texcoord.x - v0->texcoord.x; + dv1 = v1->texcoord.y - v0->texcoord.y; + + du2 = v2->texcoord.x - v0->texcoord.x; + dv2 = v2->texcoord.y - v0->texcoord.y; + + f = 1.0 / (du1 * dv2 - du2 * dv1); + + tangent.x = f * (dv2 * e1.x - dv1 * e2.x); + tangent.y = f * (dv2 * e1.y - dv1 * e2.y); + tangent.z = f * (dv2 * e1.z - dv1 * e2.z); + + v0->tangent = tangent; + } + + for (i = 0; i <= prec; i++) + { + for (j = 0; j <= prec; j++) + { + if (j == prec) + { + vertex *v = &globalGraphical.vertices[i * (prec + 1) + j]; + v->tangent = globalGraphical.vertices[i * (prec + 1)].tangent; + } + } + } +} +/*FIXME Need to be from bounding of root_node*/ +void _init_bounding() +{ + + float cube_vertices[] = + { + /* Front */ + -50.0, 1.0, 50.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, + 50.0, 1.0, 50.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, + -50.0, -1.0, 50.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, + 50.0, -1.0, 50.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, + + /* Back */ + 50.0, 1.0, -50.0, 0.0, 0.0, -1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, + -50.0, 1.0, -50.0, 0.0, 0.0, -1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, + 50.0, -1.0, -50.0, 0.0, 0.0, -1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, + -50.0, -1.0, -50.0, 0.0, 0.0, -1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, + + /* Left */ + -50.0, 1.0, -50.0, -1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, + -50.0, 1.0, 50.0, -1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, + -50.0, -1.0, -50.0, -1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, + -50.0, -1.0, 50.0, -1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, + + /* Right */ + 50.0, 1.0, 50.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, + 50.0, 1.0, -50.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 1.0, + 50.0, -1.0, 50.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, + 50.0, -1.0, -50.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, + + /* Top */ + -50.0, 1.0, -50.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, + 50.0, 1.0, -50.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, + -50.0, 1.0, 50.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, + 50.0, 1.0, 50.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, + + /* Bottom */ + 50.0, -1.0, -50.0, 0.0, -1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, + -50.0, -1.0, -50.0, 0.0, -1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, + 50.0, -1.0, 50.0, 0.0, -1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, + -50.0, -1.0, 50.0, 0.0, -1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, + }; + + unsigned short cube_indices[] = + { + /* Front */ + 0, 1, 2, 2, 1, 3, + + /* Back */ + 4, 5, 6, 6, 5, 7, + + /* Left */ + 8, 9, 10, 10, 9, 11, + + /* Right */ + 12, 13, 14, 14, 13, 15, + + /* Top */ + 16, 17, 18, 18, 17, 19, + + /* Bottom */ + 20, 21, 22, 22, 21, 23 + }; + + globalGraphical.material_box = eo_add(EVAS_3D_MATERIAL_CLASS, globalGraphical.evas); + + eo_do(globalGraphical.material_box, + evas_3d_material_enable_set(EVAS_3D_MATERIAL_AMBIENT, EINA_TRUE), + evas_3d_material_enable_set(EVAS_3D_MATERIAL_DIFFUSE, EINA_TRUE), + evas_3d_material_enable_set(EVAS_3D_MATERIAL_SPECULAR, EINA_TRUE), + + evas_3d_material_color_set(EVAS_3D_MATERIAL_AMBIENT, 0.2, 0.2, 0.2, 1.0), + evas_3d_material_color_set(EVAS_3D_MATERIAL_DIFFUSE, 0.8, 0.8, 0.8, 1.0), + evas_3d_material_color_set(EVAS_3D_MATERIAL_SPECULAR, 1.0, 1.0, 1.0, 1.0), + evas_3d_material_shininess_set(100.0)); + + /* Setup mesh. */ + globalGraphical.mesh_box = eo_add(EVAS_3D_MESH_CLASS, globalGraphical.evas); + eo_do(globalGraphical.mesh_box, + evas_3d_mesh_vertex_count_set(24), + evas_3d_mesh_frame_add(0), + + evas_3d_mesh_frame_vertex_data_copy_set(0, EVAS_3D_VERTEX_POSITION, + 12 * sizeof(float), &cube_vertices[ 0]), + evas_3d_mesh_frame_vertex_data_copy_set(0, EVAS_3D_VERTEX_NORMAL, + 12 * sizeof(float), &cube_vertices[ 3]), + evas_3d_mesh_frame_vertex_data_copy_set(0, EVAS_3D_VERTEX_COLOR, + 12 * sizeof(float), &cube_vertices[ 6]), + evas_3d_mesh_frame_vertex_data_copy_set(0, EVAS_3D_VERTEX_TEXCOORD, + 12 * sizeof(float), &cube_vertices[10]), + + evas_3d_mesh_index_data_copy_set(EVAS_3D_INDEX_FORMAT_UNSIGNED_SHORT, + 36, &cube_indices[0]), + evas_3d_mesh_vertex_assembly_set(EVAS_3D_VERTEX_ASSEMBLY_TRIANGLES), + + evas_3d_mesh_shade_mode_set(EVAS_3D_SHADE_MODE_PHONG), + + evas_3d_mesh_frame_material_set(0, globalGraphical.material_box)); + + globalGraphical.mesh_nodebox = + eo_add(EVAS_3D_NODE_CLASS, globalGraphical.evas, + evas_3d_node_constructor(EVAS_3D_NODE_TYPE_MESH), + evas_3d_node_position_set(0, -30.0, 0.0)); + eo_do(globalGraphical.root_node, evas_3d_node_member_add(globalGraphical.mesh_nodebox)); + eo_do(globalGraphical.mesh_nodebox, evas_3d_node_mesh_add(globalGraphical.mesh_box)); +} +static void +_change_scene_setup() +{ + Eo *node = NULL, *m = NULL; + Eina_List *l = NULL; + int i = 0; + int quantity = (globalGraphical.count + 1) * (globalGraphical.count + 1); + eo_do(globalGraphical.camera, + evas_3d_camera_projection_perspective_set(globalGraphical.angle, 1.0, 2.0, 1000)); + + EINA_LIST_FOREACH (globalGraphical.list_nodes, l, node) + { + eo_do(globalGraphical.root_node, evas_3d_node_member_del(node)); + globalGraphical.list_nodes = eina_list_remove(globalGraphical.list_nodes, node); + /*eo_del(node);Unless evas_3d_destructors work properly*/ + } + eina_list_free(globalGraphical.list_nodes); + eina_list_free(l); + + + EINA_LIST_FOREACH (globalGraphical.list_meshes, l, m) + { + globalGraphical.list_meshes = eina_list_remove(globalGraphical.list_meshes, m); + /*eo_del(m); Unless evas_3d_destructors work properly*/ + } + eina_list_free(globalGraphical.list_meshes); + eina_list_free(l); + + /* Add the mesh with target precision */ + _sphere_init(globalGraphical.precision); + for (i = 0; i < quantity; i++) + { + globalGraphical.mesh = eo_add(EVAS_3D_MESH_CLASS, globalGraphical.evas); + if (!globalGraphical.model_path) + { + eo_do(globalGraphical.mesh, + evas_3d_mesh_vertex_count_set(globalGraphical.vertex_count), + evas_3d_mesh_frame_add(0), + evas_3d_mesh_frame_vertex_data_copy_set(0, EVAS_3D_VERTEX_POSITION, + sizeof(vertex), + &globalGraphical.vertices[0].position), + evas_3d_mesh_frame_vertex_data_copy_set(0, EVAS_3D_VERTEX_NORMAL, + sizeof(vertex), + &globalGraphical.vertices[0].normal), + evas_3d_mesh_frame_vertex_data_copy_set(0, EVAS_3D_VERTEX_TANGENT, + sizeof(vertex), + &globalGraphical.vertices[0].tangent), + evas_3d_mesh_frame_vertex_data_copy_set(0, EVAS_3D_VERTEX_COLOR, + sizeof(vertex), &globalGraphical.vertices[0].color), + evas_3d_mesh_frame_vertex_data_copy_set(0, EVAS_3D_VERTEX_TEXCOORD, + sizeof(vertex), + &globalGraphical.vertices[0].texcoord), + + evas_3d_mesh_index_data_copy_set(EVAS_3D_INDEX_FORMAT_UNSIGNED_SHORT, + globalGraphical.index_count, &globalGraphical.indices[0]), + evas_3d_mesh_vertex_assembly_set(EVAS_3D_VERTEX_ASSEMBLY_TRIANGLES), + evas_3d_mesh_shade_mode_set(EVAS_3D_SHADE_MODE_PHONG)); + } + else + { + eo_do(globalGraphical.mesh, + efl_file_set(globalGraphical.model_path, NULL), + evas_3d_mesh_frame_material_set(0, globalGraphical.material), + evas_3d_mesh_shade_mode_set(EVAS_3D_SHADE_MODE_PHONG)); + } + + if (globalGraphical.flags.fog_enable) + { + eo_do(globalGraphical.mesh, evas_3d_mesh_fog_enable_set(EINA_TRUE), evas_3d_mesh_fog_color_set(FOG_COLOR, FOG_FACTOR)); + } + else + { + eo_do(globalGraphical.mesh, evas_3d_mesh_fog_enable_set(EINA_FALSE)); + } + if (globalGraphical.flags.colorpick_enable) + eo_do(globalGraphical.mesh, evas_3d_mesh_color_pick_enable_set(EINA_TRUE)); + else + eo_do(globalGraphical.mesh, evas_3d_mesh_color_pick_enable_set(EINA_FALSE)); + + if (globalGraphical.flags.blend_enable) + { + eo_do(globalGraphical.mesh, evas_3d_mesh_blending_enable_set(EINA_TRUE), + evas_3d_mesh_blending_func_set(EVAS_3D_BLEND_SRC_ALPHA, EVAS_3D_BLEND_ONE_MINUS_SRC_ALPHA)); + } + else + eo_do(globalGraphical.mesh, evas_3d_mesh_blending_enable_set(EINA_FALSE)); + + eo_do(globalGraphical.mesh, evas_3d_mesh_frame_material_set(0, globalGraphical.material)); + globalGraphical.list_meshes = eina_list_append(globalGraphical.list_meshes, globalGraphical.mesh); + } + + /*Add target count nodes*/ + _sphere_count(globalGraphical.count, 0.2); + for (i = 0; i < quantity; i++) + { + globalGraphical.mesh_node = + eo_add(EVAS_3D_NODE_CLASS, globalGraphical.evas, + evas_3d_node_constructor(EVAS_3D_NODE_TYPE_MESH), + evas_3d_node_position_set(globalGraphical.places[i].position.x * 20, + globalGraphical.places[i].position.y * 20, + globalGraphical.places[i].position.z * 20)); + if (globalGraphical.model_path) + eo_do(globalGraphical.mesh_node, evas_3d_node_scale_set(0.2, 0.2, 0.2)); + eo_do(globalGraphical.root_node, evas_3d_node_member_add(globalGraphical.mesh_node)); + eo_do(globalGraphical.mesh_node, evas_3d_node_mesh_add((Eo*)eina_list_nth(globalGraphical.list_meshes, i))); + globalGraphical.list_nodes = eina_list_append(globalGraphical.list_nodes, globalGraphical.mesh_node); + } + + + if (!globalGraphical.flags.fps_enable) + ecore_animator_frametime_set(1.0 / (globalGraphical.speed)); + else + ecore_animator_frametime_set(0.0001); + + if (globalGraphical.flags.shadow_enable) + eo_do(globalGraphical.scene, evas_3d_scene_shadows_enable_set(EINA_TRUE)); + else + eo_do(globalGraphical.scene, evas_3d_scene_shadows_enable_set(EINA_FALSE)); + + if (globalGraphical.flags.colorpick_enable) + { + eo_do(globalGraphical.scene, evas_3d_scene_color_pick_enable_set(EINA_TRUE)); + } + else + eo_do(globalGraphical.scene, evas_3d_scene_color_pick_enable_set(EINA_FALSE)); +} + +static void +_init_scene(Evas_Object *img) +{ + int i, x, y, w, h; + int quantity = (globalGraphical.count + 1) * (globalGraphical.count + 1); + /*Allocate memory - eina_mempool*/ + + /* Add a scene object .*/ + globalGraphical.scene = eo_add(EVAS_3D_SCENE_CLASS, globalGraphical.evas); + + /* Add the root node for the scene. */ + globalGraphical.root_node = eo_add(EVAS_3D_NODE_CLASS, globalGraphical.evas, + evas_3d_node_constructor(EVAS_3D_NODE_TYPE_NODE)); + + /* Add the camera. */ + globalGraphical.camera = eo_add(EVAS_3D_CAMERA_CLASS, globalGraphical.evas); + eo_do(globalGraphical.camera, + evas_3d_camera_projection_perspective_set(globalGraphical.angle, 1.0, 2.0, 1000.0)); + + globalGraphical.camera_node = + eo_add(EVAS_3D_NODE_CLASS, globalGraphical.evas, + evas_3d_node_constructor(EVAS_3D_NODE_TYPE_CAMERA)); + eo_do(globalGraphical.camera_node, + evas_3d_node_camera_set(globalGraphical.camera), + evas_3d_node_position_set(0.0, 0.0, 25.0), + evas_3d_node_look_at_set(EVAS_3D_SPACE_PARENT, 0.0, 0.0, 0.0, + EVAS_3D_SPACE_PARENT, 0.0, 1.0, 0.0)); + eo_do(globalGraphical.root_node, evas_3d_node_member_add(globalGraphical.camera_node)); + + globalGraphical.light = eo_add(EVAS_3D_LIGHT_CLASS, globalGraphical.evas); + eo_do(globalGraphical.light, + evas_3d_light_ambient_set(1.0, 1.0, 1.0, 1.0), + evas_3d_light_diffuse_set(1.0, 1.0, 1.0, 1.0), + evas_3d_light_specular_set(1.0, 1.0, 1.0, 1.0), + evas_3d_light_projection_perspective_set(globalGraphical.angle / 5, 1.0, 1.0, 1000.0), + /*evas_3d_light_projection_perspective_set(value, ...) => + evas_3d_light_spot_cutoff_set(~(value / 3))*/ + evas_3d_light_spot_cutoff_set(globalGraphical.angle / 15)); + + globalGraphical.light_node = + eo_add(EVAS_3D_NODE_CLASS, globalGraphical.evas, + evas_3d_node_constructor(EVAS_3D_NODE_TYPE_LIGHT)); + eo_do(globalGraphical.light_node, + evas_3d_node_light_set(globalGraphical.light), + evas_3d_node_position_set(0.0, 100.0, 1.0), + evas_3d_node_look_at_set(EVAS_3D_SPACE_PARENT, 0.0, 0.0, 0.0, + EVAS_3D_SPACE_PARENT, 0.0, 1.0, 0.0)); + eo_do(globalGraphical.root_node, evas_3d_node_member_add(globalGraphical.light_node)); + + + globalGraphical.material = eo_add(EVAS_3D_MATERIAL_CLASS, globalGraphical.evas); + globalGraphical.texture = eo_add(EVAS_3D_TEXTURE_CLASS, globalGraphical.evas); + eo_do(globalGraphical.texture, + evas_3d_texture_file_set("target_texture.png", NULL), + evas_3d_texture_filter_set(EVAS_3D_TEXTURE_FILTER_LINEAR, + EVAS_3D_TEXTURE_FILTER_LINEAR), + evas_3d_texture_wrap_set(EVAS_3D_WRAP_MODE_REPEAT, + EVAS_3D_WRAP_MODE_REPEAT)); + eo_do(globalGraphical.material, + evas_3d_material_texture_set(EVAS_3D_MATERIAL_DIFFUSE, globalGraphical.texture), + evas_3d_material_texture_set(EVAS_3D_MATERIAL_AMBIENT, globalGraphical.texture), + evas_3d_material_enable_set(EVAS_3D_MATERIAL_AMBIENT, EINA_TRUE), + evas_3d_material_enable_set(EVAS_3D_MATERIAL_DIFFUSE, EINA_TRUE), + evas_3d_material_enable_set(EVAS_3D_MATERIAL_SPECULAR, EINA_TRUE), + evas_3d_material_enable_set(EVAS_3D_MATERIAL_NORMAL, EINA_TRUE), + evas_3d_material_color_set(EVAS_3D_MATERIAL_AMBIENT, 1.0, 0.2, 0.2, 0.2), + evas_3d_material_color_set(EVAS_3D_MATERIAL_DIFFUSE, 1.0, 0.0, 0.0, 0.2), + evas_3d_material_color_set(EVAS_3D_MATERIAL_SPECULAR, 1.0, 1.0, 1.0, 0.2)); + /* Add the mesh with target precision */ + _sphere_init(globalGraphical.precision); + + for (i = 0; i < quantity; i++) + { + globalGraphical.mesh = eo_add(EVAS_3D_MESH_CLASS, globalGraphical.evas); + if (!globalGraphical.model_path) + { + eo_do(globalGraphical.mesh, + evas_3d_mesh_vertex_count_set(globalGraphical.vertex_count), + evas_3d_mesh_frame_add(0), + evas_3d_mesh_frame_vertex_data_copy_set(0, EVAS_3D_VERTEX_POSITION, + sizeof(vertex), + &globalGraphical.vertices[0].position), + evas_3d_mesh_frame_vertex_data_copy_set(0, EVAS_3D_VERTEX_NORMAL, + sizeof(vertex), + &globalGraphical.vertices[0].normal), + evas_3d_mesh_frame_vertex_data_copy_set(0, EVAS_3D_VERTEX_TANGENT, + sizeof(vertex), + &globalGraphical.vertices[0].tangent), + evas_3d_mesh_frame_vertex_data_copy_set(0, EVAS_3D_VERTEX_COLOR, + sizeof(vertex), &globalGraphical.vertices[0].color), + evas_3d_mesh_frame_vertex_data_copy_set(0, EVAS_3D_VERTEX_TEXCOORD, + sizeof(vertex), + &globalGraphical.vertices[0].texcoord), + + evas_3d_mesh_index_data_copy_set(EVAS_3D_INDEX_FORMAT_UNSIGNED_SHORT, + globalGraphical.index_count, &globalGraphical.indices[0]), + evas_3d_mesh_vertex_assembly_set(EVAS_3D_VERTEX_ASSEMBLY_TRIANGLES), + evas_3d_mesh_shade_mode_set(EVAS_3D_SHADE_MODE_PHONG)); + } + else + { + eo_do(globalGraphical.mesh, + efl_file_set(globalGraphical.model_path, NULL), + evas_3d_mesh_frame_material_set(0, globalGraphical.material), + evas_3d_mesh_shade_mode_set(EVAS_3D_SHADE_MODE_PHONG)); + } + eo_do(globalGraphical.mesh, evas_3d_mesh_frame_material_set(0, globalGraphical.material)); + globalGraphical.list_meshes = eina_list_append(globalGraphical.list_meshes, globalGraphical.mesh); + } + + /*Add target count meshes*/ + _sphere_count(globalGraphical.count, 0.2); + + for (i = 0; i < quantity; i++) + { + globalGraphical.mesh_node = + eo_add(EVAS_3D_NODE_CLASS, globalGraphical.evas, + evas_3d_node_constructor(EVAS_3D_NODE_TYPE_MESH), + evas_3d_node_position_set(globalGraphical.places[i].position.x * 20, + globalGraphical.places[i].position.y * 20, + globalGraphical.places[i].position.z * 20)); + if (globalGraphical.model_path) + eo_do(globalGraphical.mesh_node, evas_3d_node_scale_set(0.2, 0.2, 0.2)); + eo_do(globalGraphical.root_node, evas_3d_node_member_add(globalGraphical.mesh_node)); + eo_do(globalGraphical.mesh_node, evas_3d_node_mesh_add((Eo*)eina_list_nth(globalGraphical.list_meshes, i))); + globalGraphical.list_nodes = eina_list_append(globalGraphical.list_nodes, globalGraphical.mesh_node); + } + + _init_bounding(); + evas_object_geometry_get(img, &x, &y, &w, &h); + eo_do(globalGraphical.scene, + evas_3d_scene_root_node_set(globalGraphical.root_node), + evas_3d_scene_camera_node_set(globalGraphical.camera_node), + evas_3d_scene_size_set(w, h)); + + ecore_animator_frametime_set(1.0 / (globalGraphical.speed)); +} + +static Eina_Bool +_xml_attr_data(void *data, const char *key, const char *value) +{ + char *format = NULL, *tmp = NULL, *a = NULL; + int i; + + if (!strcmp("path", key)) + { + if (!strcmp("none", value)) + { + globalGraphical.model_path = NULL; + } + else + { + globalGraphical.model_path = strdup(value);/*Don't forget update UI*/ + tmp = strdup(globalGraphical.model_path); + a = strrchr(tmp,'.'); + format = malloc(sizeof (char) * (strlen(a) - 1)); + for (i = 0; i <= strlen(a) - 1; i++) + format[i] = a[i + 1]; + if (strcmp(format, "md2") || strcmp(format, "obj") || !strcmp(format, "ply")) + { + fprintf(stdout, "\nUnsupported fromat file\n"); + globalGraphical.model_path = NULL; + } + free(format); + free(tmp); + } + } + else if (!strcmp("count", key)) + globalGraphical.count = atoi(value); + else if (!strcmp("speed", key)) + globalGraphical.speed = atoi(value); + else if (!strcmp("precision", key)) + globalGraphical.precision = atoi(value); + else if (!strcmp("angle", key)) + globalGraphical.angle = atoi(value); + + return EINA_TRUE; +} + +static Eina_Bool +_xml_get_data(void *data, Eina_Simple_XML_Type type, const char *content, + unsigned offset, unsigned length) +{ + char str[512]; + switch (type) + { + case EINA_SIMPLE_XML_OPEN: + { + if (!strncmp("modelpath", content, strlen("modelpath"))) + { + const char *tags = eina_simple_xml_tag_attributes_find(content, length); + eina_simple_xml_attributes_parse(tags, length - (tags - content), _xml_attr_data, str); + } + else if (!strncmp("modelcount", content, strlen("modelcount"))) + { + const char *tags = eina_simple_xml_tag_attributes_find(content, length); + eina_simple_xml_attributes_parse(tags, length - (tags - content), _xml_attr_data, str); + } + else if (!strncmp("animspeed", content, strlen("animspeed"))) + { + const char *tags = eina_simple_xml_tag_attributes_find(content, length); + eina_simple_xml_attributes_parse(tags, length - (tags - content), _xml_attr_data, str); + } + else if (!strncmp("sphereprecision", content, strlen("sphereprecision"))) + { + const char *tags = eina_simple_xml_tag_attributes_find(content, length); + eina_simple_xml_attributes_parse(tags, length - (tags - content), _xml_attr_data, str); + } + else if (!strncmp("perspective", content, strlen("perspective"))) + { + const char *tags = eina_simple_xml_tag_attributes_find(content, length); + eina_simple_xml_attributes_parse(tags, length - (tags - content), _xml_attr_data, str); + } + } + default: + break; + } + + return EINA_TRUE; +} + +static void _init_graphical() +{ + Eina_File *config = NULL; + char *buffer = NULL; + config = eina_file_open("initial_config.xml", EINA_FALSE); + /*Set default values*/ + globalGraphical.count = 1; + globalGraphical.speed = 10; + globalGraphical.precision = 100; + globalGraphical.angle = 120; + globalGraphical.img = NULL; + globalGraphical.init_scene = _init_scene; + globalGraphical.change_scene_setup = _change_scene_setup; + globalGraphical.flags.shadow_enable = EINA_FALSE; + globalGraphical.flags.fog_enable = EINA_FALSE; + globalGraphical.flags.colorpick_enable = EINA_FALSE; + globalGraphical.flags.blend_enable = EINA_FALSE; + globalGraphical.flags.fps_enable = EINA_FALSE; + globalGraphical.model_path = NULL; + + if (!config) + fprintf(stdout, "Could not open initial_config.xml, count=4, speed=10, precision=100, perspective=120"); + else + { + buffer = (char*)(eina_file_map_all(config, EINA_FILE_RANDOM)); + eina_simple_xml_parse(buffer, eina_file_size_get(config), EINA_TRUE, _xml_get_data, NULL); + eina_file_close(config); + } +} +Evas_Object * +init_graphical_window(Evas_Object *img) +{ + _init_graphical(); + globalGraphical.evas = evas_object_evas_get(img); + _init_scene(img); + eo_do(img, evas_obj_image_scene_set(globalGraphical.scene)); + + return img; +} + diff --git a/src/examples/perfomance/graphical_struct.h b/src/examples/perfomance/graphical_struct.h new file mode 100644 index 0000000..a38806d --- /dev/null +++ b/src/examples/perfomance/graphical_struct.h @@ -0,0 +1,90 @@ +#ifndef GRAPHICAL_STRUCT_H +#define GRAPHICAL_STRUCT_H + +typedef struct _vec4 +{ + float x; + float y; + float z; + float w; +} vec4; + +typedef struct _vec3 +{ + float x; + float y; + float z; +} vec3; + +typedef struct _vec2 +{ + float x; + float y; +} vec2; +typedef struct _vertex +{ + vec3 position; + vec3 normal; + vec3 tangent; + vec4 color; + vec3 texcoord; +} vertex; + +typedef struct _place +{ + vec3 position; +} place; + +typedef struct _Flags_Change +{ + Eina_Bool fog_enable; + Eina_Bool shadow_enable; + Eina_Bool colorpick_enable; + Eina_Bool blend_enable; + Eina_Bool fps_enable; +} Changes; + +typedef struct _Graphical +{ + Evas *evas; + Evas_Object *img; + Eo *scene; + Eo *root_node; + Eo *light_node; + Eo *light; + Eo *camera_node; + Eo *camera; + Eo *mesh_node; + Eo *mesh; + Eo *material; + Eo *material_box; + Eo *texture; + Eo *mesh_box; + Eo *mesh_nodebox; + Eo *texture_box; + + Eina_List *list_nodes; + Eina_List *list_meshes; + + const char *model_path; + + void (*init_scene)(); + void (*change_scene_setup)(); + + vertex *vertices; + place *places; + unsigned short *indices; + int index_count; + int vertex_count; + + int count; + int speed; + int precision; + int angle; + + Changes flags; + +} Graphical; + +extern Graphical globalGraphical; +#endif diff --git a/src/examples/perfomance/initial_config.xml b/src/examples/perfomance/initial_config.xml new file mode 100644 index 0000000..b058b60 --- /dev/null +++ b/src/examples/perfomance/initial_config.xml @@ -0,0 +1,11 @@ +<!--Use it for initial loading --> +<?xml version="1.0" encoding="UTF-8"?> +<approot> + <defvalues> + <modelpath path="none"></modelpath> + <modelcount count="2"></modelcount> + <animspeed speed="100"></animspeed> + <sphereprecision precision="10"></sphereprecision> + <perspective angle="120"></perspective> + </defvalues> +</approot> diff --git a/src/examples/perfomance/layout.edc b/src/examples/perfomance/layout.edc new file mode 100644 index 0000000..52430d4 --- /dev/null +++ b/src/examples/perfomance/layout.edc @@ -0,0 +1,170 @@ +collections { + group { name: "new/layout/0"; + broadcast_signal: 0; + parts { + part { name: "area.bg"; + type: SPACER; + description { state: "default" 0; + align: 0.0 0.0; + min: 1000 600; + } + } + part { name: "area.controls"; + type: SPACER; + description { state: "default" 0; + align: 0.0 0.0; + min: 800 110; + max: -1 110; + rel1 { + to: "area.bg"; + } + rel2 { + to: "area.bg"; + } + } + } + part { name: "area.content"; + type: SPACER; + description { state: "default" 0; + align: 0.0 0.0; + rel1 { + to: "area.bg"; + } + rel2 { + to: "area.bg"; + } + } + } + part { name: "padding.controls.rel1"; + type: SPACER; + description { state: "default" 0; + align: 0 0; + max: 5 5; + rel1 { + to: "area.controls"; + } + rel2 { + to: "area.controls"; + } + } + } + part { name: "padding.controls.rel2"; + type: SPACER; + description { state: "default" 0; + align: 1 1; + min: 5 5; + max: 5 5; + fixed: 1 1; + rel1 { + to: "area.controls"; + } + rel2 { + relative: 1 0; + to: "area.content"; + } + } + } + part { name: "swallow.content"; + type: SWALLOW; + description { state: "default" 0; + align: 0 0; + min: 800 600; + rel1 { + to: "area.content"; + } + rel2 { + to: "area.content"; + } + } + } + part { name: "swallow.btn.startexit"; + type: SWALLOW; + description { state: "default" 0; + align: 0 0; + min: 800 50; + max: -1 50; + fixed: 1 1; + rel1 { + relative: 1 1; + to: "padding.controls.rel1"; + } + rel2 { + relative: 0 0; + offset: 0 0; + to: "padding.controls.rel2"; + } + } + } + part { name: "swallow.controls.btn"; + type: SWALLOW; + description { state: "default" 0; + align: 0 0; + min: 800 20; + max: -1 20; + fixed: 1 1; + rel1 { + relative: 0 1; + to: "padding1"; + } + rel2 { + relative: 0 0; + to: "padding.controls.rel2"; + } + } + } + part { name: "new_features"; + type: SWALLOW; + description { state: "default" 0; + align: 0 0; + min: 800 20; + max: -1 20; + fixed: 1 1; + rel1 { + relative: 0 1; + offset: -1 -1; + to: "padding5"; + } + rel2 { + relative: 0 0; + to: "padding.controls.rel2"; + } + } + } + part { name: "padding1"; + type: SPACER; + description { state: "default" 0; + align: 0 0; + min: 0 5; + max: -1 5; + fixed: 1 1; + rel1 { + relative: 1 1; + to_x: "padding.controls.rel1"; + to_y: "swallow.btn.startexit"; + } + rel2 { + relative: 0 0; + to: "padding.controls.rel2"; + } + } + } + part { name: "padding5"; + type: SPACER; + description { state: "default" 0; + align: 0 0; + min: 0 5; + max: -1 5; + fixed: 1 1; + rel1 { + relative: 0 1; + to: "swallow.controls.btn"; + } + rel2 { + relative: 0 1; + to: "padding.controls.rel2"; + } + } + } + } + } +} diff --git a/src/examples/perfomance/perfomance.c b/src/examples/perfomance/perfomance.c new file mode 100644 index 0000000..d054b29 --- /dev/null +++ b/src/examples/perfomance/perfomance.c @@ -0,0 +1,972 @@ +/** + * Example for testing perfomance of Evas 3D library + * + * Program should be runned with 4 parameters: + * 1 - count parameter (NP) + * 2 - speed parameter (SP) + * 3 - precision parameter (PP) + * 4 - camera parameter (CP) + * + * NP sets number of spheres. Count of spheres is (NP+1)^2. + * SP sets speed of rotation. One revolution of root node takes 1200/SP seconds. It is count of calculation of position per second. + * PP sets number of sphere's vertices. Count of vertices is (NP+1)^2. + * CP sets camera's perspective angle in degrees. + * + * Right click of mouse show/hide navigation panel + * + * @verbatim + * Just use script ./run with key -a: enable automation testing, -l: change which only in local repository, -p: disable navigation panel + * @endverbatim + */ + +#define EFL_EO_API_SUPPORT +#define EFL_BETA_API_SUPPORT + +/*enable automation test*/ +#ifdef ENABLE_ATPORT + #include "at_port.h" +#endif + +#include <math.h> +#include <stdlib.h> +#include <time.h> +#include <stdio.h> +#include <stdlib.h> + + +#include <Eo.h> +#include <Evas.h> +#include <Ecore.h> +#include <Ecore_Evas.h> +#include <Elementary.h> + +#include "Tools.h" + +#include "graphical_struct.h" + +#define CONVERT 20 +#define WIDTH 1000 +#define HEIGHT 600 + +Graphical globalGraphical; + +/*Variable for fps*/ +int fps_frames = 0; + +void _clear_buf(char *buf) +{ + int i; + for (i = 0; i < CONVERT; i++) + buf[i] = '\0'; +} + +void _value_int_to_char(char *buf, int value, const char *description) +{ + _clear_buf(buf); + if (description) + sprintf(buf, "%s %d", description, value); + else + sprintf(buf, "%d", value); +} + +static Eina_Bool +_timer_update(void *data) +{ + fprintf(stdout, " frame rate = %f fps\n", fps_frames / 10.0); + fps_frames = 0; + return EINA_TRUE; +} +static Eina_Bool +_animate_scene(void *data) +{ + Eina_List *l; + Evas_3D_Node *node; + + static float angle = 0.0f; + angle += 0.03; + + eo_do((Evas_3D_Node *)data, + evas_3d_node_look_at_set(EVAS_3D_SPACE_PARENT, 8 * sin(angle), 0.0, 8 * cos(angle), + EVAS_3D_SPACE_PARENT, 0.0, 1.0, 0.0)); + + EINA_LIST_FOREACH (globalGraphical.list_nodes, l, node) + { + eo_do(node, evas_3d_node_orientation_angle_axis_set(10 * angle, 1.0, 1.0, 0.0)); + } + + /* Rotate */ + if (angle > 360.0) angle -= 360.0f; + + fps_frames++; + + return EINA_TRUE; +} + + +static void +_on_mouse_down(void *data, Evas *e EINA_UNUSED, Evas_Object *obj, + void *event_info) +{ + Evas_Event_Mouse_Down *ev = event_info; + Evas_Coord x, y, w, h; + Evas_Coord obj_x, obj_y; + int scene_w, scene_h; + Evas_Real scene_x, scene_y; + Evas_Real s, t; + Evas_3D_Node *n; + Evas_3D_Mesh *m; + Eina_Bool pick; + clock_t time; + float diff_sec; + if (ev->button == 3) + { + if (evas_object_visible_get((Evas_Object*)data)) + evas_object_hide((Evas_Object*)data); + else + evas_object_show((Evas_Object*)data); + } + else + { + evas_object_geometry_get(obj, &x, &y, &w, &h); + + obj_x = ev->canvas.x - x; + obj_y = ev->canvas.y - y; + + eo_do(globalGraphical.scene, evas_3d_scene_size_get(&scene_w, &scene_h)); + + scene_x = obj_x * scene_w / (Evas_Real)w; + scene_y = obj_y * scene_h / (Evas_Real)h; + + time = clock(); + if (globalGraphical.flags.colorpick_enable) + { + eo_do(globalGraphical.scene, pick = evas_3d_scene_color_pick_enable_set(EINA_TRUE)); + eo_do(globalGraphical.scene, + pick = evas_3d_scene_pick(ev->canvas.x, ev->canvas.y, &n, &m, NULL, NULL)); + time = clock() - time; + diff_sec = ((float)time) / CLOCKS_PER_SEC / 10; + if (pick) + { + fprintf(stdout, "Boom! Color pick time expended for pick: %2.7f \n", diff_sec); + if (n != globalGraphical.mesh_nodebox) + eo_do(n, evas_3d_node_scale_set(0.5, 0.5, 0.5)); + } + } + else + { + eo_do(globalGraphical.scene, pick = evas_3d_scene_color_pick_enable_set(EINA_FALSE)); + eo_do(globalGraphical.scene, pick = evas_3d_scene_pick(scene_x, scene_y, &n, &m, &s, &t)); + time = clock() - time; + diff_sec = ((float)time) / CLOCKS_PER_SEC / 10; + if (pick) + { + fprintf(stdout, "Boom! Geometry pick time expended for pick: %2.7f, TexCoord (%f, %f)\n", diff_sec, s, t); + if (n != globalGraphical.mesh_nodebox) + eo_do(n, evas_3d_node_scale_set(0.5, 0.5, 0.5)); + } + } + } +} +static void +_btnstart_cb(void *data, Evas_Object *obj, void *event_info) +{ + globalGraphical.change_scene_setup(); +} + +static void +_btnexit_cb(void *data, Evas_Object *obj, void *event_info) +{ + elm_exit(); +} + +static void +_btnstop_cb(void *data, Evas_Object *obj, void *event_info) +{ + const char *status = NULL; + status = elm_object_text_get(obj); + if (status != NULL && !strcmp(status, "Stop")) + { + elm_object_text_set(obj, "Start"); + ecore_animator_freeze((Ecore_Animator *)data); + } + else + { + elm_object_text_set(obj, "Stop"); + ecore_animator_thaw((Ecore_Animator *)data); + } +} +static void +_node_orientation_change_cb(void *data, Evas_Object *obj, void *event_info) +{ + Elm_Object_Item *it; + Eina_List *l; + Evas_3D_Node *node; + it = elm_flipselector_selected_item_get((Evas_Object*)data); + const char *str = elm_object_item_text_get(it); + if (str && !strcmp(str, "root node")) + eo_do(globalGraphical.root_node, evas_3d_node_orientation_angle_axis_set(15, 1.0, 1.0, 1.0)); + else + { + EINA_LIST_FOREACH (globalGraphical.list_nodes, l, node) + { + eo_do((Eo*)node, evas_3d_node_orientation_angle_axis_set(15, 1.0, 1.0, 1.0)); + } + } +} +static void +_node_position_change_cb(void *data, Evas_Object *obj, void *event_info) +{ + Elm_Object_Item *it; + Eina_List *l; + Evas_3D_Node *node; + it = elm_flipselector_selected_item_get((Evas_Object*)data); + const char *str = elm_object_item_text_get(it); + if (str && !strcmp(str, "root node")) + eo_do(globalGraphical.root_node, evas_3d_node_position_set(10.0, 1.0, 1.0)); + else + { + EINA_LIST_FOREACH (globalGraphical.list_nodes, l, node) + { + eo_do((Eo*)node, evas_3d_node_position_set(1.0, 1.0, 1.0)); + } + } +} +static void +_node_scale_change_cb(void *data, Evas_Object *obj, void *event_info) +{ + Elm_Object_Item *it; + Eina_List *l; + Evas_3D_Node *node; + it = elm_flipselector_selected_item_get((Evas_Object*)data); + const char *str = elm_object_item_text_get(it); + if (str && !strcmp(str, "root node")) + eo_do(globalGraphical.root_node, evas_3d_node_scale_set(1.0, 1.0, 1.0)); + else + { + EINA_LIST_FOREACH (globalGraphical.list_nodes, l, node) + { + eo_do((Eo*)node, evas_3d_node_scale_set(1.0, 1.0, 1.0)); + } + } +} +static void +_countdec10_cb(void *data, Evas_Object *obj, void *event_info) +{ + char buf[CONVERT]; + int tmp; + + globalGraphical.count -= 10; + if (globalGraphical.count < 0) tmp = globalGraphical.count = 0; + else + tmp = ((globalGraphical.count + 1) * (globalGraphical.count + 1)); + + _value_int_to_char(buf, ((tmp <= 1) ? 0 : tmp), "quantity:"); + elm_object_text_set((Evas_Object*)data, buf); +} + +static void +_countdec_cb(void *data, Evas_Object *obj, void *event_info) +{ + char buf[CONVERT]; + int tmp; + globalGraphical.count--; + if (globalGraphical.count < 0) tmp = globalGraphical.count = 0; + else + tmp = ((globalGraphical.count + 1) * (globalGraphical.count + 1)); + _value_int_to_char(buf, ((tmp <= 1) ? 0 : tmp), "quantity:"); + elm_object_text_set((Evas_Object*)data, buf); +} + +static void +_countinc_cb(void *data, Evas_Object *obj, void *event_info) +{ + char buf[CONVERT]; + + globalGraphical.count++; + + _value_int_to_char(buf, ((globalGraphical.count + 1) * (globalGraphical.count + 1)), "quantity:"); + elm_object_text_set((Evas_Object*)data, buf); +} + +static void +_countinc10_cb(void *data, Evas_Object *obj, void *event_info) +{ + char buf[CONVERT]; + + globalGraphical.count += 10; + + _value_int_to_char(buf, ((globalGraphical.count + 1) * (globalGraphical.count + 1)), "quantity:"); + elm_object_text_set((Evas_Object*)data, buf); +} + +static void +_speeddec10_cb(void *data, Evas_Object *obj, void *event_info) +{ + char buf[CONVERT]; + + globalGraphical.speed -= 10; + if (globalGraphical.speed <= 0) globalGraphical.speed = 10; + + _value_int_to_char(buf, globalGraphical.speed, "speed:"); + elm_object_text_set((Evas_Object*)data, buf); +} + +static void +_speeddec_cb(void *data, Evas_Object *obj, void *event_info) +{ + char buf[CONVERT]; + + globalGraphical.speed--; + if (globalGraphical.speed <= 0) globalGraphical.speed = 10; + + _value_int_to_char(buf, globalGraphical.speed, "speed:"); + elm_object_text_set((Evas_Object*)data, buf); +} + +static void +_speedinc_cb(void *data, Evas_Object *obj, void *event_info) +{ + char buf[CONVERT]; + + globalGraphical.speed++; + + _value_int_to_char(buf, globalGraphical.speed, "speed:"); + elm_object_text_set((Evas_Object*)data, buf); +} + +static void +_speedinc10_cb(void *data, Evas_Object *obj, void *event_info) +{ + char buf[CONVERT]; + + globalGraphical.speed += 10; + + _value_int_to_char(buf, globalGraphical.speed, "speed:"); + elm_object_text_set((Evas_Object*)data, buf); +} + +static void +_precisiondec10_cb(void *data, Evas_Object *obj, void *event_info) +{ + char buf[CONVERT]; + + globalGraphical.precision -= 10; + if (globalGraphical.precision <= 0) globalGraphical.precision = 10; + + _value_int_to_char(buf, globalGraphical.precision, "precision:"); + elm_object_text_set((Evas_Object*)data, buf); +} + +static void +_precisiondec_cb(void *data, Evas_Object *obj, void *event_info) +{ + char buf[CONVERT]; + + globalGraphical.precision--; + if (globalGraphical.precision <= 0) globalGraphical.precision = 10; + + _value_int_to_char(buf, globalGraphical.precision, "precision:"); + elm_object_text_set((Evas_Object*)data, buf); +} + +static void +_precisioninc_cb(void *data, Evas_Object *obj, void *event_info) +{ + char buf[CONVERT]; + + globalGraphical.precision++; + + _value_int_to_char(buf, globalGraphical.precision, "precision:"); + elm_object_text_set((Evas_Object*)data, buf); +} + +static void +_precisioninc10_cb(void *data, Evas_Object *obj, void *event_info) +{ + char buf[CONVERT]; + + globalGraphical.precision += 10; + + _value_int_to_char(buf, globalGraphical.precision, "precision:"); + elm_object_text_set((Evas_Object*)data, buf); + +} + +static void +_angledec10_cb(void *data, Evas_Object *obj, void *event_info) +{ + char buf[CONVERT]; + + globalGraphical.angle -= 10; + if (globalGraphical.angle <= 0) globalGraphical.angle = 10; + + _value_int_to_char(buf, globalGraphical.angle, "angle:"); + elm_object_text_set((Evas_Object*)data, buf); +} + +static void +_angledec_cb(void *data, Evas_Object *obj, void *event_info) +{ + char buf[CONVERT]; + + globalGraphical.angle--; + if (globalGraphical.angle <= 0) globalGraphical.angle = 10; + + _value_int_to_char(buf, globalGraphical.angle, "angle:"); + elm_object_text_set((Evas_Object*)data, buf); +} + +static void +_angleinc_cb(void *data, Evas_Object *obj, void *event_info) +{ + char buf[CONVERT]; + + globalGraphical.angle++; + if (globalGraphical.angle >= 180) globalGraphical.angle = 180; + _value_int_to_char(buf, globalGraphical.angle, "angle:"); + elm_object_text_set((Evas_Object*)data, buf); +} + +static void +_angleinc10_cb(void *data, Evas_Object *obj, void *event_info) +{ + char buf[CONVERT]; + + globalGraphical.angle += 10; + if (globalGraphical.angle >= 180) globalGraphical.angle = 180; + + _value_int_to_char(buf, globalGraphical.angle, "angle:"); + elm_object_text_set((Evas_Object*)data, buf); +} + +static void +_shadow_enable(void *data, Evas_Object *obj, void *event_info) +{ + if (elm_check_state_get(obj)) + globalGraphical.flags.shadow_enable = EINA_TRUE; + else + globalGraphical.flags.shadow_enable = EINA_FALSE; +} + +static void +_colorpick_enable(void *data, Evas_Object *obj, void *event_info) +{ + if (elm_check_state_get(obj)) + globalGraphical.flags.colorpick_enable = EINA_TRUE; + else + globalGraphical.flags.colorpick_enable = EINA_FALSE; +} + +static void +_fog_enable(void *data, Evas_Object *obj, void *event_info) +{ + if (elm_check_state_get(obj)) + globalGraphical.flags.fog_enable = EINA_TRUE; + else + globalGraphical.flags.fog_enable = EINA_FALSE; +} + +static void +_blend_enable(void *data, Evas_Object *obj, void *event_info) +{ + if (elm_check_state_get(obj)) + globalGraphical.flags.blend_enable = EINA_TRUE; + else + globalGraphical.flags.blend_enable = EINA_FALSE; +} + +static void +_cb_fps_enable(void *data, Evas_Object *obj, void *event_info) +{ + if (elm_check_state_get(obj)) + { + globalGraphical.flags.fps_enable = EINA_TRUE; + ecore_timer_thaw((Ecore_Timer *)data); + fps_frames = 0; + } + else + { + globalGraphical.flags.fps_enable = EINA_FALSE; + ecore_timer_freeze((Ecore_Timer *)data); + fps_frames = 0; + } +} + +static void +_load_mesh(void *data, Evas_Object *obj, void *event_info) +{ + char *format = NULL, *tmp = NULL, *a = NULL; + char name[FILENAME_MAX]; + int i = 0, j = 0; + if (event_info) tmp = strdup(event_info); + if (data) tmp = strdup((char *)data); + if (tmp) + { + tmp = strdup(event_info); + /*Get filename in backward*/ + for (i = strlen(tmp) - 1; i >= 0; i--, j++) + { + if (tmp[i] != '/') + name[j] = tmp[i]; + else + { + name[j] = '\0'; + break; + } + } + free(tmp); + tmp = NULL; + j = 0; + /*Reverse filename*/ + tmp = strdup(name); + for (i = strlen(tmp) - 1; i >= 0 ; i--, j++) + name[j] = tmp[i]; + + free(tmp); + free(a); + tmp = NULL; + a = NULL; + /*Get extention of file*/ + tmp = strdup(event_info); + a = strrchr(tmp,'.'); + format = malloc(sizeof (char) * (strlen(a) - 1)); + for (i = 0; i <= strlen(a) - 1; i++) + format[i] = a[i + 1]; + if (!strcmp(format, "md2")) + { + globalGraphical.model_path = event_info; + elm_object_text_set(obj, name); + } + else if (!strcmp(format, "obj")) + { + globalGraphical.model_path = event_info; + elm_object_text_set(obj, name); + } + else if (!strcmp(format, "ply")) + { + globalGraphical.model_path = event_info; + elm_object_text_set(obj, name); + } + else + { + fprintf(stdout, "\nUnsupported fromat file\n"); + globalGraphical.model_path = NULL; + elm_object_text_set(obj, "load"); + } + free(format); + free(tmp); + } + else + { + globalGraphical.model_path = NULL; + elm_object_text_set(obj, "load"); + } +} + +EAPI_MAIN + int elm_main(int argc, char **argv) +{ + Evas *evas = NULL; + const char *engine; + Evas_Object *win = NULL, *bg = NULL, *image = NULL; + Ecore_Animator *timer = NULL; + Evas_Object *layout = NULL; + Evas_Object *btnstart = NULL, *btnexit = NULL, *btnstop = NULL; + Evas_Object *startexitbox = NULL,*testbox = NULL, *controlbox = NULL, *newfeaturesbox = NULL; + Evas_Object *countdec10 = NULL, *countinc = NULL, *countdec = NULL, *countinc10 = NULL; + Evas_Object *speeddec10 = NULL, *speedinc = NULL, *speeddec = NULL, *speedinc10 = NULL; + Evas_Object *precisiondec10 = NULL, *precisioninc = NULL, *precisiondec = NULL, *precisioninc10 = NULL; + Evas_Object *vcount = NULL, *vspeed = NULL, *vprecision = NULL, *vangle = NULL; + Evas_Object *angledec10 = NULL, *angleinc = NULL, *angledec = NULL, *angleinc10 = NULL; + Evas_Object *cb_shadow = NULL, *cb_colorpick = NULL, *cb_fog = NULL, *cb_blend = NULL, *cb_fps = NULL; + Evas_Object *fs_bt = NULL; + Evas_Object *navigation = NULL; + Evas_Object *fs_node = NULL, *bt_orientation = NULL, *bt_position = NULL, *bt_scale = NULL; + Ecore_Timer *fps_timer = NULL; + char buf[CONVERT]; + +#ifdef ENABLE_ATPORT + at_port_h mf_at_port = NULL; +#endif + + if (!elm_init(0, 0)) return 1; + + elm_config_engine_set("software_x11"); + engine = elm_config_engine_get(); + + if (engine != NULL && strcmp("software_x11", engine)) + { + fprintf(stdout, "There is elementary not support OpenGL engine"); + exit(1); + } + + elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED); + win = elm_win_add(NULL, "3D Perfomance", ELM_WIN_BASIC); + evas_object_resize(win, WIDTH, HEIGHT); + elm_win_autodel_set(win, EINA_TRUE); + evas_object_show(win); + +#ifdef ENABLE_ATPORT + at_port_create(&(mf_at_port), win); + if(mf_at_port != NULL) + { + at_port_enable(mf_at_port); + } +#endif + + bg = elm_bg_add(win); + evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + elm_bg_file_set(bg, "backgroung.png", NULL); + elm_win_resize_object_add(win, bg); + evas_object_show(bg); + + layout = elm_layout_add(win); + evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL); + elm_win_resize_object_add(win, layout); + elm_layout_file_set(layout, "layout.edj", "new/layout/0"); + evas_object_show(layout); + + startexitbox = elm_box_add(win); + elm_box_horizontal_set(startexitbox, EINA_TRUE); + elm_object_part_content_set(layout, "swallow.btn.startexit", startexitbox); + evas_object_size_hint_weight_set(startexitbox, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(startexitbox, EVAS_HINT_FILL, EVAS_HINT_FILL); + elm_box_homogeneous_set(startexitbox, EINA_TRUE); + evas_object_show(startexitbox); + + evas = evas_object_evas_get(win); + image = evas_object_image_add(evas); + + btnstart = elm_button_add(win); + elm_object_text_set(btnstart, "Apply"); + evas_object_size_hint_weight_set(btnstart, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(btnstart, EVAS_HINT_FILL, EVAS_HINT_FILL); + elm_box_pack_end(startexitbox, btnstart); + evas_object_show(btnstart); + evas_object_smart_callback_add(btnstart, "clicked", _btnstart_cb, image); + + testbox = elm_box_add(win); + elm_box_horizontal_set(testbox, EINA_TRUE); + elm_box_homogeneous_set(testbox, EINA_TRUE); + elm_box_pack_end(startexitbox, testbox); + evas_object_show(testbox); + + btnstop = elm_button_add(win); + elm_object_text_set( btnstop, "Stop"); + elm_box_pack_end(testbox, btnstop); + evas_object_size_hint_weight_set(btnstop, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(btnstop, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(btnstop); + + fs_node = elm_flipselector_add(win); + elm_box_pack_end(testbox, fs_node); + elm_flipselector_item_append(fs_node, "root node", NULL, NULL); + elm_flipselector_item_append(fs_node, "mesh node", NULL, NULL); + evas_object_size_hint_weight_set(btnstop, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(btnstop, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(fs_node); + + bt_orientation = elm_button_add(win); + elm_object_text_set(bt_orientation, "Orientation"); + elm_box_pack_end(testbox, bt_orientation); + evas_object_size_hint_weight_set(bt_orientation, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(bt_orientation, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(bt_orientation); + evas_object_smart_callback_add(bt_orientation, "clicked", _node_orientation_change_cb, fs_node); + + bt_position = elm_button_add(win); + elm_object_text_set(bt_position, "Position"); + elm_box_pack_end(testbox, bt_position); + evas_object_size_hint_weight_set(bt_position, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(bt_position, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(bt_position); + evas_object_smart_callback_add(bt_position, "clicked", _node_position_change_cb, fs_node); + + bt_scale = elm_button_add(win); + elm_object_text_set(bt_scale, "Scale"); + elm_box_pack_end(testbox, bt_scale); + evas_object_size_hint_weight_set(bt_scale, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(bt_scale, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(bt_scale); + evas_object_smart_callback_add(bt_scale, "clicked", _node_scale_change_cb, fs_node); + + btnexit = elm_button_add(win); + elm_object_text_set(btnexit, "Exit"); + elm_box_pack_end(startexitbox, btnexit); + evas_object_size_hint_weight_set(btnexit, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(btnexit, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(btnexit); + evas_object_smart_callback_add(btnexit, "clicked", _btnexit_cb, NULL); + + controlbox = elm_box_add(win); + elm_box_horizontal_set(controlbox, EINA_TRUE); + elm_object_part_content_set(layout, "swallow.controls.btn", controlbox); + evas_object_size_hint_weight_set(controlbox, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(controlbox, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(controlbox); + + vcount = elm_label_add(win); + _value_int_to_char(buf, 121, "quantity:"); + elm_object_text_set(vcount, buf); + + countdec10 = elm_button_add(win); + elm_object_text_set(countdec10, "<<"); + elm_box_pack_end(controlbox, countdec10); + evas_object_size_hint_weight_set(countdec10, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(countdec10, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(countdec10); + evas_object_smart_callback_add(countdec10, "clicked", _countdec10_cb, vcount); + + countdec = elm_button_add(win); + elm_object_text_set(countdec, "<"); + elm_box_pack_end(controlbox, countdec); + evas_object_size_hint_weight_set(countdec, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(countdec, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(countdec); + evas_object_smart_callback_add(countdec, "clicked", _countdec_cb, vcount); + + elm_box_pack_end(controlbox, vcount); + evas_object_show(vcount); + + countinc = elm_button_add(win); + elm_object_text_set(countinc, ">"); + elm_box_pack_end(controlbox, countinc); + evas_object_size_hint_weight_set(countinc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(countinc, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(countinc); + evas_object_smart_callback_add(countinc, "clicked", _countinc_cb, vcount); + + countinc10 = elm_button_add(win); + elm_object_text_set(countinc10, ">>"); + elm_box_pack_end(controlbox, countinc10); + evas_object_size_hint_weight_set(countinc10, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(countinc10, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(countinc10); + evas_object_smart_callback_add(countinc10, "clicked", _countinc10_cb, vcount); + + vspeed = elm_label_add(win); + _value_int_to_char(buf, 30, "speed:"); + elm_object_text_set(vspeed, buf); + + speeddec10 = elm_button_add(win); + elm_object_text_set(speeddec10, "<<"); + elm_box_pack_end(controlbox, speeddec10); + evas_object_size_hint_weight_set(speeddec10, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(speeddec10, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(speeddec10); + evas_object_smart_callback_add(speeddec10, "clicked", _speeddec10_cb, vspeed); + + speeddec = elm_button_add(win); + elm_object_text_set(speeddec, "<"); + elm_box_pack_end(controlbox, speeddec); + evas_object_size_hint_weight_set(speeddec, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(speeddec, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(speeddec); + evas_object_smart_callback_add(speeddec, "clicked", _speeddec_cb, vspeed); + + elm_box_pack_end(controlbox, vspeed); + evas_object_show(vspeed); + + speedinc = elm_button_add(win); + elm_object_text_set(speedinc, ">"); + elm_box_pack_end(controlbox, speedinc); + evas_object_size_hint_weight_set(speedinc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(speedinc, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(speedinc); + evas_object_smart_callback_add(speedinc, "clicked", _speedinc_cb, vspeed); + + speedinc10 = elm_button_add(win); + elm_object_text_set(speedinc10, ">>"); + elm_box_pack_end(controlbox, speedinc10); + evas_object_size_hint_weight_set(speedinc10, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(speedinc10, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(speedinc10); + evas_object_smart_callback_add(speedinc10, "clicked", _speedinc10_cb, vspeed); + + vprecision = elm_label_add(win); + _value_int_to_char(buf, 100, "precision:"); + elm_object_text_set(vprecision, buf); + + precisiondec10 = elm_button_add(win); + elm_object_text_set(precisiondec10, "<<"); + elm_box_pack_end(controlbox, precisiondec10); + evas_object_size_hint_weight_set(precisiondec10, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(precisiondec10, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(precisiondec10); + evas_object_smart_callback_add(precisiondec10, "clicked", _precisiondec10_cb, vprecision); + + precisiondec = elm_button_add(win); + elm_object_text_set(precisiondec, "<"); + elm_box_pack_end(controlbox, precisiondec); + evas_object_size_hint_weight_set(precisiondec, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(precisiondec, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(precisiondec); + evas_object_smart_callback_add(precisiondec, "clicked", _precisiondec_cb, vprecision); + + elm_box_pack_end(controlbox, vprecision); + evas_object_show(vprecision); + + precisioninc = elm_button_add(win); + elm_object_text_set(precisioninc, ">"); + elm_box_pack_end(controlbox, precisioninc); + evas_object_size_hint_weight_set(precisioninc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(precisioninc, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(precisioninc); + evas_object_smart_callback_add(precisioninc, "clicked", _precisioninc_cb, vprecision); + + precisioninc10 = elm_button_add(win); + elm_object_text_set(precisioninc10, ">>"); + elm_box_pack_end(controlbox, precisioninc10); + evas_object_size_hint_weight_set(precisioninc10, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(precisioninc10, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(precisioninc10); + evas_object_smart_callback_add(precisioninc10, "clicked", _precisioninc10_cb, vprecision); + + vangle = elm_label_add(win); + _value_int_to_char(buf, 120, "angle:"); + elm_object_text_set(vangle, buf); + + angledec10 = elm_button_add(win); + elm_object_text_set(angledec10, "<<"); + elm_box_pack_end(controlbox, angledec10); + evas_object_size_hint_weight_set(angledec10, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(angledec10, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(angledec10); + evas_object_smart_callback_add(angledec10, "clicked", _angledec10_cb, vangle); + + angledec = elm_button_add(win); + elm_object_text_set(angledec, "<"); + elm_box_pack_end(controlbox, angledec); + evas_object_size_hint_weight_set(angledec, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(angledec, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(angledec); + evas_object_smart_callback_add(angledec, "clicked", _angledec_cb, vangle); + + elm_box_pack_end(controlbox, vangle); + evas_object_show(vangle); + + angleinc = elm_button_add(win); + elm_object_text_set(angleinc, ">"); + elm_box_pack_end(controlbox, angleinc); + evas_object_size_hint_weight_set(angleinc, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(angleinc, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(angleinc); + evas_object_smart_callback_add(angleinc, "clicked", _angleinc_cb, vangle); + + angleinc10 = elm_button_add(win); + elm_object_text_set(angleinc10, ">>"); + elm_box_pack_end(controlbox, angleinc10); + evas_object_size_hint_weight_set(angleinc10, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(angleinc10, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(angleinc10); + evas_object_smart_callback_add(angleinc10, "clicked", _angleinc10_cb, vangle); + + newfeaturesbox = elm_box_add(win); + elm_box_horizontal_set(newfeaturesbox, EINA_TRUE); + elm_object_part_content_set(layout, "new_features", newfeaturesbox); + evas_object_size_hint_align_set(newfeaturesbox, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(newfeaturesbox); + + cb_shadow = elm_check_add(win); + elm_object_text_set(cb_shadow, "shadow"); + elm_check_state_set(cb_shadow, EINA_FALSE); + evas_object_size_hint_align_set(cb_shadow, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_smart_callback_add(cb_shadow, "changed", _shadow_enable, NULL); + elm_box_pack_end(newfeaturesbox, cb_shadow); + evas_object_show(cb_shadow); + + cb_fog = elm_check_add(win); + elm_object_text_set(cb_fog, "fog"); + elm_check_state_set(cb_fog, EINA_FALSE); + evas_object_size_hint_align_set(cb_fog, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_smart_callback_add(cb_fog, "changed", _fog_enable, NULL); + elm_box_pack_end(newfeaturesbox, cb_fog); + evas_object_show(cb_fog); + + cb_colorpick = elm_check_add(win); + elm_object_text_set(cb_colorpick, "colorpick"); + elm_check_state_set(cb_colorpick, EINA_FALSE); + evas_object_size_hint_align_set(cb_colorpick, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_smart_callback_add(cb_colorpick, "changed", _colorpick_enable, NULL); + elm_box_pack_end(newfeaturesbox, cb_colorpick); + evas_object_show(cb_colorpick); + + cb_blend = elm_check_add(win); + elm_object_text_set(cb_blend, "blend"); + elm_check_state_set(cb_blend, EINA_FALSE); + evas_object_size_hint_align_set(cb_blend, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_smart_callback_add(cb_blend, "changed", _blend_enable, NULL); + elm_box_pack_end(newfeaturesbox, cb_blend); +#ifndef LOCAL_REPOSITORY + elm_object_disabled_set(cb_blend, EINA_TRUE); +#endif + evas_object_show(cb_blend); + + cb_fps = elm_check_add(win); + elm_object_text_set(cb_fps, "fps"); + elm_check_state_set(cb_fps, EINA_FALSE); + evas_object_size_hint_align_set(cb_fps, EVAS_HINT_FILL, EVAS_HINT_FILL); + elm_box_pack_end(newfeaturesbox, cb_fps); + evas_object_show(cb_fps); + + /*Select model file*/ + fs_bt = elm_fileselector_button_add(win); + elm_fileselector_path_set(fs_bt, "."); + elm_object_text_set(fs_bt, "load"); + elm_fileselector_button_inwin_mode_set(fs_bt, EINA_TRUE); + evas_object_size_hint_align_set(fs_bt, EVAS_HINT_FILL, EVAS_HINT_FILL); + elm_box_pack_end(newfeaturesbox, fs_bt); + evas_object_show(fs_bt); + evas_object_smart_callback_add(fs_bt, "file,chosen", _load_mesh, NULL); + + evas_object_image_filled_set(image, EINA_TRUE); + elm_object_part_content_set(layout, "swallow.content", image); + evas_object_size_hint_weight_set(image, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(image, EVAS_HINT_FILL, EVAS_HINT_FILL); + evas_object_show(image); + evas_render(evas); //make edje do recalculation + image = init_graphical_window(image); + + /*Update data for count, speed, precision, angle*/ + _value_int_to_char(buf, (globalGraphical.count + 1) * (globalGraphical.count + 1), "quantity:"); + elm_object_text_set(vcount, buf); + _value_int_to_char(buf, globalGraphical.speed, "speed:"); + elm_object_text_set(vspeed, buf); + _value_int_to_char(buf, globalGraphical.precision, "precision:"); + elm_object_text_set(vprecision, buf); + _value_int_to_char(buf, globalGraphical.angle, "angle:"); + elm_object_text_set(vangle, buf); + if (globalGraphical.model_path) + evas_object_smart_callback_call(fs_bt, "file,chosen", (void *)globalGraphical.model_path); + + /*Create navigation panel*/ +#ifndef DISABLE_NAVIGATION_PANEL + navigation = init_panel_camera_light(win, globalGraphical.camera_node, globalGraphical.light_node, 1.0, 0.5); + panel_camera_coord_step_set(navigation, 5); + panel_camera_angle_step_set(navigation, 5); + panel_light_coord_step_set(navigation, 5); + panel_light_angle_step_set(navigation, 5); +#endif + + evas_object_event_callback_add(image, EVAS_CALLBACK_MOUSE_DOWN, + _on_mouse_down, navigation); + + ecore_animator_frametime_set(1.0 / (globalGraphical.speed)); + timer = ecore_animator_add(_animate_scene, globalGraphical.light_node); + fps_timer = ecore_timer_add(10, _timer_update, NULL); + ecore_timer_freeze(fps_timer); + evas_object_smart_callback_add(cb_fps, "changed", _cb_fps_enable, (void *)fps_timer); + + evas_object_smart_callback_add(btnstop, "clicked", _btnstop_cb, timer); + + elm_run(); + elm_shutdown(); + +#ifndef DISABLE_NAVIGATION_PANEL + panel_camera_light_fini(navigation); +#endif + return 0; +} +ELM_MAIN() + diff --git a/src/examples/perfomance/target_texture.png b/src/examples/perfomance/target_texture.png new file mode 100644 index 0000000..3bcf58b Binary files /dev/null and b/src/examples/perfomance/target_texture.png differ diff --git a/src/examples/perfomance/tools_private.h b/src/examples/perfomance/tools_private.h new file mode 100644 index 0000000..05c3c26 --- /dev/null +++ b/src/examples/perfomance/tools_private.h @@ -0,0 +1,50 @@ +#define EFL_EO_API_SUPPORT +#define EFL_BETA_API_SUPPORT + +#include <math.h> +#include <stdlib.h> +#include <time.h> +#include <stdio.h> +#include <stdlib.h> + +#include <Eo.h> +#include <Evas.h> +#include <Ecore.h> +#include <Ecore_Evas.h> +#include <Elementary.h> + +#define COORDRANGE 1000 +#define ANGLERANGE 360 +#define axiskeys "xyz" +#define pb "panel_struct" + +typedef struct _Panel_Struct +{ + Evas_Object *cspX, *cspY, *cspZ; + Evas_Object *cspangle; + Evas_Object *lspX, *lspY, *lspZ; + Evas_Object *lspangle; +} Panel_Struct; + +typedef struct _Axis_Key +{ + float x; + float y; + float z; +} Axis_Key; + +/*callbacks*/ +static void +_camera_light_changeX_cb(void *data, Evas_Object *obj, void *event_info); +static void +_camera_light_changeY_cb(void *data, Evas_Object *obj, void *event_info); +static void +_camera_light_changeZ_cb(void *data, Evas_Object *obj, void *event_info); +static void +_camera_light_angle_change_cb(void *data, Evas_Object *obj, void *event_info); +static void +_camera_light_axisX_change_cb(void *data, Evas_Object *obj, void *event_info); +static void +_camera_light_axisY_change_cb(void *data, Evas_Object *obj, void *event_info); +static void +_camera_light_axisZ_change_cb(void *data, Evas_Object *obj, void *event_info); --