| /* Copyright (C) 2007-2008 The Android Open Source Project | |
| ** | |
| ** This software is licensed under the terms of the GNU General Public | |
| ** License version 2, as published by the Free Software Foundation, and | |
| ** may be copied, distributed, and modified under those terms. | |
| ** | |
| ** This program is distributed in the hope that it will be useful, | |
| ** but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| ** GNU General Public License for more details. | |
| */ | |
| #ifdef _MSC_VER | |
| #define _USE_MATH_DEFINES | |
| #endif | |
| #include "android/skin/trackball.h" | |
| #include "android/skin/image.h" | |
| #include "android/utils/system.h" | |
| #ifdef _MSC_VER | |
| #include "msvc-posix.h" | |
| #else | |
| #include <sys/time.h> | |
| #endif | |
| #include <math.h> | |
| #include <stdlib.h> | |
| // Return the number of milliseconds since the start of this module. | |
| static uint32_t get_ticks(void) { | |
| static int tick_init; | |
| static uint32_t tick_offset; | |
| struct timeval tv; | |
| gettimeofday(&tv, NULL); | |
| uint32_t now = | |
| (uint32_t)(tv.tv_sec * 1000U) + (uint32_t)(tv.tv_usec / 1000U); | |
| if (!tick_init) { | |
| tick_offset = now; | |
| tick_init = 1; | |
| } | |
| return now - tick_offset; | |
| } | |
| /***********************************************************************/ | |
| /***********************************************************************/ | |
| /***** *****/ | |
| /***** T R A C K B A L L *****/ | |
| /***** *****/ | |
| /***********************************************************************/ | |
| /***********************************************************************/ | |
| // a 3-d vector | |
| typedef double VectorRec[3]; | |
| typedef double* Vector; | |
| /* define FIX16_IS_FLOAT to use floats for computations */ | |
| #define FIX16_IS_FLOAT | |
| #ifdef FIX16_IS_FLOAT | |
| typedef float Fix16; | |
| #define FIX16_ONE 1.0 | |
| #define FIX16_FROM_FLOAT(x) (x) | |
| #define FIX16_TO_FLOAT(x) (x) | |
| #else | |
| typedef int Fix16; | |
| #define FIX16_SHIFT 16 | |
| #define FIX16_ONE (1 << FIX16_SHIFT) | |
| #define FIX16_FROM_FLOAT(x) (Fix16)((x) * FIX16_ONE) | |
| #define FIX16_TO_FLOAT(x) ((x)/(1.0*FIX16_ONE)) | |
| #endif | |
| typedef Fix16 Fix16VectorRec[3]; | |
| typedef Fix16* Fix16Vector; | |
| static Fix16 | |
| fixedvector_len( Fix16Vector v ) | |
| { | |
| double x = FIX16_TO_FLOAT(v[0]); | |
| double y = FIX16_TO_FLOAT(v[1]); | |
| double z = FIX16_TO_FLOAT(v[2]); | |
| double len = sqrt( x*x + y*y + z*z ); | |
| return FIX16_FROM_FLOAT(len); | |
| } | |
| static void | |
| fixedvector_from_vector( Fix16Vector f, Vector v ) | |
| { | |
| f[0] = FIX16_FROM_FLOAT(v[0]); | |
| f[1] = FIX16_FROM_FLOAT(v[1]); | |
| f[2] = FIX16_FROM_FLOAT(v[2]); | |
| } | |
| #ifdef FIX16_IS_FLOAT | |
| static double | |
| fixedvector_dot( Fix16Vector u, Fix16Vector v ) | |
| { | |
| return u[0]*v[0] + u[1]*v[1] + u[2]*v[2]; | |
| } | |
| #else | |
| static Fix16 | |
| fixedvector_dot( Fix16Vector u, Fix16Vector v ) | |
| { | |
| long long t; | |
| t = (long long)u[0] * v[0] + (long long)u[1] * v[1] + (long long)u[2] * v[2]; | |
| return (Fix16)(t >> FIX16_SHIFT); | |
| } | |
| #endif | |
| static int | |
| norm( int dx, int dy ) | |
| { | |
| return (int) sqrt( dx*1.0*dx + dy*1.0*dy ); | |
| } | |
| /*** ROTATOR: used to rotate the reference axis when mouse motion happens | |
| ***/ | |
| typedef struct | |
| { | |
| VectorRec d; | |
| VectorRec n; | |
| double angle; | |
| } RotatorRec, *Rotator; | |
| #define ANGLE_FACTOR (M_PI/200) | |
| static void | |
| rotator_reset( Rotator rot, int dx, int dy ) | |
| { | |
| double len = sqrt( dx*dx + dy*dy ); | |
| double zx, zy; | |
| if (len < 1e-3 ) { | |
| zx = 1.; | |
| zy = 0; | |
| } else { | |
| zx = dx / len; | |
| zy = dy / len; | |
| } | |
| rot->d[0] = zx; | |
| rot->d[1] = zy; | |
| rot->d[2] = 0.; | |
| rot->n[0] = -rot->d[1]; | |
| rot->n[1] = rot->d[0]; | |
| rot->n[2] = 0; | |
| rot->angle = len * ANGLE_FACTOR; | |
| } | |
| static void | |
| rotator_apply( Rotator rot, double* vec ) | |
| { | |
| double d, n, z, d2, z2, cs, sn; | |
| /* project on D, N, Z */ | |
| d = vec[0]*rot->d[0] + vec[1]*rot->d[1]; | |
| n = vec[0]*rot->n[0] + vec[1]*rot->n[1]; | |
| z = vec[2]; | |
| /* rotate on D, Z */ | |
| cs = cos( rot->angle ); | |
| sn = sin( rot->angle ); | |
| d2 = cs*d + sn*z; | |
| z2 = -sn*d + cs*z; | |
| /* project on X, Y, Z */ | |
| vec[0] = d2*rot->d[0] + n*rot->n[0]; | |
| vec[1] = d2*rot->d[1] + n*rot->n[1]; | |
| vec[2] = z2; | |
| } | |
| /*** TRACKBALL OBJECT | |
| ***/ | |
| typedef struct { int x, y, offset, alpha; Fix16VectorRec f; } SphereCoordRec, *SphereCoord; | |
| typedef struct SkinTrackBall | |
| { | |
| int diameter; | |
| unsigned* pixels; | |
| SkinSurface* surface; | |
| VectorRec axes[3]; /* current ball axes */ | |
| #define DOT_GRID 3 /* number of horizontal and vertical cells per side grid */ | |
| #define DOT_CELLS 2 /* number of random dots per cell */ | |
| #define DOT_MAX (6*DOT_GRID*DOT_GRID*DOT_CELLS) /* total number of dots */ | |
| #define DOT_RANDOM_X 1007 /* horizontal random range in each cell */ | |
| #define DOT_RANDOM_Y 1007 /* vertical random range in each cell */ | |
| #define DOT_THRESHOLD FIX16_FROM_FLOAT(0.17) | |
| Fix16VectorRec dots[ DOT_MAX ]; | |
| SphereCoordRec* sphere_map; | |
| int sphere_count; | |
| unsigned ball_color; | |
| unsigned dot_color; | |
| unsigned ring_color; | |
| uint32_t ticks_last; /* ticks since last move */ | |
| int acc_x; | |
| int acc_y; | |
| int acc_threshold; | |
| double acc_scale; | |
| /* rotation applied to events send to the system */ | |
| SkinRotation rotation; | |
| SkinTrackBallEventFunc event_func; | |
| } TrackBallRec, *TrackBall; | |
| /* The following constants are used to better mimic a real trackball. | |
| * | |
| * ACC_THRESHOLD is used to filter small ball movements out. | |
| * If the length of the relative mouse motion is smaller than this | |
| * constant, then no corresponding ball event will be sent to the | |
| * system. | |
| * | |
| * ACC_SCALE is used to scale the relative mouse motion vector into | |
| * the corresponding ball motion vector. | |
| */ | |
| #define ACC_THRESHOLD 20 | |
| #define ACC_SCALE 0.2 | |
| static void | |
| trackball_init(TrackBall ball, int diameter, int ring, | |
| unsigned ball_color, unsigned dot_color, | |
| unsigned ring_color, | |
| SkinTrackBallEventFunc event_func) { | |
| int diameter2 = diameter + ring*2; | |
| memset( ball, 0, sizeof(*ball) ); | |
| ball->acc_threshold = ACC_THRESHOLD; | |
| ball->acc_scale = ACC_SCALE; | |
| ball->event_func = event_func; | |
| /* init SDL surface */ | |
| ball->diameter = diameter2; | |
| ball->ball_color = ball_color; | |
| ball->dot_color = dot_color; | |
| ball->ring_color = ring_color; | |
| ball->rotation = SKIN_ROTATION_0; | |
| ball->pixels = (unsigned*)calloc( diameter2*diameter2, sizeof(unsigned) ); | |
| ball->surface = skin_surface_create(diameter2, diameter2, diameter2, diameter2); | |
| /* init axes */ | |
| ball->axes[0][0] = 1.; ball->axes[0][1] = 0.; ball->axes[0][2] = 0.; | |
| ball->axes[1][0] = 0.; ball->axes[1][1] = 1.; ball->axes[1][2] = 0.; | |
| ball->axes[2][0] = 0.; ball->axes[2][1] = 0.; ball->axes[2][2] = 1.; | |
| /* init dots */ | |
| { | |
| int side, nn = 0; | |
| for (side = 0; side < 6; side++) { | |
| VectorRec origin, axis1, axis2; | |
| int xx, yy; | |
| switch (side) { | |
| case 0: | |
| origin[0] = -1; origin[1] = -1; origin[2] = +1; | |
| axis1 [0] = 1; axis1 [1] = 0; axis1 [2] = 0; | |
| axis2 [0] = 0; axis2 [1] = 1; axis2 [2] = 0; | |
| break; | |
| case 1: | |
| origin[0] = -1; origin[1] = -1; origin[2] = -1; | |
| axis1 [0] = 1; axis1 [1] = 0; axis1 [2] = 0; | |
| axis2 [0] = 0; axis2 [1] = 1; axis2 [2] = 0; | |
| break; | |
| case 2: | |
| origin[0] = +1; origin[1] = -1; origin[2] = -1; | |
| axis1 [0] = 0; axis1 [1] = 0; axis1 [2] = 1; | |
| axis2 [0] = 0; axis2 [1] = 1; axis2 [2] = 0; | |
| break; | |
| case 3: | |
| origin[0] = -1; origin[1] = -1; origin[2] = -1; | |
| axis1 [0] = 0; axis1 [1] = 0; axis1 [2] = 1; | |
| axis2 [0] = 0; axis2 [1] = 1; axis2 [2] = 0; | |
| break; | |
| case 4: | |
| origin[0] = -1; origin[1] = -1; origin[2] = -1; | |
| axis1 [0] = 1; axis1 [1] = 0; axis1 [2] = 0; | |
| axis2 [0] = 0; axis2 [1] = 0; axis2 [2] = 1; | |
| break; | |
| default: | |
| origin[0] = -1; origin[1] = +1; origin[2] = -1; | |
| axis1 [0] = 1; axis1 [1] = 0; axis1 [2] = 0; | |
| axis2 [0] = 0; axis2 [1] = 0; axis2 [2] = 1; | |
| } | |
| for (xx = 0; xx < DOT_GRID; xx++) { | |
| double tx = xx*(2./DOT_GRID); | |
| for (yy = 0; yy < DOT_GRID; yy++) { | |
| double ty = yy*(2./DOT_GRID); | |
| double x0 = origin[0] + axis1[0]*tx + axis2[0]*ty; | |
| double y0 = origin[1] + axis1[1]*tx + axis2[1]*ty; | |
| double z0 = origin[2] + axis1[2]*tx + axis2[2]*ty; | |
| int cc; | |
| for (cc = 0; cc < DOT_CELLS; cc++) { | |
| double h = (rand() % DOT_RANDOM_X)/((double)DOT_RANDOM_X*DOT_GRID/2); | |
| double v = (rand() % DOT_RANDOM_Y)/((double)DOT_RANDOM_Y*DOT_GRID/2); | |
| double x = x0 + axis1[0]*h + axis2[0]*v; | |
| double y = y0 + axis1[1]*h + axis2[1]*v; | |
| double z = z0 + axis1[2]*h + axis2[2]*v; | |
| double invlen = 1/sqrt( x*x + y*y + z*z ); | |
| ball->dots[nn][0] = FIX16_FROM_FLOAT(x*invlen); | |
| ball->dots[nn][1] = FIX16_FROM_FLOAT(y*invlen); | |
| ball->dots[nn][2] = FIX16_FROM_FLOAT(z*invlen); | |
| nn++; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| /* init sphere */ | |
| { | |
| int diameter2 = diameter + 2*ring; | |
| double radius = diameter*0.5; | |
| double radius2 = diameter2*0.5; | |
| int xx, yy; | |
| int empty = 0, total = 0; | |
| ball->sphere_map = calloc( diameter2*diameter2, sizeof(SphereCoordRec) ); | |
| for (yy = 0; yy < diameter2; yy++) { | |
| for (xx = 0; xx < diameter2; xx++) { | |
| double x0 = xx - radius2; | |
| double y0 = yy - radius2; | |
| double r0 = sqrt( x0*x0 + y0*y0 ); | |
| SphereCoord coord = &ball->sphere_map[total]; | |
| if (r0 <= radius) { /* ball pixel */ | |
| double rx = x0/radius; | |
| double ry = y0/radius; | |
| double rz = sqrt( 1.0 - rx*rx - ry*ry ); | |
| coord->x = xx; | |
| coord->y = yy; | |
| coord->offset = xx + yy*diameter2; | |
| coord->alpha = 256; | |
| coord->f[0] = FIX16_FROM_FLOAT(rx); | |
| coord->f[1] = FIX16_FROM_FLOAT(ry); | |
| coord->f[2] = FIX16_FROM_FLOAT(rz); | |
| if (r0 >= radius-1.) { | |
| coord->alpha = 256*(radius - r0); | |
| } | |
| /* illumination model */ | |
| { | |
| #define LIGHT_X -2.0 | |
| #define LIGHT_Y -2.5 | |
| #define LIGHT_Z 5.0 | |
| double lx = LIGHT_X - rx; | |
| double ly = LIGHT_Y - ry; | |
| double lz = LIGHT_Z - rz; | |
| double lir = 1/sqrt(lx*lx + ly*ly + lz*lz); | |
| double cosphi = lir*(lx*rx + ly*ry + lz*rz); | |
| double scale = 1.1*cosphi + 0.3; | |
| if (scale < 0) | |
| scale = 0; | |
| coord->alpha = coord->alpha * scale; | |
| } | |
| total++; | |
| } else if (r0 <= radius2) { /* ring pixel */ | |
| coord->x = xx; | |
| coord->y = yy; | |
| coord->offset = xx + yy*diameter2; | |
| coord->alpha = 0; | |
| if (r0 >= radius2-1.) { | |
| coord->alpha = -256*(r0 - (radius2-1.)); | |
| } | |
| total++; | |
| } else /* outside pixel */ | |
| empty++; | |
| } | |
| } | |
| ball->sphere_count = total; | |
| } | |
| } | |
| static void | |
| trackball_done( TrackBall ball ) | |
| { | |
| free( ball->sphere_map ); | |
| ball->sphere_map = NULL; | |
| ball->sphere_count = 0; | |
| skin_surface_unrefp(&ball->surface); | |
| if (ball->pixels) { | |
| free( ball->pixels ); | |
| ball->pixels = NULL; | |
| } | |
| } | |
| /*** TRACKBALL SPHERE PIXELS | |
| ***/ | |
| static unsigned | |
| color_blend( unsigned from, unsigned to, int alpha ) | |
| { | |
| unsigned from_ag = (from >> 8) & 0x00ff00ff; | |
| unsigned to_ag = (to >> 8) & 0x00ff00ff; | |
| unsigned from_rb = from & 0x00ff00ff; | |
| unsigned to_rb = to & 0x00ff00ff; | |
| unsigned result_ag = (from_ag + (alpha*(to_ag - from_ag) >> 8)) & 0xff00ff; | |
| unsigned result_rb = (from_rb + (alpha*(to_rb - from_rb) >> 8)) & 0xff00ff; | |
| return (result_ag << 8) | result_rb; | |
| } | |
| static int | |
| trackball_move( TrackBall ball, int dx, int dy ) | |
| { | |
| RotatorRec rot[1]; | |
| uint32_t now = get_ticks(); | |
| ball->acc_x += dx; | |
| ball->acc_y += dy; | |
| if ( norm( ball->acc_x, ball->acc_y ) > ball->acc_threshold ) | |
| { | |
| int ddx = ball->acc_x * ball->acc_scale; | |
| int ddy = ball->acc_y * ball->acc_scale; | |
| int ddt; | |
| ball->acc_x = 0; | |
| ball->acc_y = 0; | |
| switch (ball->rotation) { | |
| case SKIN_ROTATION_0: | |
| break; | |
| case SKIN_ROTATION_90: | |
| ddt = ddx; | |
| ddx = ddy; | |
| ddy = -ddt; | |
| break; | |
| case SKIN_ROTATION_180: | |
| ddx = -ddx; | |
| ddy = -ddy; | |
| break; | |
| case SKIN_ROTATION_270: | |
| ddt = ddx; | |
| ddx = -ddy; | |
| ddy = ddt; | |
| break; | |
| } | |
| ball->event_func(ddx, ddy); | |
| } | |
| rotator_reset( rot, dx, dy ); | |
| rotator_apply( rot, ball->axes[0] ); | |
| rotator_apply( rot, ball->axes[1] ); | |
| rotator_apply( rot, ball->axes[2] ); | |
| if ( ball->ticks_last == 0 ) | |
| ball->ticks_last = now; | |
| else if ( now > ball->ticks_last + (1000/60) ) { | |
| // At least 1/60 of a second has elapsed | |
| ball->ticks_last = now; | |
| return 1; | |
| } | |
| return 0; | |
| } | |
| #define BACK_COLOR 0x00000000 | |
| #define LIGHT_COLOR 0xffffffff | |
| static void | |
| trackball_refresh( TrackBall ball ) | |
| { | |
| int diameter = ball->diameter; | |
| unsigned* pixels = ball->pixels; | |
| Fix16VectorRec faxes[3]; | |
| Fix16 dot_threshold = DOT_THRESHOLD * diameter; | |
| int nn; | |
| SkinRect sRect = { { 0, 0 }, { diameter, diameter } }; | |
| fixedvector_from_vector( (Fix16Vector)&faxes[0], (Vector)&ball->axes[0] ); | |
| fixedvector_from_vector( (Fix16Vector)&faxes[1], (Vector)&ball->axes[1] ); | |
| fixedvector_from_vector( (Fix16Vector)&faxes[2], (Vector)&ball->axes[2] ); | |
| for (nn = 0; nn < ball->sphere_count; nn++) { | |
| SphereCoord coord = &ball->sphere_map[nn]; | |
| unsigned color = BACK_COLOR; | |
| if (coord->alpha > 0) { | |
| /* are we near one of the points ? */ | |
| Fix16 ax = fixedvector_dot( (Fix16Vector)&coord->f, (Fix16Vector)&faxes[0] ); | |
| Fix16 ay = fixedvector_dot( (Fix16Vector)&coord->f, (Fix16Vector)&faxes[1] ); | |
| Fix16 az = fixedvector_dot( (Fix16Vector)&coord->f, (Fix16Vector)&faxes[2] ); | |
| Fix16 best_dist = FIX16_ONE; | |
| int pp; | |
| color = ball->ball_color; | |
| for (pp = 0; pp < DOT_MAX; pp++) { | |
| Fix16VectorRec d; | |
| Fix16 dist; | |
| d[0] = ball->dots[pp][0] - ax; | |
| d[1] = ball->dots[pp][1] - ay; | |
| d[2] = ball->dots[pp][2] - az; | |
| if (d[0] > dot_threshold || d[0] < -dot_threshold || | |
| d[1] > dot_threshold || d[1] < -dot_threshold || | |
| d[2] > dot_threshold || d[2] < -dot_threshold ) | |
| continue; | |
| dist = fixedvector_len( (Fix16Vector)&d ); | |
| if (dist < best_dist) | |
| best_dist = dist; | |
| } | |
| if (best_dist < DOT_THRESHOLD) { | |
| int a = 256*(DOT_THRESHOLD - best_dist) / DOT_THRESHOLD; | |
| color = color_blend( color, ball->dot_color, a ); | |
| } | |
| if (coord->alpha < 256) { | |
| int a = coord->alpha; | |
| color = color_blend( ball->ring_color, color, a ); | |
| } | |
| else if (coord->alpha > 256) { | |
| int a = (coord->alpha - 256); | |
| color = color_blend( color, LIGHT_COLOR, a ); | |
| } | |
| } | |
| else /* coord->alpha <= 0 */ | |
| { | |
| color = ball->ring_color; | |
| if (coord->alpha < 0) { | |
| int a = -coord->alpha; | |
| color = color_blend( color, BACK_COLOR, a ); | |
| } | |
| } | |
| pixels[coord->x + diameter*coord->y] = color; | |
| } | |
| skin_surface_upload(ball->surface, &sRect, pixels, ball->diameter * 4); | |
| } | |
| void | |
| trackball_draw(TrackBall ball, int x, int y, SkinSurface* dst) | |
| { | |
| SkinPos dst_pos; | |
| dst_pos.x = x; | |
| dst_pos.y = y; | |
| SkinRect src_rect; | |
| src_rect.pos.x = 0; | |
| src_rect.pos.y = 0; | |
| src_rect.size.w = ball->diameter; | |
| src_rect.size.h = ball->diameter; | |
| skin_surface_blit(dst, | |
| &dst_pos, | |
| ball->surface, | |
| &src_rect, | |
| SKIN_BLIT_COPY); | |
| } | |
| SkinTrackBall* | |
| skin_trackball_create ( const SkinTrackBallParameters* params ) | |
| { | |
| TrackBall ball; | |
| ANEW0(ball); | |
| trackball_init( ball, | |
| params->diameter, | |
| params->ring, | |
| params->ball_color, | |
| params->dot_color, | |
| params->ring_color, | |
| params->event_func | |
| ); | |
| return ball; | |
| } | |
| int | |
| skin_trackball_move( SkinTrackBall* ball, int dx, int dy ) | |
| { | |
| return trackball_move(ball, dx, dy); | |
| } | |
| void | |
| skin_trackball_refresh ( SkinTrackBall* ball ) | |
| { | |
| trackball_refresh(ball); | |
| } | |
| void | |
| skin_trackball_draw(SkinTrackBall* ball, int x, int y, SkinSurface* dst) | |
| { | |
| trackball_draw(ball, x, y, dst); | |
| } | |
| void | |
| skin_trackball_destroy ( SkinTrackBall* ball ) | |
| { | |
| if (ball) { | |
| trackball_done(ball); | |
| AFREE(ball); | |
| } | |
| } | |
| void | |
| skin_trackball_rect(SkinTrackBall* ball, SkinRect* rect) | |
| { | |
| rect->pos.x = 0; | |
| rect->pos.y = 0; | |
| rect->size.w = ball->diameter; | |
| rect->size.h = ball->diameter; | |
| } | |
| void | |
| skin_trackball_set_rotation( SkinTrackBall* ball, SkinRotation rotation ) | |
| { | |
| ball->rotation = rotation & 3; | |
| } |