home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 5 / Amiga Tools 5.iso / grafik / converter / limbo4.0 / src / 2d / fileio.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-16  |  9.7 KB  |  312 lines
  1. #include "includes.h"
  2.  
  3.  Parameter *FileIO_Parm;
  4.  
  5. /**************************************|****************************************
  6. Routine   : SaveTrans
  7. Input  par: Transformation *T (pointer to trans)
  8.             char *file        (filename)
  9.             int dx            (delta x)
  10.             int dy            (delta y)
  11. Output par: none
  12. Function  : Saves transformation plus all its sub-transformation.
  13. ***************************************|***************************************/
  14.  
  15.  void SaveTrans(Transformation *T,char *file, int delta)
  16.   {
  17.    unsigned char out[]="dummy",temp,main=TRUE;
  18.    unsigned int i,j;
  19.    
  20.    if (T->Sub!=NULL) main=FALSE; /* check subblock configuration */
  21.    
  22.    out[0]=main;
  23.    IOBitArray(FILE_APPEND,file,FileIO_Parm->SBits,out); /* par/subs */
  24.    
  25.    if (main) /* should we save the transformation ? */
  26.     {
  27.      switch(T->Type)
  28.       {
  29.        case EDGEBLOCK : 
  30.        out[0]=0x00;  /* Type bit = 00 b */
  31.        IOBitArray(FILE_APPEND,file,1,out);
  32.        out[0]=(unsigned char)(T->Domain->x/delta);
  33.        IOBitArray(FILE_APPEND,file,FileIO_Parm->XBits,out);
  34.        out[0]=(unsigned char)(T->Domain->y/delta);
  35.        IOBitArray(FILE_APPEND,file,FileIO_Parm->YBits,out);
  36.        out[0]=(unsigned char)(T->Domain->z/delta);
  37.        out[0]=MakeRange(T->Alpha,FileIO_Parm);
  38.        IOBitArray(FILE_APPEND,file,FileIO_Parm->ABits,out);
  39. /*
  40.        if (T->Alpha<0.0) 
  41.         {
  42.          temp=MakeRange(-T->Alpha,FileIO_Parm);
  43.          out[0]=1;
  44.         }
  45.        else 
  46.         {
  47.          temp=MakeRange(T->Alpha,FileIO_Parm);
  48.          out[0]=0;
  49.         }
  50.        IOBitArray(FILE_APPEND,file,1,out);
  51.        out[0]=temp;
  52.        IOBitArray(FILE_APPEND,file,FileIO_Parm->ABits,out);
  53. */
  54.        
  55.        if (T->Deltag<0) 
  56.         {
  57.          temp=-T->Deltag;
  58.          out[0]=1;
  59.         }
  60.        else 
  61.         {
  62.          temp=T->Deltag;
  63.          out[0]=0;
  64.         }
  65.        IOBitArray(FILE_APPEND,file,1,out); /* save sign */
  66.        out[0]=temp;
  67.        IOBitArray(FILE_APPEND,file,FileIO_Parm->DBits,out);
  68.        
  69.        out[0]=(unsigned char)(T->tn);
  70.        IOBitArray(FILE_APPEND,file,FileIO_Parm->TBits,out);
  71.        break;
  72.        
  73.        case SHADEBLOCK :
  74.        out[0]=0x01;  /* Type bit = 10 b */
  75.        IOBitArray(FILE_APPEND,file,1,out);
  76.        out[0]=(unsigned char)(T->g0);
  77.        IOBitArray(FILE_APPEND,file,FileIO_Parm->GBits,out);
  78.        break;
  79.        
  80.        default : ErrorHandler(OUT_OF_RANGE,"Unknown block type in SaveFC");
  81.        break;
  82.       }
  83.     }
  84.    else
  85.    for(i=0;i<2;i++)
  86.    for(j=0;j<2;j++) SaveTrans(T->Sub[i][j],file,delta);
  87.    
  88.   }
  89.  
  90. /**************************************|****************************************
  91. Routine   : SaveFC
  92. Input  par: Transformation ***T (pointer to 2D array of Transformation pointers)
  93.             char *file          (filename)
  94.             LimboHeader TheHead (header structure with current header info)
  95. Output par: none
  96. Function  : Saves all transformation in T[][] to file. Saves FC-header + FC-Code
  97. ***************************************|***************************************/
  98.  
  99.  void SaveFC(Transformation ***T, char *file, LimboHeader *Head)
  100.   {
  101.    int i,j,x,y,delta,B,nsquare;
  102.    unsigned char out[]="dummy";
  103.    char savefile[99];
  104.    FILE *headfile;
  105.    
  106.    strcpy(savefile,FCCODE);
  107.    strcat(savefile,file);
  108.    strcat(savefile,".lmb");
  109.    
  110.    vprintf(stderr,"\nSaving fractal code...\n   File:'%s'",savefile);
  111.    
  112.    HeadInfo(T,Head);
  113.    
  114.    FileIO_Parm=GimmeAParameter();
  115.    FileIO_Parm->XBits=Head->XBits;
  116.    FileIO_Parm->YBits=Head->YBits;
  117.    FileIO_Parm->SBits=Head->SBits;
  118.    FileIO_Parm->ABits=Head->ABits;
  119.    FileIO_Parm->AMax =Head->AMax/100.0;
  120.    FileIO_Parm->AMin =Head->AMin/100.0;
  121.    FileIO_Parm->DBits=Head->DBits;
  122.    FileIO_Parm->GBits=Head->GBits;
  123.    FileIO_Parm->TBits=Head->TBits;
  124.    
  125.    x=Head->MSBx*256+Head->LSBx;
  126.    y=Head->MSBy*256+Head->LSBy;
  127.    delta=Head->Delta;
  128.    B=Head->B;
  129.    nsquare=Head->NSquare;
  130.    
  131.    if ((headfile=fopen(savefile,"wb")) == NULL) 
  132.    ErrorHandler(UNABLE_TO_OPEN,"SaveFC could not open file");
  133.    fprintf(headfile,"LIMBO:%s\n",LIMBOVERSION);
  134.    fwrite((void *)Head,sizeof(LimboHeader),1,headfile);
  135.    if (fclose(headfile)) ErrorHandler(UNABLE_TO_CLOSE,"SaveFC could not close file");
  136.    
  137.    IOBitArray(FILE_OPENAPPEND,savefile,0,out); /* open for FCCode */
  138.    for (i=0;i<x/(B<<nsquare);i++)  
  139.    for (j=0;j<y/(B<<nsquare);j++)
  140.    SaveTrans(T[i][j],savefile,delta);  /* save transformations */
  141.    
  142.    out[0]='X';
  143.    IOBitArray(FILE_APPEND,file,8,out); /* end */
  144.    IOBitArray(FILE_CLOSE,savefile,0,out);
  145.   }
  146.  
  147. /**************************************|****************************************
  148. Routine   : LoadTrans
  149. Input  par: char *file (filename)
  150.             int B      (B-blocksize)
  151.             int D      (D-blocksize)
  152.             int dx     (delta x)
  153.             int dy     (delta y)
  154. Output par: Transformation * (pointer to transformation loaded)
  155. Function  : Loads transformation from file. Loads main transformation plus 
  156.             recursive load of all sub-blocks.
  157. ***************************************|***************************************/
  158.  
  159.  Transformation *LoadTrans(char *file, int B, int D, int delta)
  160.   {
  161.    Transformation *T;
  162.    unsigned char in[99],sign,main=TRUE;
  163.    int type;
  164.    
  165.    T=GimmeATransformation();    /*dynamic allocation of tranformation */
  166.    T->Type=NOBLOCK;
  167.    T->D=D;
  168.    T->BlockSize=B;
  169.    T->Sub=NULL;
  170.    
  171.    if (FileIO_Parm->SBits) 
  172.     {
  173.      IOBitArray(FILE_READ,file,FileIO_Parm->SBits,in); /* parent/sub bit */
  174.      main=in[0]; /* remember subblock */ 
  175.     }
  176.    
  177.    if (main) /* read trans ? if this is a main */               
  178.     {
  179.      T->Domain=GimmeAPoolNode();
  180.      
  181.      IOBitArray(FILE_READ,file,1,in);
  182.      if (in[0]==0x00)      type=EDGEBLOCK;
  183.      else if (in[0]==0x01) type=SHADEBLOCK;
  184.      else ErrorHandler(OUT_OF_RANGE,"Unknown block type in LoadFC");
  185.      
  186.      switch(type)
  187.       {
  188.        case EDGEBLOCK :
  189.        T->Type=EDGEBLOCK;
  190.        T->D=D;
  191.        T->BlockSize=B;
  192.        IOBitArray(FILE_READ,file,FileIO_Parm->XBits,in);
  193.        T->Domain->x=in[0]*delta;
  194.        IOBitArray(FILE_READ,file,FileIO_Parm->YBits,in);
  195.        T->Domain->y=in[0]*delta;
  196.        IOBitArray(FILE_READ,file,FileIO_Parm->ABits,in);
  197.        T->Alpha=MakeFloat(in[0],FileIO_Parm);
  198. /*
  199.        IOBitArray(FILE_READ,file,1,in);
  200.        sign=in[0];
  201.        IOBitArray(FILE_READ,file,FileIO_Parm->ABits,in);
  202.        if (sign==0) T->Alpha=MakeFloat(in[0],FileIO_Parm);
  203.        else T->Alpha = -MakeFloat(in[0],FileIO_Parm);
  204. */
  205.        IOBitArray(FILE_READ,file,1,in);
  206.        sign=in[0];
  207.        IOBitArray(FILE_READ,file,FileIO_Parm->DBits,in);
  208.        if (sign==0) T->Deltag= in[0];
  209.        else T->Deltag = -in[0];
  210.        
  211.        IOBitArray(FILE_READ,file,FileIO_Parm->TBits,in);
  212.        T->tn=in[0];
  213.        break;
  214.        
  215.        case SHADEBLOCK :
  216.        T->Type=SHADEBLOCK;
  217.        T->D=D;
  218.        T->BlockSize=B;
  219.        IOBitArray(FILE_READ,file,FileIO_Parm->GBits,in);
  220.        T->g0=(int)in[0];
  221.        break;
  222.        
  223.        default : ErrorHandler(OUT_OF_RANGE,"Unknown block type in LoadFC");
  224.        break;
  225.       }
  226.     }
  227.    else /* load subblock configuration */
  228.     {
  229.      int i,j;
  230.      T->Sub=GimmeATransArray(2,2);
  231.      
  232.      for(i=0;i<2;i++) 
  233.      for(j=0;j<2;j++) T->Sub[i][j]=LoadTrans(file,B>>1,D>>1,delta);
  234.     }
  235.    
  236.    return T;
  237.   }
  238.  
  239. /**************************************|****************************************
  240. Routine   : LoadFC
  241. Input  par: Transformation ***T (pointer to 2D array of Transformation pointers,
  242.                                  will be filled with the loaded transformations)
  243.             char *file          (filename)
  244.             int infoflag        (fractal code info for file flag. 1=info 0=noinfo)
  245. Output par: LimboHeader Head (header structure with new file info)
  246. Function  : Reads FC-code from file. Read FC Header. Allocates transformations.
  247.             Reads p/c configuration plus fractal code. Stores code in allocated
  248.             transformations. Returns header structure with file info.
  249. ****************************************|***************************************/
  250.  
  251.  LimboHeader *LoadFC(Transformation ****T, char *file)
  252.   {
  253.    FILE *infile;
  254.    int i,j,x,y,delta,size,B,nsquare;
  255.    unsigned char in[99],limbo[20];
  256.    char loadfile[99];
  257.    LimboHeader *Head=GimmeALimboHeader();
  258.    
  259.    strcpy(loadfile,FCCODE);
  260.    strcat(loadfile,file);
  261.    strcat(loadfile,".lmb");
  262.    
  263.    vprintf(stderr,"\nLoading fractal code...\n   File:'%s'",loadfile);
  264.    
  265.    if ((infile=fopen(loadfile,"rb")) == NULL)
  266.    ErrorHandler(UNABLE_TO_OPEN,"LoadFC could not open file");
  267.    fgets(limbo,LIMBOSTRINGSIZE,infile);             /* read version */
  268.    
  269.    if ((strncmp(limbo,"LIMBO:",5))) 
  270.     {
  271.      char msg[40];
  272.      strcpy(msg,"Could not read file ");
  273.      strcat(msg,loadfile);
  274.      ErrorHandler(UNKNOWN_FORMAT,msg);
  275.     }
  276.    vprintf(stderr,"\n   Version: %s",limbo);
  277.    fread(Head,sizeof(LimboHeader),1,infile);    /* read header */
  278.    
  279.    size=Head->HeadSize;
  280.    
  281.    FileIO_Parm=GimmeAParameter();
  282.    FileIO_Parm->XBits=Head->XBits;
  283.    FileIO_Parm->YBits=Head->YBits;
  284.    FileIO_Parm->SBits=Head->SBits;
  285.    FileIO_Parm->ABits=Head->ABits;
  286.    FileIO_Parm->AMax =Head->AMax/100.0;
  287.    FileIO_Parm->AMin =Head->AMin/100.0;
  288.    FileIO_Parm->DBits=Head->DBits;
  289.    FileIO_Parm->GBits=Head->GBits;
  290.    FileIO_Parm->TBits=Head->TBits;
  291.    
  292.    x=Head->MSBx*256+Head->LSBx;
  293.    y=Head->MSBy*256+Head->LSBy;
  294.    delta=Head->Delta;
  295.    B=Head->B;
  296.    nsquare=Head->NSquare;
  297.    *T=GimmeATransArray(x/(B<<nsquare),y/(B<<nsquare));
  298.    
  299.    IOBitArray(FILE_OPENREAD,loadfile,0,in);
  300.    IOBitArray(FILE_READ,loadfile,size*8-8,in);  /* skip header */
  301.    
  302.    for (i=0;i<x/(B<<nsquare);i++)
  303.    for (j=0;j<y/(B<<nsquare);j++)
  304.    (*T)[i][j]=LoadTrans(loadfile,B<<nsquare,B<<(nsquare+1),delta);
  305.    
  306.    IOBitArray(FILE_READ,file,8,in); /* end */
  307.    if (in[0]!='X') ErrorHandler(ERROR_READING,"LoadFC could not find tail in FCfile");
  308.    IOBitArray(FILE_CLOSE,loadfile,0,in);
  309.    
  310.    return Head;
  311.   }
  312.