home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 March / VPR9703A.ISO / VPR_DATA / DOGA / SOURCES / POLYEDIT.LZH / MODEL / POLY.C < prev    next >
C/C++ Source or Header  |  1996-07-25  |  8KB  |  345 lines
  1. /*
  2.  *        ポリゴンデータ管理ライブラリ
  3.  *
  4.  *        Copyright    T.Kobayashi        1993.9.5
  5.  */
  6.  
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #include <assert.h>
  11. #include <math.h>
  12.  
  13. #include "lib.h"
  14. #include "alloc.h"
  15. #include "buffer.h"
  16. #include "poly.h"
  17. #include "view.h"
  18.  
  19. Polygon    *CurrentPoly ;
  20. int        MaxAttr ;
  21. int        MaxVertex ;
  22. Polygon    *PolyPtr ;
  23.  
  24. /*    初期化    */
  25. void    PolyInit( bufsize, maxobj, maxatr, maxver )
  26. int        bufsize ;
  27. int        maxobj ;
  28. int        maxatr ;
  29. int        maxver ;
  30. {
  31.     BufferInit( bufsize );
  32.     AttrInit( maxatr );
  33.     ObjInit( maxobj );
  34.  
  35.     CurrentPoly = MemoryAlloc( PolySize( maxver ) );
  36.     MaxVertex = maxver ;
  37.  
  38.     CurrentPoly->select = OFF ;
  39.     CurrentPoly->type = POLY_SIMPLE ;
  40.     CurrentPoly->atr = 0 ;
  41.     CurrentPoly->obj = 0 ;
  42.     CurrentPoly->vers = 0 ;
  43.     CurrentPoly->mode = 0 ;
  44.     CurrentPoly->vec[0] = CurrentPoly->vec[1] = CurrentPoly->vec[2] = 0;
  45. }
  46.  
  47. /*    終了処理    */
  48. void    PolyExit()
  49. {
  50.     BufferExit();
  51.     AttrExit();
  52.     MemoryFree( CurrentPoly );
  53. }
  54.  
  55. /*    ポリゴンバッファサイズを得る    */
  56. int        PolySize( vers )
  57. int        vers ;
  58. {
  59.     assert( 0 < vers && vers < 1024 );
  60.     return sizeof( Polygon ) + sizeof( Vertex ) * (vers-1) ;
  61. }
  62.  
  63. /*    ポリゴンの数を得る    */
  64. int        Polygons()
  65. {
  66.     int        n ;
  67.     Polygon    *poly ;
  68.  
  69.     n = 0 ;
  70.     poly = PolyTop();
  71.     while( poly != NULL )
  72.     {
  73.         n ++ ;
  74.         poly = PolyNext( poly );
  75.     }
  76.     return n ;
  77. }
  78.  
  79. /*    ポリゴンの登録    */
  80. void    PolyAppend()
  81. {
  82.     Polygon    *dst ;
  83.     int coe[3];
  84.  
  85.     dst = BufferAppend( PolySize( CurrentPoly->vers ) );
  86.  
  87.     dst->select = CurrentPoly->select ;
  88.     if (dst->select) {
  89.         Selects++;
  90.     }
  91.     Coefficent(coe, CurrentPoly->ver, CurrentPoly->vers);
  92.     dst->vec[0] = CurrentPoly->vec[0] = coe[0];
  93.     dst->vec[1] = CurrentPoly->vec[1] = coe[1];
  94.     dst->vec[2] = CurrentPoly->vec[2] = coe[2];
  95.     dst->type = CurrentPoly->type ;
  96.     dst->atr = CurrentPoly->atr ;
  97.     dst->obj = CurrentPoly->obj ;
  98.     dst->vers = CurrentPoly->vers ;
  99.     dst->mode = CurrentPoly->mode ;
  100.     memcpy( dst->ver, CurrentPoly->ver, sizeof( Vertex ) * CurrentPoly->vers );
  101.     ObjData[CurrentPoly->obj].edit = TRUE ;
  102. }
  103.  
  104. /*    選択されているポリゴンを一時バッファに取り込む    */
  105. void    *PolyLoad()
  106. {
  107.     if ( PolyPtr == NULL )
  108.         PolyPtr = (Polygon*)BufferTop();
  109.     else
  110.         PolyPtr = (Polygon*)BufferNext( PolyPtr );
  111.  
  112.     /* By Taka2 */
  113.     if ( PolyPtr == NULL )
  114.         return NULL ;
  115.  
  116.     while( PolyPtr->select == OFF )
  117.     {
  118.         PolyPtr = (Polygon*)BufferNext( PolyPtr );
  119.         if ( PolyPtr == NULL )
  120.             return NULL ;
  121.     }
  122.  
  123.     BufferCopy( CurrentPoly, PolyPtr, PolySize( PolyPtr->vers ) );
  124.     return PolyPtr ;
  125. }
  126.  
  127. void    *PolyLoadPtr(void *p)
  128. {
  129.     Polygon *poly = p;
  130.     if (poly == NULL) {
  131.         return NULL;
  132.     }
  133.     PolyPtr = poly;
  134.     BufferCopy( CurrentPoly, PolyPtr, PolySize( PolyPtr->vers ) );
  135.     return PolyPtr ;
  136. }
  137.  
  138. /*    一時バッファからポリゴンを書き戻す    */
  139. void    PolySave()
  140. {
  141.     int i;
  142.     int coe[3];
  143.     if (PolyPtr != NULL) {
  144.         BufferResize( (DataBuffer*)PolyPtr, PolySize( CurrentPoly->vers ) );
  145.  
  146.         BufferCopy( PolyPtr, CurrentPoly, PolySize( CurrentPoly->vers ) );
  147.  
  148.         for (i = 0; i < CurrentPoly->vers; i++) {
  149.             if ((PolyPtr->type & POLY_SHADE) == 0) {
  150.                 PolyPtr->ver[i].vx = 0;
  151.                 PolyPtr->ver[i].vy = 0;
  152.                 PolyPtr->ver[i].vz = 0;
  153.             }
  154.             if ((PolyPtr->type & POLY_UV) == 0) {
  155.                 PolyPtr->ver[i].u = 0;
  156.                 PolyPtr->ver[i].v = 0;
  157.             }
  158.         }
  159.         Coefficent(coe, PolyPtr->ver, PolyPtr->vers);
  160.         CurrentPoly->vec[0] = PolyPtr->vec[0] = coe[0];
  161.         CurrentPoly->vec[1] = PolyPtr->vec[1] = coe[1];
  162.         CurrentPoly->vec[2] = PolyPtr->vec[2] = coe[2];
  163.         ObjData[CurrentPoly->obj].edit = TRUE ;
  164.     }
  165. }
  166.  
  167. /*    セレクトされているポリゴン削除する    */
  168. void    PolyDelete()
  169. {
  170.     Polygon    *poly, *next ;
  171.  
  172.     poly = PolyTop();
  173.     while( poly != NULL )
  174.     {
  175.         next = PolyNext( poly );
  176.         if ( poly->select == ON )
  177.         {
  178.             ObjData[poly->obj].edit = TRUE ;
  179.             BufferDelete( poly );
  180.         }
  181.         poly = next ;
  182.     }
  183.     BufferDeleteCorrect();
  184. /*    ObjValid();*/
  185.     Selects = 0 ;
  186. }
  187.  
  188. /*    セレクトされているポリゴンを移動する    */
  189. void    PolyMove( mat )
  190. Matrix    mat ;
  191. {
  192.     int        i, x, y, z ;
  193.     Polygon    *poly ;
  194.     Vertex    *ver ;
  195.     int        imat[5][3], imatit[5][3] ;
  196.     float    r;
  197.  
  198.     Matrix    matit;
  199.     MatCopy(matit, mat);
  200.     MatInv(matit);
  201.     MatTra(matit);
  202.  
  203.     MatToInt( imat, mat );
  204.     MatToInt( imatit, matit );
  205.  
  206.     poly = PolyTop();
  207.     while( poly != NULL )
  208.     {
  209.         if ( poly->select == ON )
  210.         {
  211.             ver = poly->ver ;
  212.             for( i = poly->vers ; i > 0 ; i-- )
  213.             {
  214.                 x = (int)ver->x * imat[0][0]
  215.                   + (int)ver->y * imat[1][0]
  216.                   + (int)ver->z * imat[2][0]
  217.                   + imat[4][0] ;
  218.                 y = (int)ver->x * imat[0][1]
  219.                   + (int)ver->y * imat[1][1]
  220.                   + (int)ver->z * imat[2][1]
  221.                   + imat[4][1] ;
  222.                 z = (int)ver->x * imat[0][2]
  223.                   + (int)ver->y * imat[1][2]
  224.                   + (int)ver->z * imat[2][2]
  225.                   + imat[4][2] ;
  226. #if 0
  227.                 if (x > 0) {
  228.                     ver->x = imat[3][0] + (short)( ( x + 32767) >> 16 );
  229.                 } else {
  230.                     ver->x = imat[3][0] - (short)( (-x + 32767) >> 16 );
  231.                 }
  232.                 if (y > 0) {
  233.                     ver->y = imat[3][1] + (short)( ( y + 32767) >> 16 );
  234.                 } else {
  235.                     ver->y = imat[3][1] - (short)( (-y + 32767) >> 16 );
  236.                 }
  237.                 if (z > 0) {
  238.                     ver->z = imat[3][2] + (short)( ( z + 32767) >> 16 );
  239.                 } else {
  240.                     ver->z = imat[3][2] - (short)( (-z + 32767) >> 16 );
  241.                 }
  242. #else
  243.                 ver->x = (short)imat[3][0] + (short)( x >> 16 );
  244.                 ver->y = (short)imat[3][1] + (short)( y >> 16 );
  245.                 ver->z = (short)imat[3][2] + (short)( z >> 16 );
  246. #endif
  247.                 x = (int)ver->vx * imatit[0][0]
  248.                   + (int)ver->vy * imatit[1][0]
  249.                   + (int)ver->vz * imatit[2][0];
  250.                 y = (int)ver->vx * imatit[0][1]
  251.                   + (int)ver->vy * imatit[1][1]
  252.                   + (int)ver->vz * imatit[2][1];
  253.                 z = (int)ver->vx * imatit[0][2]
  254.                   + (int)ver->vy * imatit[1][2]
  255.                   + (int)ver->vz * imatit[2][2];
  256.                 r = sqrt((float)x * (float)x + (float)y * (float)y + (float)z * (float)z);
  257.                 if (r > 0.0) r = 256.0 / r;
  258.                 ver->vx = (short)(r * (float)x);
  259.                 ver->vy = (short)(r * (float)y);
  260.                 ver->vz = (short)(r * (float)z);
  261. /*
  262.                 ver->vx = (short)( x >> 16 );
  263.                 ver->vy = (short)( y >> 16 );
  264.                 ver->vz = (short)( z >> 16 );
  265. */
  266.                 ver ++ ;
  267.             }
  268.             ObjData[poly->obj].edit = TRUE ;
  269.  
  270.             x = (int)poly->vec[0] * imatit[0][0]
  271.               + (int)poly->vec[1] * imatit[1][0]
  272.               + (int)poly->vec[2] * imatit[2][0];
  273.             y = (int)poly->vec[0] * imatit[0][1]
  274.               + (int)poly->vec[1] * imatit[1][1]
  275.               + (int)poly->vec[2] * imatit[2][1];
  276.             z = (int)poly->vec[0] * imatit[0][2]
  277.               + (int)poly->vec[1] * imatit[1][2]
  278.               + (int)poly->vec[2] * imatit[2][2];
  279.             r = sqrt((float)x * (float)x + (float)y * (float)y + (float)z * (float)z);
  280.             if (r > 0.0) r = 256.0 / r;
  281. /*            r = 256.0 / sqrt( x * x + y * y + z * z );*/
  282.             poly->vec[0] = (short)(r * (float)x);
  283.             poly->vec[1] = (short)(r * (float)y);
  284.             poly->vec[2] = (short)(r * (float)z);
  285.         }
  286.         poly = PolyNext( poly );
  287.     }
  288. }
  289.  
  290. /*    セレクトされていないポリゴンを不可視属性にする    */
  291. void    PolyInvisible( flag )
  292. int        flag ;
  293. {
  294.     Polygon    *poly ;
  295.  
  296.     poly = PolyTop();
  297.     while( poly != NULL )
  298.     {
  299.         if ( flag )
  300.         {
  301.             if ( poly->select == OFF )
  302.                 poly->mode |= MODE_INVISIBLE ;
  303.         }
  304.         else
  305.             poly->mode &= ~ MODE_INVISIBLE ;
  306.         poly = PolyNext( poly );
  307.     }
  308. }
  309.  
  310. void    PolyShiftVertex( int begin )
  311. {
  312.     int src, dst;
  313.     Vertex *oldver;
  314.     oldver = MemoryAlloc(sizeof(Vertex) * CurrentPoly->vers);
  315.     memcpy(oldver, CurrentPoly->ver, sizeof(Vertex) * CurrentPoly->vers);
  316.     src = begin;
  317.     for (dst = 0; dst < CurrentPoly->vers; dst++) {
  318.         CurrentPoly->ver[dst] = oldver[src];
  319.         if (++src >= CurrentPoly->vers) {
  320.             src = 0;
  321.         }
  322.     }
  323.     MemoryFree(oldver);
  324. }
  325.  
  326. void    PolyInvVertex( void )
  327. {
  328.     int begin, end;
  329.     Vertex v;
  330.     begin = 0;
  331.     end = CurrentPoly->vers-1;
  332.     while (begin < end) {
  333.         v = CurrentPoly->ver[begin];
  334.         CurrentPoly->ver[begin] = CurrentPoly->ver[end];
  335.         CurrentPoly->ver[end] = v;
  336.         begin++;
  337.         end--;
  338.     }
  339.     /*
  340.         法線の向きも逆にするかどうかは未定。
  341.         逆にするときはframe.cでの処理は無くすこと。
  342.     */
  343.  
  344. }
  345.