home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 March / VPR9703A.ISO / VPR_DATA / DOGA / SOURCES / POLYEDIT.LZH / MODEL / ATR.C < prev    next >
C/C++ Source or Header  |  1996-03-18  |  8KB  |  354 lines
  1. /*
  2.  *        アトリビュート制御
  3.  *
  4.  *        1994.6.18
  5.  */
  6.  
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <assert.h>
  10. #include <string.h>
  11.  
  12. #include "lib.h"
  13. #include "alloc.h"
  14. #include "poly.h"
  15.  
  16. #include "color.h"
  17. #include "reader.h"
  18.  
  19. Attrbute    *AttrData ;
  20. int            AttrCurrent ;
  21. int            AttrSize ;
  22. int            AttrLast ;
  23.  
  24. /*
  25.  *    アトリビュートデータの初期化
  26.  */
  27. void    AttrInit( size )
  28. int        size ;
  29. {
  30.     int        i ;
  31.  
  32.     AttrData = MemoryAlloc( size * sizeof( Attrbute ) );
  33.     AttrSize = size ;
  34.     AttrLast = 0 ;
  35.     AttrCurrent = 0 ;
  36.  
  37.     for( i = 0 ; i < size ; i++ )
  38.         AttrData[i].flag = FALSE ;
  39.  
  40. /*    i = AttrAppend( "no" );*/
  41. }
  42.  
  43. void    AttrExit()
  44. {
  45.     MemoryFree( AttrData );
  46. }
  47.  
  48. static void AttrClear( int pos )
  49. {
  50.     int i, j;
  51.     AttrData[pos].code = 7;
  52.     AttrData[pos].col.r = AttrData[pos].col.g = AttrData[pos].col.b = COLOR_UNIT ;
  53.     AttrData[pos].amb.r = AttrData[pos].amb.g = AttrData[pos].amb.b = COLOR_UNIT/2 ;
  54.     AttrData[pos].dif = AttrData[pos].amb;
  55.     AttrData[pos].spc.r = AttrData[pos].spc.g = AttrData[pos].spc.b = 0;
  56.     AttrData[pos].size = AttrData[pos].ref = AttrData[pos].tra =
  57.     AttrData[pos].rfr = AttrData[pos].att = AttrData[pos].spc;
  58.     AttrData[pos].h = 0;
  59.     AttrData[pos].maptype = MAP_NO;
  60.     for (i = 0; i < 2; i++) {
  61.         for (j = 0; j < 2; j++) {
  62.             AttrData[pos].mapsize[i][j] = 0;
  63.             AttrData[pos].mapview[i][j] = 0;
  64.             AttrData[pos].mapwind[i][j] = 0;
  65.         }
  66.     }
  67. }
  68.  
  69. /*
  70.  *    アトリビュートの追加
  71.  */
  72. int        AttrAppend( name )
  73. char    *name ;
  74. {
  75.     int        i ;
  76.  
  77.     for( i = 0 ; i < AttrSize ; i++ )
  78.     {
  79.         if ( AttrData[i].flag == FALSE )
  80.         {
  81.             AttrData[i].flag = TRUE ;
  82.             strncpy( AttrData[i].name, name, ATTR_NAME_LEN );
  83.             AttrData[i].name[ATTR_NAME_LEN] = '\0' ;
  84.             AttrData[i].fname[0] = '\0' ;
  85.             AttrClear(i);
  86. #if 0
  87.             AttrData[i].r = COLOR_UNIT ;
  88.             AttrData[i].g = COLOR_UNIT ;
  89.             AttrData[i].b = COLOR_UNIT ;
  90.             AttrData[i].code = 7 ;
  91. #endif
  92.             if ( AttrLast < i )
  93.                 AttrLast = i ;
  94.             return i ;
  95.         }
  96.     }
  97.     MessageError( "アトリビュートバッファがオーバーフローしました" );
  98.     return -1 ;
  99. }
  100.  
  101. /*
  102.  *    アトリビュートの検索
  103.  */
  104. int        AttrSearch( name )
  105. char    *name ;
  106. {
  107.     int        i ;
  108.  
  109.     for( i = 0 ; i <= AttrLast ; i++ )
  110.     {
  111.         if ( AttrData[i].flag && strncmp( AttrData[i].name, name, ATTR_NAME_LEN ) == 0 )
  112.             return i ;
  113.     }
  114.     return -1 ;
  115. }
  116.  
  117. /*
  118.  *    検索＆追加
  119.  */
  120. int        AttrSearchOrAppend( name )
  121. char    *name ;
  122. {
  123.     int        n ;
  124.  
  125.     n = AttrSearch( name );
  126.     if ( n == -1 )
  127.         return AttrAppend( name );
  128.     else
  129.         return n ;
  130. }
  131.  
  132. /*
  133.  *    セレクトされているアトリビュートを変更する
  134.  */
  135. void    AttrChange( atrno )
  136. int        atrno ;
  137. {
  138.     Polygon    *poly ;
  139.  
  140.     assert( atrno <= AttrLast );
  141.  
  142.     poly = PolyTop();
  143.     while( poly != NULL )
  144.     {
  145.         if ( poly->select )
  146.         {
  147.             ObjData[poly->obj].edit = TRUE ;
  148.             poly->atr = atrno ;
  149.         }
  150.         poly = PolyNext( poly );
  151.     }
  152. }
  153.  
  154. /*
  155.  *    ファイル入力
  156.  */
  157. int        AttrReadFile(char *file, int mode)
  158. {
  159.     int        atrno, code ;
  160.     char    name[64] ;
  161. #if 0
  162.     Color    col, amb, dif, spc, size ;
  163. #endif
  164.     int        h ;
  165.     Color col[9];
  166.  
  167.  
  168.     if (AtrReadOpen( file ) == FALSE) {
  169.         return FALSE;
  170.     }
  171.  
  172.     while( AtrReadNext() && !ReaderError() )
  173.     {
  174.         AtrReadName( name );
  175.         if (mode != FILE_APPEND) {
  176.             atrno = AttrAppend( name );
  177.         } else {
  178.             atrno = AttrSearchOrAppend( name );
  179.         }
  180. #if 0
  181.         AtrReadColor( &col, &amb, &dif, &spc, &size, &h );
  182.         AttrData[atrno].r = col.r ;
  183.         AttrData[atrno].g = col.g ;
  184.         AttrData[atrno].b = col.b ;
  185. #else
  186.         strcpy(AttrData[atrno].fname, file);
  187. /*    col, amb, dif, spc, size, ref, tra, rfr, att */
  188.         AtrReadColorAll(col, &h);
  189.         AttrData[atrno].col = col[0];
  190.         AttrData[atrno].amb = col[1];
  191.         AttrData[atrno].dif = col[2];
  192.         AttrData[atrno].spc = col[3];
  193.         AttrData[atrno].size = col[4];
  194.         AttrData[atrno].ref = col[5];
  195.         AttrData[atrno].tra = col[6];
  196.         AttrData[atrno].rfr = col[7];
  197.         AttrData[atrno].att = col[8];
  198.         AttrData[atrno].h = h;
  199.  
  200.         AttrData[atrno].maptype = AtrReadColorMap(
  201.             AttrData[atrno].colorfile,
  202.             AttrData[atrno].mapsize,
  203.             AttrData[atrno].mapwind,
  204.             AttrData[atrno].mapview);
  205.  
  206. #endif
  207.         code = 0 ;
  208.         if ( AttrData[atrno].col.r > COLOR_UNIT * 3 / 5 )
  209.             code |= 2 ;
  210.         if ( AttrData[atrno].col.g > COLOR_UNIT * 3 / 5 )
  211.             code |= 4 ;
  212.         if ( AttrData[atrno].col.b > COLOR_UNIT * 3 / 5 )
  213.             code |= 1 ;
  214.         AttrData[atrno].code = code ;
  215.  
  216.  
  217.     }
  218.     AtrReadClose();
  219.     if (ReaderError()) {
  220.         return FALSE;
  221.     }
  222.     return TRUE ;
  223. }
  224.  
  225. int    AttrDelete( int atrno )
  226. {
  227.     int i;
  228.     Polygon    *poly ;
  229.  
  230.     poly = PolyTop();
  231.     while( poly != NULL )
  232.     {
  233.         if ( poly->atr == atrno ) {
  234.             return FALSE;
  235.         }
  236.         poly = PolyNext( poly );
  237.     }
  238.     poly = PolyTop();
  239.     while( poly != NULL )
  240.     {
  241.         if ( poly->atr > atrno ) {
  242.             poly->atr--;
  243.         }
  244.         poly = PolyNext( poly );
  245.     }
  246.     for (i = atrno; i < AttrLast; ++i) {
  247.         AttrData[i] = AttrData[i+1];
  248.     }
  249.     AttrData[AttrLast].flag = FALSE;
  250.     AttrLast--;
  251.     if (AttrLast >= 0 && AttrCurrent > AttrLast) {
  252.         AttrCurrent = AttrLast;
  253.     }
  254.     return TRUE;
  255. }
  256.  
  257. static void AttrWriteColor( FILE *fp, Color *col)
  258. {
  259.     if (col->r == col->g && col->r == col->b) {
  260.         fprintf( fp, "%4.2lf", (double)col->r / (double)(1<<COLOR_SHIFT));
  261.     } else {
  262.         fprintf( fp, "rgb ( %4.2lf %4.2lf %4.2lf )",
  263.                 (double)col->r / (double)(1<<COLOR_SHIFT),
  264.                 (double)col->g / (double)(1<<COLOR_SHIFT),
  265.                 (double)col->b / (double)(1<<COLOR_SHIFT));
  266.     }
  267. }
  268.  
  269. static void AttrWriteParameter( FILE *fp, char *name, Color *col)
  270. {
  271.     if (col->r != 0 || col->g != 0 || col->b != 0) {
  272.         if (col->r == col->g && col->r == col->b) {
  273.             fprintf( fp, "\t%s ( %4.2lf )\n", name, (double)col->r / (double)(1<<COLOR_SHIFT));
  274.         } else {
  275.             fprintf( fp, "\t%s ( rgb ( %4.2lf %4.2lf %4.2lf ) )\n",
  276.                     name,
  277.                     (double)col->r / (double)(1<<COLOR_SHIFT),
  278.                     (double)col->g / (double)(1<<COLOR_SHIFT),
  279.                     (double)col->b / (double)(1<<COLOR_SHIFT));
  280.         }
  281.     }
  282. }
  283.  
  284. static void AttrWriteMap( FILE *fp, char *name, int map[2][2])
  285. {
  286.     int i, j;
  287.     fprintf(fp, "\t%s ( ", name);
  288.     for( i = 0 ; i < 2 ; ++i )
  289.     {
  290.         for( j = 0 ; j < 2 ; ++j )
  291.         {
  292.             if ((map[i][j] & 65535) == 0) {
  293.                 fprintf(fp, "%d ", map[i][j] >> 16);
  294.             } else {
  295.                 fprintf(fp, "%8.4lf ", (double)map[i][j] / 65536.0);
  296.             }
  297.         }
  298.     }
  299.     fprintf(fp, ")\n");
  300. }
  301.  
  302.  
  303. /*    ファイルに書き込む    */
  304. int        AttrWriteFile( char *file, int atrno, int mode )
  305. {
  306.     FILE    *fp ;
  307.     int        i;
  308.  
  309.     assert( 0 <= atrno && atrno <= AttrLast );
  310.  
  311.     if ( AttrData[atrno].flag == FALSE )
  312.         return FALSE ;
  313.  
  314.     if ( mode == FILE_APPEND )
  315.         fp = fopen( file, "a" );
  316.     else
  317.         fp = fopen( file, "w" );
  318.  
  319.     if ( fp == NULL )
  320.     {
  321.         MessageWarning( "ファイルがオープンできません" );
  322.         return FALSE ;
  323.     }
  324.  
  325.     fprintf( fp, "atr %s {\n", AttrData[atrno].name );
  326.     fprintf( fp, "\tcol ( ");     AttrWriteColor( fp, &AttrData[atrno].col );
  327.     fprintf( fp, " )\n\ttra ( "); AttrWriteColor( fp, &AttrData[atrno].tra );
  328.     fprintf( fp, " )\n\tamb ( "); AttrWriteColor( fp, &AttrData[atrno].amb );
  329.     fprintf( fp, " )\n\tdif ( "); AttrWriteColor( fp, &AttrData[atrno].dif );
  330.     fprintf( fp, " )\n\tspc ( "); AttrWriteColor( fp, &AttrData[atrno].spc );
  331.     fprintf( fp, " ");              AttrWriteColor( fp, &AttrData[atrno].size );
  332.     fprintf( fp, " %4.2lf )\n", (double)AttrData[atrno].h / (double)(1<<COLOR_SHIFT));
  333.  
  334.     AttrWriteParameter( fp, "ref", &AttrData[atrno].ref );
  335.     AttrWriteParameter( fp, "rfr", &AttrData[atrno].rfr );
  336.     AttrWriteParameter( fp, "att", &AttrData[atrno].att );
  337.  
  338.     if (AttrData[atrno].maptype == MAP_COLOR && AttrData[atrno].colorfile[0]) {
  339.         fprintf(fp, "\tcolormap ( %s )\n", AttrData[atrno].colorfile);
  340.         AttrWriteMap( fp, "mapsize", AttrData[atrno].mapsize);
  341.         AttrWriteMap( fp, "mapview", AttrData[atrno].mapview);
  342.         AttrWriteMap( fp, "mapwind", AttrData[atrno].mapwind);
  343.     }
  344.  
  345.     fprintf( fp, "}\n");
  346.     if (ferror(fp)) {
  347.         return FALSE;
  348.     }
  349.     fclose( fp );
  350.  
  351.     return TRUE ;
  352. }
  353.  
  354.