kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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 <cedric@osg.samsung.com>
This commit is contained in:
Oleksandr Shcherbina 2015-02-17 12:51:14 +01:00 committed by Cedric BAIL
parent 58c131d25d
commit 7a8942f74a
14 changed files with 2402 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
legacy/elementary/configure.ac
View File

@ -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

1
legacy/elementary/src/examples/Makefile.am
View File

@ -1,6 +1,7 @@
MAINTAINERCLEANFILES = Makefile.in
SUBDIRS = sphere_hunter
SUBDIRS += perfomance
include ../../Makefile_Elm_Helpers.am

13
legacy/elementary/src/examples/perfomance/HowTo Normal file
View File

@ -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

44
legacy/elementary/src/examples/perfomance/Makefile.am Normal file
View File

@ -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

19
legacy/elementary/src/examples/perfomance/Tools.h Normal file
View File

@ -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);

BIN
legacy/elementary/src/examples/perfomance/backgroung.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 173 KiB

351
legacy/elementary/src/examples/perfomance/camera_light.c Normal file
View File

@ -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);
}

680
legacy/elementary/src/examples/perfomance/graphical.c Normal file
View File

@ -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;
}

90
legacy/elementary/src/examples/perfomance/graphical_struct.h Normal file
View File

@ -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

11
legacy/elementary/src/examples/perfomance/initial_config.xml Normal file
View File

@ -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>

170
legacy/elementary/src/examples/perfomance/layout.edc Normal file
View File

@ -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";
}
}
}
}
}
}

972
legacy/elementary/src/examples/perfomance/perfomance.c Normal file
View File

@ -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()

BIN
legacy/elementary/src/examples/perfomance/target_texture.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 2.0 MiB

50
legacy/elementary/src/examples/perfomance/tools_private.h Normal file
View File

@ -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);