00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041 #include <stdio.h>
00042 #include <math.h>
00043 #include <string.h>
00044 #ifndef __UNIX_
00045 #include <malloc.h>
00046 #include <stdlib.h>
00047 #endif
00048 #include "mensagem.h"
00049 #include "memvirtu.h"
00050 #include "lowparam.h"
00051 #include "lowmacro.h"
00052 #include "lowsolid.h"
00053 #include "genfunc_.h"
00054 #include "hiegroup.h"
00055 #include "vectorop.h"
00056 #include "disdispl.h"
00057 #include "animatio.h"
00058 #include "mancommd.h"
00059
00060 void animatio(void)
00061 {
00062 char aname[13], arqnam[13];
00063 int ip, nframes, opcao;
00064 float edesl, x1, y1, z1, x2, y2, z2;
00065
00066 for (ip = 0; ip == 0;)
00067 {
00068 switch (optin())
00069 {
00070 case 'i':
00071 MSD_clearAnimationList();
00072 ip = 1;
00073 break;
00074
00075 case 'p':
00076 PrintListAni();
00077 ip = 1;
00078 break;
00079
00080 case 'm':
00081 if (sscanf(restbuf, "%d %d %s %s %s", &opcao, &nframes, arqnam,
00082 aname) == 4)
00083 {
00084 MSD_createAnimation(opcao, nframes, arqnam, aname);
00085 ip = 1;
00086 }
00087 break;
00088
00089 case 'c':
00090 if (sscanf(restbuf, "%s %f %f %f %f %f %f %f", aname, &x1,
00091 &y1, &z1, &x2, &y2, &z2, &edesl) == 8)
00092 {
00093 MSD_addCameraToMovementStructure(aname, x1, y1, z1, x2, y2, z2, edesl);
00094 ip = 1;
00095 }
00096 break;
00097
00098 case 'a':
00099 if (sscanf(restbuf, "%s %f", aname, &edesl) == 2)
00100 {
00101 MSD_addAxisToMovementStructure(aname, edesl);
00102 ip = 1;
00103 }
00104 }
00105 if (ip == 0)
00106 {
00107 printf("-ip \n");
00108 printf("-a eixo desl\n");
00109 printf("-c camera olho[3] ref[3] scale\n");
00110 printf("-m ini nframes arquivo camera objetos\n");
00111 if (!lineins("? "))
00112 {
00113 return;
00114 }
00115 }
00116 }
00117 }
00118
00119 void MSD_selectAllObjects(void)
00120 {
00121 STYPE *optr;
00122
00123 for (AllSolids(optr))
00124 {
00125 SolDsp(optr) = TRUE;
00126 }
00127 }
00128
00129 void MSD_resetAllObjects(void)
00130 {
00131 STYPE *optr;
00132
00133 for (AllSolids(optr))
00134 {
00135 SolDsp(optr) = FALSE;
00136 }
00137 }
00138
00139 void MSD_selectElement(char *name)
00140 {
00141 if (MSD_getTypeByName(name) == 'o')
00142 {
00143 MSD_selectObject(name);
00144 return;
00145 }
00146 if (MSD_getTypeByName(name) == 'g')
00147 {
00148 MSD_selectGroup(name);
00149 return;
00150 }
00151 }
00152
00153 void MSD_resetElement(char *name)
00154 {
00155 if (MSD_getTypeByName(name) == 'o')
00156 {
00157 MSD_resetObject(name);
00158 return;
00159 }
00160 if (MSD_getTypeByName(name) == 'g')
00161 {
00162 MSD_resetGroup(name);
00163 return;
00164 }
00165 }
00166
00167 void MSD_selectGroup(char *name)
00168 {
00169 SPTYPE optr;
00170 GPTYPE gptr;
00171
00172 if ((gptr = MSD_lowFindGroupByName(name)) == GNIL)
00173 {
00174 return;
00175 }
00176 for (AllSolids(optr))
00177 {
00178 if (SolGroup(optr) != GNIL)
00179 {
00180 if (MSD_lowIsAncestorGroup(gptr, SolGroup(optr)))
00181 {
00182 SolDsp(optr) = TRUE;
00183 }
00184 }
00185 }
00186 }
00187
00188 void MSD_resetGroup(char *name)
00189 {
00190 SPTYPE optr;
00191 GPTYPE gptr;
00192
00193 if ((gptr = MSD_lowFindGroupByName(name)) == GNIL)
00194 {
00195 return;
00196 }
00197 for (AllSolids(optr))
00198 {
00199 if (SolGroup(optr) != GNIL)
00200 {
00201 if (MSD_lowIsAncestorGroup(gptr, SolGroup(optr)))
00202 {
00203 SolDsp(optr) = FALSE;
00204 }
00205 }
00206 }
00207 }
00208
00209 void MSD_selectObject(char *name)
00210 {
00211 SPTYPE optr;
00212
00213 if ((optr = MSD_lowFindSolidByName(name)) != SNIL)
00214 {
00215 SolDsp(optr) = TRUE;
00216 }
00217 }
00218
00219 void MSD_resetObject(char *name)
00220 {
00221 SPTYPE optr;
00222
00223 if ((optr = MSD_lowFindSolidByName(name)) != SNIL)
00224 {
00225 SolDsp(optr) = FALSE;
00226 }
00227 }
00228
00229 void MSD_addAxisToMovementStructure(char *eaname, real edesl)
00230 {
00231 APTYPE axis;
00232 MOVE *count;
00233
00234 if ((axis = MSD_lowFindAxisByName(eaname)) == ANIL)
00235 {
00236 fprintf(stderr, "%s nao e o nome de nenhum eixo!\n", eaname);
00237 return;
00238 }
00239 if ((count = CreateElementAni(MovimentoAxis)) == (MOVE *)NIL)
00240 {
00241 fprintf(stderr, "AddAxisAni: no memory left!\n");
00242 return;
00243 }
00244 AddElementAni(count);
00245 count->mu.ma->axs = axis;
00246 count->mu.ma->desl = edesl;
00247 }
00248
00249 void MSD_addCameraToMovementStructure(char *aname, real ex, real ey, real ez,
00250 real rx, real ry, real rz, real desl)
00251 {
00252 vector eeye, eref;
00253
00254 makevec(eeye, ex, ey, ez, 1.0);
00255 makevec(eref, rx, ry, rz, 1.0);
00256 AddCamAni(aname, eeye, eref, desl);
00257 }
00258
00259 void AddCamAni(char *aname, vector eeye, vector eref, real edesl)
00260 {
00261 CTYPE *cam;
00262 MOVE *count;
00263
00264 if ((cam = MSD_lowFindCameraByName(aname)) == (CTYPE *)NIL)
00265 {
00266 fprintf(stderr, "%s nao e o nome de nenhuma camera!\n", aname);
00267 return;
00268 }
00269 if ((count = CreateElementAni(MovimentoCamera)) == (MOVE *)NIL)
00270 {
00271 fprintf(stderr, "AddCamAni: no memory left!\n");
00272 return;
00273 }
00274 AddElementAni(count);
00275 count->mu.mc->cam = cam;
00276 veccopy(count->mu.mc->eye, eeye);
00277 veccopy(count->mu.mc->ref, eref);
00278 count->mu.mc->scale = edesl;
00279 }
00280
00281 FILE *OpenIndexAni(char *AnimeName)
00282 {
00283 char FrameIndex[13];
00284 FILE *FrameIndexFile;
00285
00286 strcpy(FrameIndex, AnimeName);
00287 strcat(FrameIndex, "000.TMP");
00288 if ((FrameIndexFile = fopen(FrameIndex, "w")) == (FILE *)NIL)
00289 {
00290 fprintf(stderr, "Nao obteve sucesso em abrir o arquivo %s!\n", FrameIndex);
00291 return((FILE *)NIL);
00292 }
00293 return(FrameIndexFile);
00294 }
00295
00296 void CriaFrame(FILE *FrameIndexFile, char *AnimeName, int framect)
00297 {
00298 SPTYPE optr;
00299 CTYPE *cptr;
00300 MOVE *count;
00301 char FrameFile[13];
00302 vector eeye, eref;
00303 real edesl;
00304
00305 for (count = movhead; count; count = count->next)
00306 {
00307 if (count->tipo == MovimentoCamera)
00308 {
00309 cptr = count->mu.mc->cam;
00310 vecplus(eeye, cptr->eye, count->mu.mc->auxeye);
00311 vecplus(eref, cptr->ref, count->mu.mc->auxref);
00312 edesl = cptr->scale + count->mu.mc->auxscale;
00313 MSD_lowSetCamera(cptr, eeye, eref, edesl, cptr->mode, cptr->hid, cptr->dash,
00314 cptr->smooth);
00315 }
00316 else
00317 {
00318 edesl = count->mu.ma->auxdesl;
00319 MSD_highNameTransformUsingAxis(count->mu.ma->axs->aname, edesl);
00320 }
00321 }
00322 MSD_lowDisplayWriteFile(InitFrameCount(AnimeName, FrameFile, framect));
00323 for (AllSolids(optr))
00324 {
00325 SolDsp(optr) = TRUE;
00326 }
00327 g_clear();
00328 framenum = 0;
00329 Draw = FALSE;
00330 switch (camptr->hid)
00331 {
00332 case 0:
00333 MSD_highDisplayAllEdges();
00334 break;
00335
00336 case 1:
00337 MSD_highDisplayLocalHidden();
00338 break;
00339
00340 case 2:
00341 MSD_lowCameraDisplayHidden();
00342 break;
00343
00344 case 3:
00345 MSD_lowCameraDisplayIntersection();
00346 break;
00347 }
00348 Draw = TRUE;
00349 fclose(dspfwptr);
00350 dspfwptr = (FILE *)NIL;
00351 fprintf(FrameIndexFile, "%s %d\n", FrameFile, framenum);
00352 }
00353
00354 void MSD_createAnimation(int opcao, int nframes, char *AnimeName, char *ecname)
00355 {
00356 MOVE *count;
00357 char FrameFile[13];
00358 int framect;
00359 FILE *FrameIndexFile;
00360
00361 if ((camptr = MSD_lowFindCameraByName(ecname)) == (CTYPE *)NIL)
00362 {
00363 fprintf(stderr, "%s nao e o nome de nenhuma camera!\n", ecname);
00364 return;
00365 }
00366 if ((FrameIndexFile = OpenIndexAni(AnimeName)) == (FILE *)NIL)
00367 {
00368 return;
00369 }
00370
00371 for (count = movhead; count; count = count->next)
00372 {
00373 if (count->tipo == MovimentoCamera)
00374 {
00375 vecminus(count->mu.mc->auxeye, count->mu.mc->eye, camptr->eye);
00376 vecesc(count->mu.mc->auxeye, count->mu.mc->auxeye, 1. / ((real)nframes));
00377 vecminus(count->mu.mc->auxref, count->mu.mc->ref, camptr->ref);
00378 vecesc(count->mu.mc->auxref, count->mu.mc->auxref, 1. / ((real)nframes));
00379 count->mu.mc->auxscale = (count->mu.mc->scale - camptr->scale) / ((real)nframes);
00380 }
00381 else
00382 {
00383 count->mu.ma->auxdesl = count->mu.ma->desl / ((real)nframes);
00384 }
00385 }
00386
00387 if (opcao == 1)
00388 {
00389 opcao++;
00390 for (count = movhead; count; count = count->next)
00391 {
00392 if (count->tipo == MovimentoCamera)
00393 {
00394 camptr = count->mu.mc->cam;
00395 }
00396 }
00397 MSD_lowDisplayWriteFile(InitFrameCount(AnimeName, FrameFile, 1));
00398
00399 g_clear();
00400 framenum = 0;
00401 Draw = FALSE;
00402 switch (camptr->hid)
00403 {
00404 case 0:
00405 MSD_highDisplayAllEdges();
00406 break;
00407
00408 case 1:
00409 MSD_highDisplayLocalHidden();
00410 break;
00411
00412 case 2:
00413 MSD_lowCameraDisplayHidden();
00414 break;
00415
00416 case 3:
00417 MSD_lowCameraDisplayIntersection();
00418 break;
00419 }
00420 Draw = TRUE;
00421 fclose(dspfwptr);
00422 dspfwptr = (FILE *)NIL;
00423 fprintf(FrameIndexFile, "%s %d\n", FrameFile, framenum);
00424 }
00425
00426 for (framect = opcao; framect <= opcao + nframes - 1; framect++)
00427 {
00428 CriaFrame(FrameIndexFile, AnimeName, framect);
00429 }
00430 fclose(FrameIndexFile);
00431 PurificaAni(AnimeName, opcao);
00432 }
00433
00434 char *InitFrameCount(char *AnimeName, char *FrameFile, int framect)
00435 {
00436 char Numero[4];
00437
00438 strcpy(FrameFile, AnimeName);
00439 if (framect < 100)
00440 {
00441 strcat(FrameFile, "0");
00442 }
00443 if (framect < 10)
00444 {
00445 strcat(FrameFile, "0");
00446 }
00447 #ifdef __UNIX_
00448 itoaa(Numero, framect);
00449 #else
00450 itoa(framect, Numero, 10);
00451 #endif
00452 strcat(FrameFile, Numero);
00453 strcat(FrameFile, ".dsp");
00454 return(FrameFile);
00455 }
00456
00457 #ifdef __UNIX_
00458 void itoaa(char *s, int n)
00459 {
00460 int i, sign;
00461
00462 if ((sign = n) < 0)
00463 {
00464 n = -n;
00465 }
00466 i = 0;
00467 do
00468 {
00469 s[i++] = n % 10 + '0';
00470 } while ((n /= 10) > 0);
00471 if (sign < 0)
00472 {
00473 s[i++] = '-';
00474 }
00475 s[i] = '\0';
00476 reverse(s);
00477 }
00478
00479
00480
00481
00482
00483
00484
00485
00486
00487
00488
00489 #endif
00490
00491 void PurificaAni(char *AnimeName, int opcao)
00492 {
00493 int NumVectors;
00494 char FrameIndex[13], FrameFileName[13];
00495 FILE *FrameIndexFile;
00496
00497 strcpy(FrameIndex, AnimeName);
00498 strcat(FrameIndex, "000.TMP");
00499 if ((FrameIndexFile = fopen(FrameIndex, "r")) == (FILE *)NIL)
00500 {
00501 fprintf(stderr, "erro ao abrir arquivo %s\n", FrameIndex);
00502 return;
00503 }
00504 while (fscanf(FrameIndexFile, "%s %d", FrameFileName, &NumVectors) == 2)
00505 {
00506 PurificaFrame(NumVectors, AnimeName, FrameFileName, opcao);
00507 opcao = 2;
00508 }
00509 fclose(FrameIndexFile);
00510 }
00511
00512 void PurificaFrame(int NumVectors, char *AnimeName, char *FrameFileName, int opcao)
00513 {
00514 FLOVECTOR Vectors[MAXVECTORS], *auxvp, *vp;
00515 int filt, flag, k, NumVectorsNew, auxcor, auxtipo;
00516 float ev1, ev2, sv1, sv2;
00517 char FrameIndexFileName[13];
00518 FILE *FrameFile, *FrameIndexFile;
00519 real eps;
00520
00521 if (NumVectors > MAXVECTORS)
00522 {
00523 fprintf(stderr, "CreateFrameArray: falta memoria!\n");
00524 return;
00525 }
00526 if ((FrameFile = fopen(FrameFileName, "r")) == (FILE *)NIL)
00527 {
00528 fprintf(stderr, "CreateFrameArray: erro ao abrir arquivo %s\n",
00529 FrameFileName);
00530 return;
00531 }
00532 eps = FILTERPRECISION;
00533 flag = filt = NumVectorsNew = 0;
00534 while (fscanf(FrameFile, "%d %d %f %f %f %f", &auxcor, &auxtipo,
00535 &sv1, &sv2, &ev1, &ev2) == 6)
00536 {
00537 for (auxvp = Vectors, k = 0; k < NumVectorsNew; k++)
00538 {
00539 flag = 0;
00540 if (compara(auxvp->px1, sv1, eps))
00541 {
00542 if (compara(auxvp->py1, sv2, eps))
00543 {
00544 if (compara(auxvp->px2, ev1, eps))
00545 {
00546 if (compara(auxvp->py2, ev2, eps))
00547 {
00548 flag = filt = 1;
00549 break;
00550 }
00551 }
00552 }
00553 }
00554 if (compara(auxvp->px2, sv1, eps))
00555 {
00556 if (compara(auxvp->py2, sv2, eps))
00557 {
00558 if (compara(auxvp->px1, ev1, eps))
00559 {
00560 if (compara(auxvp->py1, ev2, eps))
00561 {
00562 flag = filt = 1;
00563 break;
00564 }
00565 }
00566 }
00567 }
00568 auxvp++;
00569 }
00570 if (flag == 0)
00571 {
00572 Vectors[NumVectorsNew].cor = auxcor;
00573 Vectors[NumVectorsNew].tlinha = auxtipo;
00574 Vectors[NumVectorsNew].px1 = sv1;
00575 Vectors[NumVectorsNew].py1 = sv2;
00576 Vectors[NumVectorsNew].px2 = ev1;
00577 Vectors[NumVectorsNew].py2 = ev2;
00578 NumVectorsNew++;
00579 }
00580 }
00581 fclose(FrameFile);
00582
00583 if (filt == 1)
00584 {
00585 fprintf(stderr, "Reescrevendo o arquivo %s %d --> %d\n",
00586 FrameFileName, NumVectors, NumVectorsNew);
00587 if ((FrameFile = fopen(FrameFileName, "w")) == (FILE *)NIL)
00588 {
00589 fprintf(stderr, "CreateFrameArray: erro ao abrir arquivo %s\n",
00590 FrameFileName);
00591 return;
00592 }
00593 for (vp = Vectors, k = 0; k < NumVectorsNew; k++, vp++)
00594 {
00595 fprintf(FrameFile, "%2d %2d %10.6f %10.6f %10.6f %10.6f\n",
00596 vp->cor, vp->tlinha, vp->px1, vp->py1, vp->px2, vp->py2);
00597 }
00598 fclose(FrameFile);
00599 }
00600 else
00601 {
00602 NumVectorsNew = NumVectors;
00603 fprintf(stderr, "Arquivo %s %d\n", FrameFileName, NumVectorsNew);
00604 }
00605
00606 strcpy(FrameIndexFileName, AnimeName);
00607 strcat(FrameIndexFileName, "000.dsp");
00608 if ((FrameIndexFile = fopen(FrameIndexFileName, opcao == 1 ? "w" : "a")) ==
00609 (FILE *)NIL)
00610 {
00611 fprintf(stderr, "CreateFrameArray: erro ao abrir arquivo %s!\n",
00612 FrameIndexFileName);
00613 return;
00614 }
00615 fprintf(FrameIndexFile, "%s %d\n", FrameFileName, NumVectorsNew);
00616 fclose(FrameIndexFile);
00617 }
00618
00619 int compara(real x, real y, real eps)
00620 {
00621 if (fabs(x - y) < eps)
00622 {
00623 return(TRUE);
00624 }
00625 return(FALSE);
00626 }