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