home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / developm / source / macraysh.sit / Code / Source / macdelete.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-05-13  |  7.0 KB  |  365 lines
  1. /* Macdelete
  2.  * A collection of routines for the removal of objects from memory
  3.  */
  4.  
  5. #include "texture.h"
  6. #include "geom.h"
  7. #include "surface.h"
  8. #include "light.h"
  9.  
  10. #include "list.h"
  11. #include "grid.h"
  12. #include "sphere.h"
  13. #include "box.h"
  14. #include "blob.h"
  15. #include "disc.h"
  16. #include "cone.h"
  17. #include "plane.h"
  18. #include "cylinder.h"
  19. #include "sampling.h"
  20. #include "csg.h"
  21. #include "instance.h"
  22. #include "triangle.h"
  23. #include "hf.h"
  24. #include "poly.h"
  25.  
  26. #include "image.h"
  27. #include "blotch.h"
  28. #include "bump.h"
  29. #include "checker.h"
  30. #include "cloud.h"
  31. #include "fbm.h"
  32. #include "fbmbump.h"
  33. #include "gloss.h"
  34. #include "imagetext.h"
  35. #include "marble.h"
  36. #include "mount.h"
  37. #include "sky.h"
  38. #include "stripe.h"
  39. #include "windy.h"
  40. #include "wood.h"
  41.  
  42. #include "maceditor.h"
  43.  
  44. char UnlinkObject(Geom *obj, Geom *parent)
  45. {
  46.     Geom *p;
  47.     Grid *grid;
  48.     List *list;
  49.     char found;
  50.     
  51.     if(!obj || !parent) return;
  52.  
  53.     found = FALSE;
  54.     switch(ObjectType(parent)) {
  55.         case LIST:
  56.             list = parent->obj;
  57.             if(list->list) {
  58.                 if(list->list==obj) {
  59.                     list->list = obj->next;
  60.                     parent->prims--;
  61.                     return TRUE;
  62.                 }
  63.                 p = list->list;
  64.                 while((p->next != obj) && p) p = p->next;
  65.                 if(p) {
  66.                     p->next = obj->next ;
  67.                     parent->prims--;
  68.                     return TRUE;
  69.                 }
  70.             }
  71.             if(list->unbounded) {
  72.                 if(list->unbounded==obj) {
  73.                     list->unbounded = obj->next;
  74.                     parent->prims--;
  75.                     return TRUE;
  76.                 }
  77.                 p = list->unbounded;
  78.                 while((p->next != obj) && p) p = p->next;
  79.                 if(p) {
  80.                     p->next = obj->next;
  81.                     parent->prims--;
  82.                     return TRUE;
  83.                 }
  84.             }
  85.             break;
  86.         case GRID:
  87.             grid = parent->obj;
  88.             if(grid->objects) {
  89.                 if(grid->objects==obj) {
  90.                     grid->objects = obj->next;
  91.                     parent->prims--;
  92.                     found = TRUE;
  93.                 }
  94.                 p = grid->objects;
  95.                 while((p->next != obj) && p) p = p->next;
  96.                 if(p) {
  97.                     p->next = obj->next ;
  98.                     parent->prims--;
  99.                     found = TRUE;
  100.                 }
  101.             }
  102.             if(grid->unbounded) {
  103.                 if(grid->unbounded==obj) {
  104.                     grid->unbounded = obj->next;
  105.                     parent->prims--;
  106.                     found = TRUE;
  107.                 }
  108.                 p = grid->unbounded;
  109.                 while((p->next != obj) && p) p = p->next;
  110.                 if(p) {
  111.                     p->next = obj->next;
  112.                     parent->prims--;
  113.                     found = TRUE;
  114.                 }
  115.             }
  116.             /* If we found obj anywhere, we must remove it from the voxel array lists */
  117.             if(found==TRUE) {
  118.                 short x,y,z;
  119.                 GeomList *cell, *cell2;
  120.                 
  121.                 for(x = 0 ; x < grid->xsize; x++) {
  122.                     for(y = 0 ; y < grid->ysize; y++) {
  123.                         for(z = 0 ; z < grid->zsize; z++) {
  124.                             cell = grid->cells[x][y][z];
  125.                             if(cell) {
  126.                                 if(cell->obj == obj) {
  127.                                     grid->cells[x][y][z] = cell->next;
  128.                                     Free(cell);
  129.                                 }
  130.                                 else {
  131.                                     cell2 = cell->next;
  132.                                     while(cell2 && (cell2->obj != obj)) {
  133.                                         cell = cell2;
  134.                                         cell2 = cell->next;
  135.                                     }
  136.                                     if(cell2) {
  137.                                         cell->next = cell2->next;
  138.                                         Free(cell2);
  139.                                     }
  140.                                 }
  141.                             }
  142.                         }
  143.                     }
  144.                 }
  145.             }
  146.             return found;
  147.             break;
  148.         case CSG:
  149.             RLerror(RL_WARN,"Sorry, Rayshade-M cannot delete single objects in a CSG",0,0,0);
  150.             break;
  151.     }
  152.     return FALSE;
  153. }
  154.  
  155. void DeleteSurface(Surface *surf)
  156. {
  157.     if(surf == NULL)
  158.         return ;
  159.     if(surf->name)
  160.         Free(surf->name) ;
  161.     Free(surf) ;
  162. }
  163.  
  164. void DeleteTrans(Trans *trans)
  165. {
  166.     if(trans == NULL)
  167.         return ;
  168.     Free(trans->tr);
  169.     Free(trans);
  170. }
  171.  
  172. void DeleteImage(Image *image)
  173. {
  174.     if(image == NULL)
  175.         return ;
  176.     
  177.     if(image->data)
  178.         Free(image->data) ;
  179.     if(image->filename)
  180.         Free(image->filename) ;
  181. }
  182.  
  183. void DeleteColorMap(Color *map)
  184. {
  185.     if(map == NULL)
  186.         return ;
  187.     Free(map) ;
  188. }
  189.  
  190. void DeleteMapping(Mapping *map)
  191. {
  192.     if(map == NULL)
  193.         return ;
  194.     Free(map) ;
  195. }
  196.  
  197. void DeleteTexture(Texture *text)
  198. {
  199.     if(text == NULL)
  200.         return ;
  201.         
  202.     switch(TextureType(text)) {    
  203.         case T_BLOTCH:
  204.             DeleteSurface(((Blotch *) text->data)->surf) ;
  205.             break ;
  206.         case T_BUMP:
  207.             break ;            
  208.         case T_CHECKER:
  209.             DeleteSurface(((Checker *) text->data)->surf) ;
  210.             break ;
  211.         case T_CLOUD:
  212.             break ;
  213.         case T_FBM:
  214.             DeleteColorMap(((FBm *) text->data)->colormap) ;
  215.             break ;
  216.         case T_FBMBUMP:
  217.             break ;
  218.         case T_GLOSS:
  219.             break ;
  220.         case T_IMAGE:
  221.             DeleteImage(((ImageText *) text->data)->image) ;
  222.             DeleteMapping(((ImageText *) text->data)->mapping) ;
  223.             break ;
  224.         case T_MARBLE:
  225.             break ;
  226.         case T_SKY:
  227.             break ;
  228.         case T_STRIPE:
  229.             DeleteSurface(((Stripe *) text->data)->surf) ;
  230.             DeleteMapping(((Stripe *) text->data)->mapping) ;
  231.             break ;
  232.         case T_WOOD:
  233.             break ;
  234.     }
  235.     if(text->data) Free(text->data) ;
  236.     DeleteTrans(text->trans) ;
  237. }
  238.  
  239. void DeleteLight(Light *light)
  240. {
  241.     if(!light) return;
  242.     Free(light->light);
  243.     Free(light->cache);
  244.     Free(light);
  245. }
  246.  
  247. void DeleteObject(Geom *obj)
  248. {
  249.     Trans *trans, *newtrans ;
  250.     if(obj == NULL)
  251.         return ;
  252.  
  253.     switch(ObjectType(obj)) {
  254.         case PLANE:
  255.             break ;
  256.         case SPHERE:
  257.             break ;
  258.         case CONE:
  259.             break ;
  260.         case BOX:
  261.             break ;
  262.         case TORUS:
  263.             break ;
  264.         case BLOB:
  265.             if(((Blob *)obj->obj)->list) Free(((Blob *)obj->obj)->list) ;
  266.             if(((Blob *)obj->obj)->ilist) Free(((Blob *)obj->obj)->ilist) ;
  267.             if(((Blob *)obj->obj)->iarr) Free(((Blob *)obj->obj)->iarr) ;
  268.             break ;
  269.         case DISC:
  270.             break ;
  271.         case TRIANGLE:
  272.             if(((Triangle *)obj->obj)->vnorm) Free(((Triangle *)obj->obj)->vnorm) ;
  273.             if(((Triangle *)obj->obj)->dpdu) Free(((Triangle *)obj->obj)->dpdu) ;
  274.             if(((Triangle *)obj->obj)->dpdv) Free(((Triangle *)obj->obj)->dpdv) ;
  275.             if(((Triangle *)obj->obj)->uv) Free(((Triangle *)obj->obj)->uv) ;
  276.             break ;
  277.         case POLYGON:
  278.             if(((RPolygon *)obj->obj)->points) Free(((RPolygon *)obj->obj)->points) ;
  279.             break ;
  280.         case HF:
  281.             {
  282.                 Hf *hf ;
  283.                 int i,j ;
  284.                 
  285.                 hf = obj->obj ;
  286.                 
  287.                 for(i = 0 ; i < hf->size ; i++)
  288.                     Free(hf->data[i]) ;
  289.                 Free(hf->data) ;
  290.                 Free(hf->q) ;
  291.                 for(i = 0 ; i <hf->lsize[0] ; i++) {
  292.                     Free(hf->boundsmax[0][i]) ;    
  293.                     Free(hf->boundsmin[0][i]) ;    
  294.                 }
  295.                 
  296.                 for(i = 1 ; i < hf->levels ; i++) {
  297.                     for(j = 0 ; j < hf->lsize[i] ; j++) {
  298.                         Free(hf->boundsmax[i][j]) ;    
  299.                         Free(hf->boundsmin[i][j]) ;    
  300.                     }
  301.                 }
  302.                 Free(hf->boundsmax[0]) ;
  303.                 Free(hf->boundsmin[0]) ;
  304.                 Free(hf->boundsmax) ;
  305.                 Free(hf->boundsmin) ;
  306.                 Free(hf->spacing) ;
  307.                 Free(hf->lsize) ;
  308.             }
  309.             break ;
  310.         case CYLINDER:
  311.             break ;
  312.         case CSG:
  313.             DeleteObject(((Csg *)obj->obj)->obj1) ;
  314.             DeleteObject(((Csg *)obj->obj)->obj2) ;
  315.             break ;
  316.         case LIST:
  317.             {
  318.                 Geom *obj2, *next ;
  319.             
  320.                 obj2 = ((List *)obj->obj)->list ;
  321.                 while(obj2) {
  322.                     next = obj2->next ;
  323.                     DeleteObject(obj2) ;
  324.                     obj2 = next ;
  325.                 }
  326.             }
  327.             break ;
  328.         case GRID:
  329.             {
  330.                 Geom *obj2, *next;
  331.                 Grid *grid;
  332.                 
  333.                 grid = (Grid *)obj->obj;
  334.                 
  335.                 obj2 = grid->objects;
  336.                 while(obj2) {
  337.                     next = obj2->next;
  338.                     DeleteObject(obj2);
  339.                     obj2 = next;
  340.                 }
  341.                 obj2 = grid->unbounded;
  342.                 while(obj2) {
  343.                     next = obj2->next;
  344.                     DeleteObject(obj2);
  345.                     obj2 = next;
  346.                 }
  347.                 /* Use a procedure already provided in grid.c */
  348.                 if(grid->cells)
  349.                     GridFreeVoxels(grid);
  350.             }
  351.             break ;
  352.         case INSTANCE:
  353.             break ;
  354.     }
  355.     if(obj->name) Free(obj->name) ;
  356.     if(obj->obj) Free(obj->obj) ;
  357.     DeleteSurface(obj->surf) ;
  358.     trans = obj->trans ;
  359.     while(trans) {
  360.         newtrans = trans->next ;
  361.         DeleteTrans(trans) ;
  362.         trans = newtrans ;
  363.     }
  364.     DeleteTexture(obj->texture) ;
  365. }