SDL_gesture.c (22792B)
1 /* 2 Simple DirectMedia Layer 3 Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org> 4 5 This software is provided 'as-is', without any express or implied 6 warranty. In no event will the authors be held liable for any damages 7 arising from the use of this software. 8 9 Permission is granted to anyone to use this software for any purpose, 10 including commercial applications, and to alter it and redistribute it 11 freely, subject to the following restrictions: 12 13 1. The origin of this software must not be misrepresented; you must not 14 claim that you wrote the original software. If you use this software 15 in a product, an acknowledgment in the product documentation would be 16 appreciated but is not required. 17 2. Altered source versions must be plainly marked as such, and must not be 18 misrepresented as being the original software. 19 3. This notice may not be removed or altered from any source distribution. 20 */ 21 22 #include "../SDL_internal.h" 23 24 /* General gesture handling code for SDL */ 25 26 #include "SDL_events.h" 27 #include "SDL_endian.h" 28 #include "SDL_events_c.h" 29 #include "SDL_gesture_c.h" 30 31 /* 32 #include <stdio.h> 33 */ 34 35 /* TODO: Replace with malloc */ 36 37 #define MAXPATHSIZE 1024 38 39 #define ENABLE_DOLLAR 40 41 #define DOLLARNPOINTS 64 42 43 #if defined(ENABLE_DOLLAR) 44 # define DOLLARSIZE 256 45 # define PHI 0.618033989 46 #endif 47 48 typedef struct { 49 float x,y; 50 } SDL_FloatPoint; 51 52 typedef struct { 53 float length; 54 55 int numPoints; 56 SDL_FloatPoint p[MAXPATHSIZE]; 57 } SDL_DollarPath; 58 59 typedef struct { 60 SDL_FloatPoint path[DOLLARNPOINTS]; 61 unsigned long hash; 62 } SDL_DollarTemplate; 63 64 typedef struct { 65 SDL_TouchID id; 66 SDL_FloatPoint centroid; 67 SDL_DollarPath dollarPath; 68 Uint16 numDownFingers; 69 70 int numDollarTemplates; 71 SDL_DollarTemplate *dollarTemplate; 72 73 SDL_bool recording; 74 } SDL_GestureTouch; 75 76 static SDL_GestureTouch *SDL_gestureTouch; 77 static int SDL_numGestureTouches = 0; 78 static SDL_bool recordAll; 79 80 #if 0 81 static void PrintPath(SDL_FloatPoint *path) 82 { 83 int i; 84 printf("Path:"); 85 for (i=0; i<DOLLARNPOINTS; i++) { 86 printf(" (%f,%f)",path[i].x,path[i].y); 87 } 88 printf("\n"); 89 } 90 #endif 91 92 int SDL_RecordGesture(SDL_TouchID touchId) 93 { 94 int i; 95 if (touchId < 0) recordAll = SDL_TRUE; 96 for (i = 0; i < SDL_numGestureTouches; i++) { 97 if ((touchId < 0) || (SDL_gestureTouch[i].id == touchId)) { 98 SDL_gestureTouch[i].recording = SDL_TRUE; 99 if (touchId >= 0) 100 return 1; 101 } 102 } 103 return (touchId < 0); 104 } 105 106 void SDL_GestureQuit() 107 { 108 SDL_free(SDL_gestureTouch); 109 SDL_gestureTouch = NULL; 110 } 111 112 static unsigned long SDL_HashDollar(SDL_FloatPoint* points) 113 { 114 unsigned long hash = 5381; 115 int i; 116 for (i = 0; i < DOLLARNPOINTS; i++) { 117 hash = ((hash<<5) + hash) + (unsigned long)points[i].x; 118 hash = ((hash<<5) + hash) + (unsigned long)points[i].y; 119 } 120 return hash; 121 } 122 123 124 static int SaveTemplate(SDL_DollarTemplate *templ, SDL_RWops *dst) 125 { 126 if (dst == NULL) { 127 return 0; 128 } 129 130 /* No Longer storing the Hash, rehash on load */ 131 /* if (SDL_RWops.write(dst, &(templ->hash), sizeof(templ->hash), 1) != 1) return 0; */ 132 133 #if SDL_BYTEORDER == SDL_LIL_ENDIAN 134 if (SDL_RWwrite(dst, templ->path, 135 sizeof(templ->path[0]),DOLLARNPOINTS) != DOLLARNPOINTS) { 136 return 0; 137 } 138 #else 139 { 140 SDL_DollarTemplate copy = *templ; 141 SDL_FloatPoint *p = copy.path; 142 int i; 143 for (i = 0; i < DOLLARNPOINTS; i++, p++) { 144 p->x = SDL_SwapFloatLE(p->x); 145 p->y = SDL_SwapFloatLE(p->y); 146 } 147 148 if (SDL_RWwrite(dst, copy.path, 149 sizeof(copy.path[0]),DOLLARNPOINTS) != DOLLARNPOINTS) { 150 return 0; 151 } 152 } 153 #endif 154 155 return 1; 156 } 157 158 159 int SDL_SaveAllDollarTemplates(SDL_RWops *dst) 160 { 161 int i,j,rtrn = 0; 162 for (i = 0; i < SDL_numGestureTouches; i++) { 163 SDL_GestureTouch* touch = &SDL_gestureTouch[i]; 164 for (j = 0; j < touch->numDollarTemplates; j++) { 165 rtrn += SaveTemplate(&touch->dollarTemplate[j], dst); 166 } 167 } 168 return rtrn; 169 } 170 171 int SDL_SaveDollarTemplate(SDL_GestureID gestureId, SDL_RWops *dst) 172 { 173 int i,j; 174 for (i = 0; i < SDL_numGestureTouches; i++) { 175 SDL_GestureTouch* touch = &SDL_gestureTouch[i]; 176 for (j = 0; j < touch->numDollarTemplates; j++) { 177 if (touch->dollarTemplate[j].hash == gestureId) { 178 return SaveTemplate(&touch->dollarTemplate[j], dst); 179 } 180 } 181 } 182 return SDL_SetError("Unknown gestureId"); 183 } 184 185 /* path is an already sampled set of points 186 Returns the index of the gesture on success, or -1 */ 187 static int SDL_AddDollarGesture_one(SDL_GestureTouch* inTouch, SDL_FloatPoint* path) 188 { 189 SDL_DollarTemplate* dollarTemplate; 190 SDL_DollarTemplate *templ; 191 int index; 192 193 index = inTouch->numDollarTemplates; 194 dollarTemplate = 195 (SDL_DollarTemplate *)SDL_realloc(inTouch->dollarTemplate, 196 (index + 1) * 197 sizeof(SDL_DollarTemplate)); 198 if (!dollarTemplate) { 199 return SDL_OutOfMemory(); 200 } 201 inTouch->dollarTemplate = dollarTemplate; 202 203 templ = &inTouch->dollarTemplate[index]; 204 SDL_memcpy(templ->path, path, DOLLARNPOINTS*sizeof(SDL_FloatPoint)); 205 templ->hash = SDL_HashDollar(templ->path); 206 inTouch->numDollarTemplates++; 207 208 return index; 209 } 210 211 static int SDL_AddDollarGesture(SDL_GestureTouch* inTouch, SDL_FloatPoint* path) 212 { 213 int index = -1; 214 int i = 0; 215 if (inTouch == NULL) { 216 if (SDL_numGestureTouches == 0) return SDL_SetError("no gesture touch devices registered"); 217 for (i = 0; i < SDL_numGestureTouches; i++) { 218 inTouch = &SDL_gestureTouch[i]; 219 index = SDL_AddDollarGesture_one(inTouch, path); 220 if (index < 0) 221 return -1; 222 } 223 /* Use the index of the last one added. */ 224 return index; 225 } 226 return SDL_AddDollarGesture_one(inTouch, path); 227 } 228 229 int SDL_LoadDollarTemplates(SDL_TouchID touchId, SDL_RWops *src) 230 { 231 int i,loaded = 0; 232 SDL_GestureTouch *touch = NULL; 233 if (src == NULL) return 0; 234 if (touchId >= 0) { 235 for (i = 0; i < SDL_numGestureTouches; i++) { 236 if (SDL_gestureTouch[i].id == touchId) { 237 touch = &SDL_gestureTouch[i]; 238 } 239 } 240 if (touch == NULL) { 241 return SDL_SetError("given touch id not found"); 242 } 243 } 244 245 while (1) { 246 SDL_DollarTemplate templ; 247 248 if (SDL_RWread(src,templ.path,sizeof(templ.path[0]),DOLLARNPOINTS) < DOLLARNPOINTS) { 249 if (loaded == 0) { 250 return SDL_SetError("could not read any dollar gesture from rwops"); 251 } 252 break; 253 } 254 255 #if SDL_BYTEORDER != SDL_LIL_ENDIAN 256 for (i = 0; i < DOLLARNPOINTS; i++) { 257 SDL_FloatPoint *p = &templ.path[i]; 258 p->x = SDL_SwapFloatLE(p->x); 259 p->y = SDL_SwapFloatLE(p->y); 260 } 261 #endif 262 263 if (touchId >= 0) { 264 /* printf("Adding loaded gesture to 1 touch\n"); */ 265 if (SDL_AddDollarGesture(touch, templ.path) >= 0) 266 loaded++; 267 } 268 else { 269 /* printf("Adding to: %i touches\n",SDL_numGestureTouches); */ 270 for (i = 0; i < SDL_numGestureTouches; i++) { 271 touch = &SDL_gestureTouch[i]; 272 /* printf("Adding loaded gesture to + touches\n"); */ 273 /* TODO: What if this fails? */ 274 SDL_AddDollarGesture(touch,templ.path); 275 } 276 loaded++; 277 } 278 } 279 280 return loaded; 281 } 282 283 284 #if defined(ENABLE_DOLLAR) 285 static float dollarDifference(SDL_FloatPoint* points,SDL_FloatPoint* templ,float ang) 286 { 287 /* SDL_FloatPoint p[DOLLARNPOINTS]; */ 288 float dist = 0; 289 SDL_FloatPoint p; 290 int i; 291 for (i = 0; i < DOLLARNPOINTS; i++) { 292 p.x = (float)(points[i].x * SDL_cos(ang) - points[i].y * SDL_sin(ang)); 293 p.y = (float)(points[i].x * SDL_sin(ang) + points[i].y * SDL_cos(ang)); 294 dist += (float)(SDL_sqrt((p.x-templ[i].x)*(p.x-templ[i].x)+ 295 (p.y-templ[i].y)*(p.y-templ[i].y))); 296 } 297 return dist/DOLLARNPOINTS; 298 299 } 300 301 static float bestDollarDifference(SDL_FloatPoint* points,SDL_FloatPoint* templ) 302 { 303 /*------------BEGIN DOLLAR BLACKBOX------------------ 304 -TRANSLATED DIRECTLY FROM PSUDEO-CODE AVAILABLE AT- 305 -"http://depts.washington.edu/aimgroup/proj/dollar/" 306 */ 307 double ta = -M_PI/4; 308 double tb = M_PI/4; 309 double dt = M_PI/90; 310 float x1 = (float)(PHI*ta + (1-PHI)*tb); 311 float f1 = dollarDifference(points,templ,x1); 312 float x2 = (float)((1-PHI)*ta + PHI*tb); 313 float f2 = dollarDifference(points,templ,x2); 314 while (SDL_fabs(ta-tb) > dt) { 315 if (f1 < f2) { 316 tb = x2; 317 x2 = x1; 318 f2 = f1; 319 x1 = (float)(PHI*ta + (1-PHI)*tb); 320 f1 = dollarDifference(points,templ,x1); 321 } 322 else { 323 ta = x1; 324 x1 = x2; 325 f1 = f2; 326 x2 = (float)((1-PHI)*ta + PHI*tb); 327 f2 = dollarDifference(points,templ,x2); 328 } 329 } 330 /* 331 if (f1 <= f2) 332 printf("Min angle (x1): %f\n",x1); 333 else if (f1 > f2) 334 printf("Min angle (x2): %f\n",x2); 335 */ 336 return SDL_min(f1,f2); 337 } 338 339 /* DollarPath contains raw points, plus (possibly) the calculated length */ 340 static int dollarNormalize(const SDL_DollarPath *path,SDL_FloatPoint *points, SDL_bool is_recording) 341 { 342 int i; 343 float interval; 344 float dist; 345 int numPoints = 0; 346 SDL_FloatPoint centroid; 347 float xmin,xmax,ymin,ymax; 348 float ang; 349 float w,h; 350 float length = path->length; 351 352 /* Calculate length if it hasn't already been done */ 353 if (length <= 0) { 354 for (i=1;i < path->numPoints; i++) { 355 float dx = path->p[i ].x - path->p[i-1].x; 356 float dy = path->p[i ].y - path->p[i-1].y; 357 length += (float)(SDL_sqrt(dx*dx+dy*dy)); 358 } 359 } 360 361 /* Resample */ 362 interval = length/(DOLLARNPOINTS - 1); 363 dist = interval; 364 365 centroid.x = 0;centroid.y = 0; 366 367 /* printf("(%f,%f)\n",path->p[path->numPoints-1].x,path->p[path->numPoints-1].y); */ 368 for (i = 1; i < path->numPoints; i++) { 369 float d = (float)(SDL_sqrt((path->p[i-1].x-path->p[i].x)*(path->p[i-1].x-path->p[i].x)+ 370 (path->p[i-1].y-path->p[i].y)*(path->p[i-1].y-path->p[i].y))); 371 /* printf("d = %f dist = %f/%f\n",d,dist,interval); */ 372 while (dist + d > interval) { 373 points[numPoints].x = path->p[i-1].x + 374 ((interval-dist)/d)*(path->p[i].x-path->p[i-1].x); 375 points[numPoints].y = path->p[i-1].y + 376 ((interval-dist)/d)*(path->p[i].y-path->p[i-1].y); 377 centroid.x += points[numPoints].x; 378 centroid.y += points[numPoints].y; 379 numPoints++; 380 381 dist -= interval; 382 } 383 dist += d; 384 } 385 if (numPoints < DOLLARNPOINTS-1) { 386 if (is_recording) { 387 SDL_SetError("ERROR: NumPoints = %i", numPoints); 388 } 389 return 0; 390 } 391 /* copy the last point */ 392 points[DOLLARNPOINTS-1] = path->p[path->numPoints-1]; 393 numPoints = DOLLARNPOINTS; 394 395 centroid.x /= numPoints; 396 centroid.y /= numPoints; 397 398 /* printf("Centroid (%f,%f)",centroid.x,centroid.y); */ 399 /* Rotate Points so point 0 is left of centroid and solve for the bounding box */ 400 xmin = centroid.x; 401 xmax = centroid.x; 402 ymin = centroid.y; 403 ymax = centroid.y; 404 405 ang = (float)(SDL_atan2(centroid.y - points[0].y, 406 centroid.x - points[0].x)); 407 408 for (i = 0; i<numPoints; i++) { 409 float px = points[i].x; 410 float py = points[i].y; 411 points[i].x = (float)((px - centroid.x)*SDL_cos(ang) - 412 (py - centroid.y)*SDL_sin(ang) + centroid.x); 413 points[i].y = (float)((px - centroid.x)*SDL_sin(ang) + 414 (py - centroid.y)*SDL_cos(ang) + centroid.y); 415 416 417 if (points[i].x < xmin) xmin = points[i].x; 418 if (points[i].x > xmax) xmax = points[i].x; 419 if (points[i].y < ymin) ymin = points[i].y; 420 if (points[i].y > ymax) ymax = points[i].y; 421 } 422 423 /* Scale points to DOLLARSIZE, and translate to the origin */ 424 w = xmax-xmin; 425 h = ymax-ymin; 426 427 for (i=0; i<numPoints; i++) { 428 points[i].x = (points[i].x - centroid.x)*DOLLARSIZE/w; 429 points[i].y = (points[i].y - centroid.y)*DOLLARSIZE/h; 430 } 431 return numPoints; 432 } 433 434 static float dollarRecognize(const SDL_DollarPath *path,int *bestTempl,SDL_GestureTouch* touch) 435 { 436 SDL_FloatPoint points[DOLLARNPOINTS]; 437 int i; 438 float bestDiff = 10000; 439 440 SDL_memset(points, 0, sizeof(points)); 441 442 dollarNormalize(path, points, SDL_FALSE); 443 444 /* PrintPath(points); */ 445 *bestTempl = -1; 446 for (i = 0; i < touch->numDollarTemplates; i++) { 447 float diff = bestDollarDifference(points,touch->dollarTemplate[i].path); 448 if (diff < bestDiff) {bestDiff = diff; *bestTempl = i;} 449 } 450 return bestDiff; 451 } 452 #endif 453 454 int SDL_GestureAddTouch(SDL_TouchID touchId) 455 { 456 SDL_GestureTouch *gestureTouch = (SDL_GestureTouch *)SDL_realloc(SDL_gestureTouch, 457 (SDL_numGestureTouches + 1) * 458 sizeof(SDL_GestureTouch)); 459 460 if (!gestureTouch) { 461 return SDL_OutOfMemory(); 462 } 463 464 SDL_gestureTouch = gestureTouch; 465 466 SDL_zero(SDL_gestureTouch[SDL_numGestureTouches]); 467 SDL_gestureTouch[SDL_numGestureTouches].id = touchId; 468 SDL_numGestureTouches++; 469 return 0; 470 } 471 472 int SDL_GestureDelTouch(SDL_TouchID touchId) 473 { 474 int i; 475 for (i = 0; i < SDL_numGestureTouches; i++) { 476 if (SDL_gestureTouch[i].id == touchId) { 477 break; 478 } 479 } 480 481 if (i == SDL_numGestureTouches) { 482 /* not found */ 483 return -1; 484 } 485 486 SDL_free(SDL_gestureTouch[i].dollarTemplate); 487 SDL_zero(SDL_gestureTouch[i]); 488 489 SDL_numGestureTouches--; 490 SDL_memcpy(&SDL_gestureTouch[i], &SDL_gestureTouch[SDL_numGestureTouches], sizeof(SDL_gestureTouch[i])); 491 return 0; 492 } 493 494 static SDL_GestureTouch * SDL_GetGestureTouch(SDL_TouchID id) 495 { 496 int i; 497 for (i = 0; i < SDL_numGestureTouches; i++) { 498 /* printf("%i ?= %i\n",SDL_gestureTouch[i].id,id); */ 499 if (SDL_gestureTouch[i].id == id) 500 return &SDL_gestureTouch[i]; 501 } 502 return NULL; 503 } 504 505 static void SDL_SendGestureMulti(SDL_GestureTouch* touch,float dTheta,float dDist) 506 { 507 if (SDL_GetEventState(SDL_MULTIGESTURE) == SDL_ENABLE) { 508 SDL_Event event; 509 event.mgesture.type = SDL_MULTIGESTURE; 510 event.mgesture.touchId = touch->id; 511 event.mgesture.x = touch->centroid.x; 512 event.mgesture.y = touch->centroid.y; 513 event.mgesture.dTheta = dTheta; 514 event.mgesture.dDist = dDist; 515 event.mgesture.numFingers = touch->numDownFingers; 516 SDL_PushEvent(&event); 517 } 518 } 519 520 #if defined(ENABLE_DOLLAR) 521 static void SDL_SendGestureDollar(SDL_GestureTouch* touch, 522 SDL_GestureID gestureId,float error) 523 { 524 if (SDL_GetEventState(SDL_DOLLARGESTURE) == SDL_ENABLE) { 525 SDL_Event event; 526 event.dgesture.type = SDL_DOLLARGESTURE; 527 event.dgesture.touchId = touch->id; 528 event.dgesture.x = touch->centroid.x; 529 event.dgesture.y = touch->centroid.y; 530 event.dgesture.gestureId = gestureId; 531 event.dgesture.error = error; 532 /* A finger came up to trigger this event. */ 533 event.dgesture.numFingers = touch->numDownFingers + 1; 534 SDL_PushEvent(&event); 535 } 536 } 537 538 static void SDL_SendDollarRecord(SDL_GestureTouch* touch,SDL_GestureID gestureId) 539 { 540 if (SDL_GetEventState(SDL_DOLLARRECORD) == SDL_ENABLE) { 541 SDL_Event event; 542 event.dgesture.type = SDL_DOLLARRECORD; 543 event.dgesture.touchId = touch->id; 544 event.dgesture.gestureId = gestureId; 545 SDL_PushEvent(&event); 546 } 547 } 548 #endif 549 550 551 void SDL_GestureProcessEvent(SDL_Event* event) 552 { 553 float x,y; 554 #if defined(ENABLE_DOLLAR) 555 int index; 556 int i; 557 float pathDx, pathDy; 558 #endif 559 SDL_FloatPoint lastP; 560 SDL_FloatPoint lastCentroid; 561 float lDist; 562 float Dist; 563 float dtheta; 564 float dDist; 565 566 if (event->type == SDL_FINGERMOTION || 567 event->type == SDL_FINGERDOWN || 568 event->type == SDL_FINGERUP) { 569 SDL_GestureTouch* inTouch = SDL_GetGestureTouch(event->tfinger.touchId); 570 571 /* Shouldn't be possible */ 572 if (inTouch == NULL) return; 573 574 x = event->tfinger.x; 575 y = event->tfinger.y; 576 577 /* Finger Up */ 578 if (event->type == SDL_FINGERUP) { 579 #if defined(ENABLE_DOLLAR) 580 SDL_FloatPoint path[DOLLARNPOINTS]; 581 #endif 582 583 inTouch->numDownFingers--; 584 585 #if defined(ENABLE_DOLLAR) 586 if (inTouch->recording) { 587 inTouch->recording = SDL_FALSE; 588 dollarNormalize(&inTouch->dollarPath, path, SDL_TRUE); 589 /* PrintPath(path); */ 590 if (recordAll) { 591 index = SDL_AddDollarGesture(NULL,path); 592 for (i = 0; i < SDL_numGestureTouches; i++) 593 SDL_gestureTouch[i].recording = SDL_FALSE; 594 } 595 else { 596 index = SDL_AddDollarGesture(inTouch,path); 597 } 598 599 if (index >= 0) { 600 SDL_SendDollarRecord(inTouch,inTouch->dollarTemplate[index].hash); 601 } 602 else { 603 SDL_SendDollarRecord(inTouch,-1); 604 } 605 } 606 else { 607 int bestTempl; 608 float error; 609 error = dollarRecognize(&inTouch->dollarPath, 610 &bestTempl,inTouch); 611 if (bestTempl >= 0){ 612 /* Send Event */ 613 unsigned long gestureId = inTouch->dollarTemplate[bestTempl].hash; 614 SDL_SendGestureDollar(inTouch,gestureId,error); 615 /* printf ("%s\n",);("Dollar error: %f\n",error); */ 616 } 617 } 618 #endif 619 /* inTouch->gestureLast[j] = inTouch->gestureLast[inTouch->numDownFingers]; */ 620 if (inTouch->numDownFingers > 0) { 621 inTouch->centroid.x = (inTouch->centroid.x*(inTouch->numDownFingers+1)- 622 x)/inTouch->numDownFingers; 623 inTouch->centroid.y = (inTouch->centroid.y*(inTouch->numDownFingers+1)- 624 y)/inTouch->numDownFingers; 625 } 626 } 627 else if (event->type == SDL_FINGERMOTION) { 628 float dx = event->tfinger.dx; 629 float dy = event->tfinger.dy; 630 #if defined(ENABLE_DOLLAR) 631 SDL_DollarPath* path = &inTouch->dollarPath; 632 if (path->numPoints < MAXPATHSIZE) { 633 path->p[path->numPoints].x = inTouch->centroid.x; 634 path->p[path->numPoints].y = inTouch->centroid.y; 635 pathDx = 636 (path->p[path->numPoints].x-path->p[path->numPoints-1].x); 637 pathDy = 638 (path->p[path->numPoints].y-path->p[path->numPoints-1].y); 639 path->length += (float)SDL_sqrt(pathDx*pathDx + pathDy*pathDy); 640 path->numPoints++; 641 } 642 #endif 643 lastP.x = x - dx; 644 lastP.y = y - dy; 645 lastCentroid = inTouch->centroid; 646 647 inTouch->centroid.x += dx/inTouch->numDownFingers; 648 inTouch->centroid.y += dy/inTouch->numDownFingers; 649 /* printf("Centrid : (%f,%f)\n",inTouch->centroid.x,inTouch->centroid.y); */ 650 if (inTouch->numDownFingers > 1) { 651 SDL_FloatPoint lv; /* Vector from centroid to last x,y position */ 652 SDL_FloatPoint v; /* Vector from centroid to current x,y position */ 653 /* lv = inTouch->gestureLast[j].cv; */ 654 lv.x = lastP.x - lastCentroid.x; 655 lv.y = lastP.y - lastCentroid.y; 656 lDist = (float)SDL_sqrt(lv.x*lv.x + lv.y*lv.y); 657 /* printf("lDist = %f\n",lDist); */ 658 v.x = x - inTouch->centroid.x; 659 v.y = y - inTouch->centroid.y; 660 /* inTouch->gestureLast[j].cv = v; */ 661 Dist = (float)SDL_sqrt(v.x*v.x+v.y*v.y); 662 /* SDL_cos(dTheta) = (v . lv)/(|v| * |lv|) */ 663 664 /* Normalize Vectors to simplify angle calculation */ 665 lv.x/=lDist; 666 lv.y/=lDist; 667 v.x/=Dist; 668 v.y/=Dist; 669 dtheta = (float)SDL_atan2(lv.x*v.y - lv.y*v.x,lv.x*v.x + lv.y*v.y); 670 671 dDist = (Dist - lDist); 672 if (lDist == 0) {dDist = 0;dtheta = 0;} /* To avoid impossible values */ 673 674 /* inTouch->gestureLast[j].dDist = dDist; 675 inTouch->gestureLast[j].dtheta = dtheta; 676 677 printf("dDist = %f, dTheta = %f\n",dDist,dtheta); 678 gdtheta = gdtheta*.9 + dtheta*.1; 679 gdDist = gdDist*.9 + dDist*.1 680 knob.r += dDist/numDownFingers; 681 knob.ang += dtheta; 682 printf("thetaSum = %f, distSum = %f\n",gdtheta,gdDist); 683 printf("id: %i dTheta = %f, dDist = %f\n",j,dtheta,dDist); */ 684 SDL_SendGestureMulti(inTouch,dtheta,dDist); 685 } 686 else { 687 /* inTouch->gestureLast[j].dDist = 0; 688 inTouch->gestureLast[j].dtheta = 0; 689 inTouch->gestureLast[j].cv.x = 0; 690 inTouch->gestureLast[j].cv.y = 0; */ 691 } 692 /* inTouch->gestureLast[j].f.p.x = x; 693 inTouch->gestureLast[j].f.p.y = y; 694 break; 695 pressure? */ 696 } 697 else if (event->type == SDL_FINGERDOWN) { 698 699 inTouch->numDownFingers++; 700 inTouch->centroid.x = (inTouch->centroid.x*(inTouch->numDownFingers - 1)+ 701 x)/inTouch->numDownFingers; 702 inTouch->centroid.y = (inTouch->centroid.y*(inTouch->numDownFingers - 1)+ 703 y)/inTouch->numDownFingers; 704 /* printf("Finger Down: (%f,%f). Centroid: (%f,%f\n",x,y, 705 inTouch->centroid.x,inTouch->centroid.y); */ 706 707 #if defined(ENABLE_DOLLAR) 708 inTouch->dollarPath.length = 0; 709 inTouch->dollarPath.p[0].x = x; 710 inTouch->dollarPath.p[0].y = y; 711 inTouch->dollarPath.numPoints = 1; 712 #endif 713 } 714 } 715 } 716 717 /* vi: set ts=4 sw=4 expandtab: */