src/video/coredraw.c

   1 /*
   2  * libneuro, a light weight abstraction of high or lower libraries
   3  * and toolkit for applications.
   4  * Copyright (C) 2005-2006  Nicholas Niro, Robert Lemay
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  */
  20
  21 /* coredraw.c
  22  * the core drawing algorithm.
  23  */
  24
  25 /*-------------------- Extern Headers Including --------------------*/
  26 #include <string.h> /* memcpy */
  27
  28 /*-------------------- Local Headers Including ---------------------*/
  29 #include <extlib.h> /* we mainly use the blitting function and screen updating functions */
  30 #include <ebuf.h> /* we mainly use the single item cleaning function Neuro_SCleanEBuf */
  31
  32 /*-------------------- Main Module Header --------------------------*/
  33 #include "video.h"
  34 #include <graphics.h>
  35
  36
  37 /*--------------------      Other       ----------------------------*/
  38
  39 /*-------------------- Global Variables ----------------------------*/
  40
  41 /*-------------------- Static Variables ----------------------------*/
  42
  43 /*-------------------- Static Prototypes ---------------------------*/
  44
  45
  46
  47 /*-------------------- Static Functions ----------------------------*/
  48
  49 /* a function to resolve a bug that made the volatile objects
  50  * mysteriously disapear. It was because the last element of the
  51  * Dynamic object was not refreshed so if an element was just
  52  * before the Dynamic object, it just made it disapear :).
  53  *
  54  * This function searches the element just before the input element
  55  * and returns it.
  56  */
  57 static INSTRUCTION_ENGINE *
  58 get_Previous_Object_To_Object(INSTRUCTION_ENGINE *indep)
  59 {
  60         INSTRUCTION_ENGINE *cur, *last = NULL;
  61
  62         cur = Graphics_GetFirstElem();
  63
  64         if (cur == NULL)
  65                 return NULL;
  66
  67         if (indep == cur)
  68                 return NULL;
  69
  70         while (cur)
  71         {
  72
  73                 if (cur == indep)
  74                 {
  75                         /* Debug_Val(0, "found the previous elem 0x%x, (his next 0x%x)\n",
  76                                         last, last->next);*/
  77                         return last;
  78                 }
  79
  80
  81                 last = cur;
  82                 cur = cur->next;
  83         }
  84
  85
  86         return NULL;
  87 }
  88
  89 /* del_mask : 0 is don't clean any buffers (big memory leak)
  90  * 1 is clean only the raw engine
  91  * 2 is clean only the queue(instruction) engine
  92  * 3 is clean both
  93  */
  94 static void
  95 Core_clean_object(INSTRUCTION_ENGINE *cur, int dont_redraw_section, u8 del_mask)
  96 {
  97         Rectan buf;
  98         INSTRUCTION_ENGINE *last = NULL;
  99         EBUF *verify_m;
 100
 101         /* this functions needs to destroy an element
 102          * from both the instruction buffer and the raw
 103          * buffer.
 104          *
 105          * the first step we do is fill a special Rectan
 106          * rectangle with the position and size of
 107          * the image. Then, we draw this position and
 108          * size black on screen. After that is done, we
 109          * have to redraw previous objects (if theres any).
 110          *
 111          *
 112          */
 113
 114         if (debug_track_fonts)
 115         {
 116                 if (cur->current->layer >= 99999)
 117                 {
 118                         Debug_Print("Destroying font");
 119                         Debug_Val(0, "&0x%x\n", cur);
 120                 }
 121         }
 122
 123         /* Graphics_DebugQueueIntegrityCheck(); */
 124
 125         if (!cur)
 126                 return;
 127
 128         /* Debug_Val(0, "destroying element address 0x%x\n", cur); */
 129
 130         buf.x = cur->current->dx;
 131         buf.y = cur->current->dy;
 132         buf.w = cur->current->src.w;
 133         buf.h = cur->current->src.h;
 134
 135         /*if (background)
 136                 Lib_BlitObject(background, &buf, sclScreen2, &buf);
 137         else
 138                 Lib_FillRect(sclScreen2, &buf, 0);
 139         */
 140
 141         if (dont_redraw_section == 0)
 142         {
 143                 Lib_FillRect(Neuro_GetScreenBuffer(), &buf, 0);
 144
 145                 Graphics_RedrawSection(cur);
 146         }
 147
 148         if (debug_clean_instruction_buffer)
 149         {
 150                 Neuro_CreateEBuf(&verify_m);
 151                 Graphics_DebugBufferQueue(verify_m);
 152         }
 153
 154         if (debug_clean_instruction_buffer)
 155         {
 156                 Debug_Print("*initial values");
 157                 Debug_Val(0, "Amount of elems %d\n", Neuro_GiveEBufCount(verify_m) - 1);
 158                 Graphics_DebugPrintMissing(verify_m);
 159         }
 160
 161         /* only set the previous element (last) if the element we need to
 162          * destroy isn't the first one
 163          */
 164         if (cur != Graphics_GetFirstElem())
 165                 last = get_Previous_Object_To_Object(cur);
 166         if (last)
 167         {
 168                 /* Debug_Val(0, "changing last's(0x%x) next 0x%x to 0x%x\n", last,
 169                                 last->next, cur->next);*/
 170
 171                 last->next = cur->next;
 172         }
 173
 174         /* check to see if the element cur is either first_element
 175          * or last_element and if so, we will destituate it.
 176          */
 177         if (cur == Graphics_GetFirstElem())
 178         {
 179                 Graphics_SetFirstElem(cur->next);
 180         }
 181
 182         if (cur == Graphics_GetLastElem())
 183         {
 184                 if (last)
 185                 {
 186                         last->next = NULL;
 187                         Graphics_SetLastElem(last);
 188                 }
 189                 else
 190                         Graphics_SetLastElem(NULL);
 191         }
 192
 193         if (debug_clean_instruction_buffer)
 194         {
 195                 Debug_Print("*before real destroy");
 196                 Graphics_DebugPrintMissing(verify_m);
 197         }
 198
 199         /*if (use_memory_pool)
 200                 Push_Data_To_Pool(POOL_QUEUE, cur);
 201         else*/
 202         {
 203                 /* INSTRUCTION_ENGINE *temp; */
 204
 205                 /*
 206                 temp = cur;
 207                 cur = cur->next;
 208                 */
 209
 210                 /* Debug_Val(0, "before queue total %d\n",
 211                                 Neuro_GiveEBufCount(_Queue) + 1);*/
 212
 213                 if (del_mask == 1 || del_mask == 3)
 214                         Neuro_SCleanEBuf(Graphics_GetRawBuffer(), cur->current);
 215                 /* Debug_Val(0, "-- element address 0x%x destroyed\n", cur); */
 216                 if (del_mask == 2 || del_mask == 3)
 217                         Neuro_SCleanEBuf(Graphics_GetQueueBuffer(), cur);
 218
 219                 /* Debug_Val(0, "after queue total %d\n",
 220                                 Neuro_GiveEBufCount(_Queue) + 1); */
 221                 /* continue; */
 222         }
 223
 224         if (debug_clean_instruction_buffer)
 225         {
 226                 Debug_Print("**After the destroy");
 227                 /*Debug_Val(0, "Amount of elems in verify %d in queue %d\n",
 228                                 Neuro_GiveEBufCount(verify_m) - 1,
 229                                 Neuro_GiveEBufCount(_Queue) - 1);*/
 230                 Debug_Print("**Full output");
 231
 232                 Graphics_DebugPrintQueue();
 233
 234                 Graphics_DebugPrintMissing(verify_m);
 235                 Neuro_CleanEBuf(&verify_m);
 236         }
 237
 238         /* Graphics_DebugQueueIntegrityCheck(); */
 239 }
 240
 241 static void
 242 clean_object(INSTRUCTION_ENGINE *cur, int dont_redraw_section)
 243 {
 244         Core_clean_object(cur, dont_redraw_section, 3);
 245 }
 246
 247 /*-------------------- Global Functions ----------------------------*/
 248
 249 /* take note that we don't do any checks for valid pointers and such
 250  * this function is supposed to be a backbone to an interface function
 251  * which itself does the parity checks.
 252  */
 253 void
 254 Graphics_DestroyElement(INSTRUCTION_ENGINE *elem)
 255 {
 256         RAW_ENGINE *tmp;
 257         Rectan dst;
 258
 259         /* we destroy only the queue buffer because we want to make
 260          * the emplacement of the element into a more comfortable
 261          * place for the algorithm to avoid glitches.
 262          */
 263
 264         tmp = elem->current;
 265
 266         /* we clean only the queue element and keep the raw engine buffer */
 267         Core_clean_object(elem, 1, 2);
 268
 269         dst.x = tmp->dx;
 270         dst.y = tmp->dy;
 271
 272         tmp->type = TDRAW_SDESTROY;
 273
 274         /* we put the raw buffer back into the queue */
 275         Graphics_PushRaw(tmp);
 276 }
 277
 278 void
 279 Graphics_CoreDrawAll()
 280 {
 281         Rectan isrc, idst;
 282         INSTRUCTION_ENGINE *cur, *last = NULL;
 283         u32 safety = 10000; /* safety decrementor to avoid death loop */
 284
 285         if (Neuro_EBufIsEmpty(Graphics_GetQueueBuffer()))
 286                 return;
 287
 288         cur = Graphics_GetFirstElem();
 289
 290         /* start the real drawing */
 291         while (cur)
 292         {
 293
 294                 if (safety <= 0)
 295                 {
 296                         Error_Print("To avoid a death loop, had to bail out of the instruction loop after 1000 loops");
 297                         break; /* safety break */
 298                 }
 299                 else
 300                         safety--;
 301
 302                 if (check_integrity_on_draw)
 303                 {
 304                         Debug_Print("Data integrity check before drawing");
 305                         Graphics_DebugQueueIntegrityCheck();
 306                 }
 307
 308                 memcpy(&isrc, &cur->current->src, sizeof(Rectan));
 309
 310                 idst.x = cur->current->dx;
 311                 idst.y = cur->current->dy;
 312
 313                 if (debug_instruction_buffer)
 314                         Debug_Val(0, "%s Flushing type %d layer %d\n", __FUNCTION__, cur->current->type, cur->current->layer);
 315
 316                 /* draw the surface_ptr to the screen buffer. */
 317                 switch (cur->current->type)
 318                 {
 319                         case TDRAW_STATIC:
 320                         {
 321
 322                                 /* Debug_Val(0, "static draw (%d,%d) %dx%d to (%d,%d)\n",
 323                                                 isrc.x, isrc.y, isrc.w, isrc.h,
 324                                                 idst.x, idst.y);
 325
 326                                 */
 327
 328
 329                                 Lib_BlitObject(cur->current->surface_ptr, &isrc, Neuro_GetScreenBuffer(),
 330                                                 &idst);
 331
 332                                 cur->current->type = TDRAW_SDRAWN;
 333
 334                                 /* Graphics_RedrawSection(cur); */
 335
 336                                 /* Debug_Val(0, "drawn static\n"); */
 337
 338                                 if (debug_track_fonts)
 339                                 {
 340                                         if (cur->current->layer >= 99999)
 341                                         {
 342                                                 Debug_Print("Drawing font");
 343                                                 Debug_Val(0, "Coord (%d,%d) &0x%x\n",
 344                                                                 cur->current->dx,
 345                                                                 cur->current->dy, cur);
 346                                         }
 347                                 }
 348                         }
 349                         break;
 350
 351                         case TDRAW_SDRAWN:
 352                         {
 353                                 /* nothing needed for this type */
 354                                 /* Debug_Val(0, "already drawn\n"); */
 355                         }
 356                         break;
 357
 358                         case TDRAW_SREDRAW:
 359                         {
 360                                 /* Debug_Val(0, "address of surface 0x%x\n", cur->current->surface_ptr); */
 361
 362                                 /* now we redraw the actual element */
 363                                 Lib_BlitObject(cur->current->surface_ptr, &isrc, Neuro_GetScreenBuffer(),
 364                                                 &idst);
 365
 366                                 /* we cleanly redrawn the static element so we
 367                                  * set the element's flag to drawn
 368                                  */
 369                                 cur->current->type = TDRAW_SDRAWN;
 370
 371                                 /* then we redraw the stuff that could have been
 372                                  * there and actually need to be visible(and are above
 373                                  * our element, ie layers).
 374                                  *
 375                                  * broken for some reason
 376                                  */
 377                                 Graphics_RedrawSection(cur);
 378
 379                                 /* Debug_Val(0, "Redrawn a static element\n"); */
 380                         }
 381                         break;
 382
 383                         case TDRAW_SDESTROY:
 384                         {
 385                                 INSTRUCTION_ENGINE *tmp;
 386                                 /*
 387                                 if (cur->current->layer > 1000)
 388                                         Debug_Print("Cleaned a static image");
 389                                 */
 390
 391                                 tmp = cur;
 392
 393                                 cur = cur->next;
 394
 395                                 clean_object(tmp, 0);
 396
 397                                 /* we restart the loop completely since we need to draw
 398                                  * the volatile types first before drawing the rest..
 399                                  */
 400                                 cur = Graphics_GetFirstElem();
 401
 402                                 if (cur)
 403                                         continue;
 404                         }
 405                         break;
 406
 407                         case TDRAW_DYNAMIC:
 408                         {
 409                                 Lib_BlitObject(cur->current->surface_ptr, &isrc,
 410                                                 Neuro_GetScreenBuffer(), &idst);
 411
 412                                 cur->current->type = TDRAW_DYNAMIC_CLEAN;
 413
 414                                 if (dynamic_debug)
 415                                         Debug_Val(0, "Dynamic : Tagging addr %x to clean\n", cur);
 416                                 /* Debug_Val(0, "drawn dynamic\n"); */
 417                         }
 418                         break;
 419
 420 #if temp
 421                         case TDRAW_DYNAMIC_CLEAN:
 422                         {
 423                                 /* Lib_BlitObject(cur->current->surface_ptr, &isrc,
 424                                                 sclScreen2, &idst);*/
 425
 426                                 /* clean_object(cur); */
 427                         }
 428                         break;
 429 #endif /* temp */
 430
 431                         case TDRAW_VOLATILE:
 432                         {
 433                                 /*Debug_Val(0, "Volatile draw (%d,%d) %dx%d to (%d,%d) image 0x%x\n",
 434                                                 isrc.x, isrc.y, isrc.w, isrc.h,
 435                                                 idst.x, idst.y,
 436                                                 cur->current->surface_ptr);
 437                                 */
 438
 439                                 Lib_BlitObject(cur->current->surface_ptr, &isrc,
 440                                                 Neuro_GetScreenBuffer(), &idst);
 441
 442                                 /* NOTE that we CAN't USE clean_object() BECAUSE
 443                                  * it actually makes the image all BLACK
 444                                  * so it nullifies the action of this COMPLETELY.
 445                                  */
 446                                 if (last)
 447                                         last->next = cur->next;
 448
 449                                 /* check to see if the element cur is either first_element
 450                                  * or last_element and if so, we will destituate it.
 451                                  */
 452                                 if (cur == Graphics_GetFirstElem())
 453                                 {
 454                                         Graphics_SetFirstElem(cur->next);
 455                                 }
 456
 457                                 if (cur == Graphics_GetLastElem())
 458                                 {
 459                                         if (last)
 460                                         {
 461                                                 last->next = NULL;
 462                                                 Graphics_SetLastElem(last);
 463                                         }
 464                                 }
 465
 466
 467                                 /*if (use_memory_pool)
 468                                         Push_Data_To_Pool(POOL_QUEUE, cur);
 469                                 else*/
 470                                 {
 471                                         INSTRUCTION_ENGINE *temp;
 472
 473                                         temp = cur;
 474                                         cur = cur->next;
 475
 476                                         Neuro_SCleanEBuf(Graphics_GetRawBuffer(), temp->current);
 477                                         Neuro_SCleanEBuf(Graphics_GetQueueBuffer(), temp);
 478
 479                                         if (cur)
 480                                                 continue;
 481                                 }
 482                         }
 483                         break;
 484
 485
 486                         default:
 487                         {
 488                                 Debug_Val(0, "ERROR Draw unknown type %d\n", cur->current->type);
 489                         }
 490                         break;
 491                 }
 492
 493                 if (cur)
 494                 {
 495                         last = cur;
 496                         if (cur->next == NULL && cur != Graphics_GetLastElem())
 497                         {
 498                                 Error_Print("cur->next is NULL AND it isn't the last element, bad, very bad...");
 499                         }
 500                         cur = cur->next;
 501                 }
 502                 else
 503                         break;
 504         }
 505
 506
 507         Graphics_SetDrawnLastCycle();
 508         /* Lib_FillRect(sclScreen, &test_BoundFix, 0); */
 509 }
 510
 511 void
 512 Graphics_SetAllToRedraw()
 513 {
 514         INSTRUCTION_ENGINE *cur;
 515
 516         cur = Graphics_GetFirstElem();
 517
 518         if (cur == NULL)
 519                 return;
 520
 521         while (cur)
 522         {
 523                 if (cur->current->type == TDRAW_SDRAWN)
 524                         cur->current->type = TDRAW_STATIC; /* TDRAW_SREDRAW seems to do a flaw */
 525
 526                 cur = cur->next;
 527         }
 528
 529         if (debug_instruction_buffer)
 530                 Debug_Print("Just Set all the instructions to be redrawn");
 531 }
 532
 533 /* Graphics_CoreCleanAll might have cleaned objects
 534  * that should be drawn so we will redraw those in this
 535  * function.
 536  * returns non zero if a volatile type was pushed
 537  */
 538 int
 539 Graphics_RedrawSection(INSTRUCTION_ENGINE *indep)
 540 {
 541         Rectan buf, indep_body;
 542         INSTRUCTION_ENGINE *cur;
 543         int bounds_ret = 0;
 544         int output = 0;
 545
 546
 547         indep_body.x = indep->current->dx;
 548         indep_body.y = indep->current->dy;
 549         indep_body.w = indep->current->src.w;
 550         indep_body.h = indep->current->src.h;
 551
 552         cur = Graphics_GetFirstElem();
 553
 554         if (cur == NULL)
 555                 return 0;
 556
 557         while (cur)
 558         {
 559
 560                 if (cur == indep)
 561                 {
 562                         cur = cur->next;
 563                         continue;
 564                 }
 565
 566                 if (!cur->current)
 567                 {
 568                         Debug_Val(0, "BAD : the instruction 0x%x has an empty content!\n",
 569                                         cur);
 570
 571                         Debug_Val(0, "DEBUG data : indep 0x%x  its next element 0x%x\n",
 572                                         indep, indep->next);
 573                         /* odd error, this ain't supposed to happen :L */
 574                         return 0;
 575                 }
 576
 577                 if (debug_track_fonts)
 578                 {
 579                         if (cur->current->layer >= 99999 && indep->current->layer >= 99999)
 580                         {
 581                                 Debug_Print("INITIAL Redrawing font");
 582
 583                                 Debug_Val(0, "Font type %d (%d,%d) &0x%x\n", cur->current->type,
 584                                                 buf.x, buf.y, cur);
 585                         }
 586                 }
 587
 588                 if (cur->current->type == TDRAW_SDRAWN)
 589                 {
 590
 591                         buf.x = cur->current->dx;
 592                         buf.y = cur->current->dy;
 593                         buf.w = cur->current->src.w;
 594                         buf.h = cur->current->src.h;
 595
 596                         bounds_ret = Neuro_BoundsCheck(&indep_body, &buf);
 597                         /* bounds_ret = 2; */
 598
 599                         if (debug_track_fonts)
 600                         {
 601                                 if (cur->current->layer >= 99999 && indep->current->layer >= 99999)
 602                                 {
 603                                         Debug_Print("INITIAL 2 Redrawing font");
 604                                         Debug_Val(0, "bounds_ret %d current (%d,%d) indep (%d,%d)\n",
 605                                                         bounds_ret,
 606                                                         buf.x, buf.y,
 607                                                         indep_body.x, indep_body.y);
 608                                 }
 609                         }
 610
 611                         if (bounds_ret == 0)
 612                         {
 613                                 Rectan bufa;
 614
 615                                 bufa.x = cur->current->dx;
 616                                 bufa.y = cur->current->dy;
 617                                 bufa.w = 0;
 618                                 bufa.h = 0;
 619
 620                                 Neuro_PushVolatileDraw(cur->current->layer, &cur->current->src,
 621                                                 &bufa, cur->current->surface_ptr);
 622
 623                                 /*Debug_Val(0, "dynamic is inside this object\n");*/
 624
 625                                 if (debug_track_fonts)
 626                                 {
 627                                         if (cur->current->layer >= 99999)
 628                                                 Debug_Print("Redrawing font #0");
 629                                 }
 630
 631                                 output = 1;
 632                         }
 633
 634                         if (bounds_ret == 2)
 635                         {
 636                                 Rectan isrc, idst;
 637
 638                                 memcpy(&isrc, &cur->current->src, sizeof(Rectan));
 639
 640                                 idst.x = cur->current->dx;
 641                                 idst.y = cur->current->dy;
 642                                 idst.w = 0;
 643                                 idst.h = 0;
 644
 645                                 Neuro_VerticalBoundCrop(&indep_body, &isrc, &idst);
 646                                 Neuro_HorizontalBoundCrop(&indep_body, &isrc, &idst);
 647
 648                                 Neuro_PushVolatileDraw(cur->current->layer,
 649                                                 &isrc, &idst, cur->current->surface_ptr);
 650
 651                                 if (debug_track_fonts)
 652                                 {
 653                                         if (cur->current->layer >= 99999)
 654                                                 Debug_Print("Redrawing font #2");
 655                                 }
 656
 657                                 output = 1;
 658                         }
 659
 660                         if (bounds_ret == 3)
 661                         {
 662                                 Rectan isrc, idst, hack;
 663
 664                                 memcpy(&isrc, &cur->current->src, sizeof(Rectan));
 665
 666                                 idst.x = cur->current->dx;
 667                                 idst.y = cur->current->dy;
 668                                 idst.w = 0;
 669                                 idst.h = 0;
 670
 671
 672                                 if (indep_body.x > buf.x)
 673                                 {
 674                                         isrc.x += indep_body.x - buf.x;
 675                                         idst.x += indep_body.x - buf.x;
 676
 677                                         /*isrc.y += buf.y - indep_body.y;
 678                                         idst.y += buf.y - indep_body.y;*/
 679
 680                                         isrc.w -= buf.w - indep_body.w;
 681                                         /* isrc.h += indep_body.h - buf.h; */
 682                                 }
 683                                 else
 684                                 {
 685                                         /*isrc.x += buf.x - indep_body.x;
 686                                         idst.x += buf.x - indep_body.x;*/
 687
 688                                         isrc.y += indep_body.y - buf.y;
 689                                         idst.y += indep_body.y - buf.y;
 690
 691                                         /* isrc.w += indep_body.w - buf.w; */
 692                                         isrc.h -= buf.h - indep_body.h;
 693                                 }
 694
 695                                 /* Neuro_PushVolatileDraw(cur->current->layer,
 696                                                 &isrc, &idst, cur->current->surface_ptr);*/
 697
 698                                 /* temporary hack that seems to work, we draw the whole
 699                                  * static image... this needs testing and a better
 700                                  * algorithm.
 701                                  */
 702
 703                                 hack.x = cur->current->dx;
 704                                 hack.y = cur->current->dy;
 705                                 hack.w = 0;
 706                                 hack.h = 0;
 707
 708                                 Neuro_PushVolatileDraw(cur->current->layer, &cur->current->src,
 709                                                 &hack, cur->current->surface_ptr);
 710
 711                                 /*Debug_Val(0, "we have a case 3 situation!\n");*/
 712
 713                                 if (debug_track_fonts)
 714                                 {
 715                                         if (cur->current->layer >= 99999)
 716                                                 Debug_Print("Redrawing font #3");
 717                                 }
 718
 719                                 output = 1;
 720                         }
 721
 722                         /* indep is inside cur */
 723                         if (bounds_ret == 4)
 724                         {
 725                                 Rectan bufa;
 726                                 Rectan nsrc;
 727
 728                                 bufa.x = indep_body.x;
 729                                 bufa.y = indep_body.y;
 730                                 bufa.w = 0;
 731                                 bufa.h = 0;
 732
 733                                 nsrc.x = indep_body.x - cur->current->dx;
 734                                 nsrc.y = indep_body.y - cur->current->dy;
 735                                 nsrc.w = indep_body.w;
 736                                 nsrc.h = indep_body.h;
 737
 738                                 /*
 739                                 bufa.x = 0;
 740                                 bufa.y = 0;
 741                                 bufa.w = 0;
 742                                 bufa.h = 0;
 743
 744                                 nsrc.x = 0;
 745                                 nsrc.y = 0;
 746                                 nsrc.w = cur->current->src.w;
 747                                 nsrc.h = cur->current->src.h;
 748                                 */
 749
 750                                 Neuro_PushVolatileDraw(cur->current->layer, &nsrc,
 751                                                 &bufa, cur->current->surface_ptr);
 752
 753                                 if (debug_track_fonts)
 754                                 {
 755                                         if (cur->current->layer >= 99999)
 756                                                 Debug_Print("Redrawing font #4");
 757                                 }
 758
 759                                 output = 1;
 760                         }
 761
 762                         /* Debug_Val(0, "Redraw Section debug #%d\n", bounds_ret); */
 763                 }
 764                 cur = cur->next;
 765         }
 766
 767         return output;
 768 }
 769
 770 void
 771 Graphics_CoreCleanAll()
 772 {
 773         INSTRUCTION_ENGINE *cur;
 774
 775         cur = Graphics_GetFirstElem();
 776
 777         if (cur == NULL)
 778                 return;
 779
 780         /* "reset" the emplacement of the last position of the image
 781          * with the background if theres one or with the color black
 782          * if none.
 783          */
 784         while (cur)
 785         {
 786                 clean_object(cur, 1);
 787
 788                 cur = cur->next;
 789         }
 790
 791         Graphics_ResetScreenDraw();
 792 }
 793
 794 /* only clean those with the type TDRAW_DYNAMIC_CLEAN */
 795 void
 796 Graphics_CoreCleanDoneDynamics()
 797 {
 798         INSTRUCTION_ENGINE *cur;
 799
 800         cur = Graphics_GetFirstElem();
 801
 802         if (cur == NULL)
 803                 return;
 804
 805         /* "reset" the emplacement of the last position of the image
 806          * with the background if theres one or with the color black
 807          * if none.
 808          */
 809         while (cur)
 810         {
 811                 if (cur->current->type == TDRAW_DYNAMIC_CLEAN)
 812                 {
 813                         clean_object(cur, 0);
 814                 }
 815
 816                 cur = cur->next;
 817         }
 818 }
 819
 820 void
 821 Graphics_FreeVObject(v_object *source)
 822 {
 823         INSTRUCTION_ENGINE *cur, *tmp;
 824
 825         /* this function was made to avoid the painter's algorithm
 826          * to have an element contain an image surface that was
 827          * freed before it was processed resulting in a segmentation
 828          * fault.
 829          */
 830
 831         cur = Graphics_GetFirstElem();
 832
 833         while (cur)
 834         {
 835                 tmp = cur->next;
 836
 837                 if (cur->current->surface_ptr == source)
 838                 {
 839                         /*if (cur->current->type == TDRAW_SDRAWN)
 840                                 Neuro_DestroyDraw(cur);
 841                         else*/
 842                                 Core_clean_object(cur, 0, 3);
 843                 }
 844
 845                 cur = tmp;
 846         }
 847
 848
 849         Lib_FreeVobject(source);
 850 }
 851