home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 March / VPR9703A.ISO / VPR_DATA / DOGA / SOURCES / POLYEDIT.LZH / MODEL / SEARCH.C < prev    next >
C/C++ Source or Header  |  1996-04-25  |  5KB  |  195 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.  
  12. #include "lib.h"
  13. #include "alloc.h"
  14. #include "buffer.h"
  15. #include "poly.h"
  16. #include "view.h"
  17.  
  18. /*    最近頂点を検索    */
  19. Vertex    *PolyVertex( pos, view )
  20. Vertex    *pos ;
  21. int view ;
  22. {
  23.     int        i, vers ;
  24.     int        x, y, z ;
  25.     Polygon    *poly ;
  26.     Vertex    *ret ;
  27.     unsigned int    min, len ;
  28.     int    min2, len2;
  29.     int scr[2];
  30.     int px, py;
  31.  
  32.     x = pos->x ;
  33.     y = pos->y ;
  34.     z = pos->z ;
  35.     ToScreenPers(scr, pos);
  36.     px = scr[0];
  37.     py = scr[1];
  38.     min = 32767 * 32767 ;
  39.     min2 = 32767;
  40.     poly = PolyTop();
  41.     ret = NULL ;
  42.  
  43.     while( poly != NULL )
  44.     {
  45.         if ( ( poly->mode & MODE_INVISIBLE ) == 0 )
  46.         {
  47.             vers = poly->vers ;
  48.             switch (view) {
  49.             case VIEW_XY:
  50.                 for( i = 0 ; i < vers ; i++ )
  51.                 {
  52.                     len =     ( poly->ver[i].x - x ) * ( poly->ver[i].x - x ) +
  53.                             ( poly->ver[i].y - y ) * ( poly->ver[i].y - y );
  54.                     len2 =  ( poly->ver[i].z - z ); if (len2 < 0) len2 = - len2;
  55.                     if ( len < min  || len == min && len2 < min2)
  56.                     {
  57.                         min = len ;
  58.                         min2 = len2;
  59.                         ret = &( poly->ver[i] );
  60.                     }
  61.                 }
  62.                 break;
  63.             case VIEW_YZ:
  64.                 for( i = 0 ; i < vers ; i++ )
  65.                 {
  66.                     len =     ( poly->ver[i].y - y ) * ( poly->ver[i].y - y ) +
  67.                             ( poly->ver[i].z - z ) * ( poly->ver[i].z - z ) ;
  68.                     len2 =  ( poly->ver[i].x - x ); if (len2 < 0) len2 = - len2;
  69.                     if ( len < min  || len == min && len2 < min2)
  70.                     {
  71.                         min = len ;
  72.                         min2 = len2;
  73.                         ret = &( poly->ver[i] );
  74.                     }
  75.                 }
  76.                 break;
  77.             case VIEW_ZX:
  78.                 for( i = 0 ; i < vers ; i++ )
  79.                 {
  80.                     len =     ( poly->ver[i].x - x ) * ( poly->ver[i].x - x ) +
  81.                             ( poly->ver[i].z - z ) * ( poly->ver[i].z - z ) ;
  82.                     len2 =  ( poly->ver[i].y - y ); if (len2 < 0) len2 = - len2;
  83.                     if ( len < min  || len == min && len2 < min2)
  84.                     {
  85.                         min = len ;
  86.                         min2 = len2;
  87.                         ret = &( poly->ver[i] );
  88.                     }
  89.                 }
  90.                 break;
  91.             case VIEW_PERS:
  92.                 if (!DrawFrontOnlyFlag || ScreenFront(poly->vec)) {
  93.                     for (i = 0; i < vers; i++) {
  94.                         ToScreenPers(scr, &poly->ver[i]);
  95.                         len = (scr[0]-px) * (scr[0]-px) + (scr[1]-py)*(scr[1]-py);
  96.                         len2 =     ( poly->ver[i].x - x ) * ( poly->ver[i].x - x ) +
  97.                                 ( poly->ver[i].y - y ) * ( poly->ver[i].y - y ) +
  98.                                 ( poly->ver[i].z - z ) * ( poly->ver[i].z - z ) ;
  99.                         if ( len < min || len == min && len2 < min2) {
  100.                             min = len;
  101.                             min2 = len2;
  102.                             ret = &(poly->ver[i]);
  103.                         }
  104.                     }
  105.                 }
  106.             default:
  107.                 for( i = 0 ; i < vers ; i++ )
  108.                 {
  109.                     len =     ( poly->ver[i].x - x ) * ( poly->ver[i].x - x ) +
  110.                             ( poly->ver[i].y - y ) * ( poly->ver[i].y - y ) +
  111.                             ( poly->ver[i].z - z ) * ( poly->ver[i].z - z ) ;
  112.                     if ( len < min )
  113.                     {
  114.                         min = len ;
  115.                         ret = &( poly->ver[i] );
  116.                     }
  117.                 }
  118.             }
  119.         }
  120.         poly = PolyNext( poly );
  121.     }
  122.     return ret ;
  123. }
  124.  
  125. /*    平面投射    */
  126. void    PolyPlane( ver, plane, vers )
  127. Vertex    *ver ;                /*    入出力        */
  128. int        plane ;                /*    投射平面    */
  129. const Vertex    *vers ;        /*    3 頂点        */
  130. {
  131.     int        i ;
  132.     double    a, b, c, d ;
  133.     const Vertex    *p1, *p2 ;
  134.  
  135.     /*    係数の計算（規格化する）    */
  136.     p1 = vers ;
  137.     p2 = vers + 1 ;
  138.     a = b = c = 0.0 ;
  139.     for( i = 0 ; i < 2 ; ++i )
  140.     {
  141.         a += (float)( ( p1->y - p2->y ) * ( p1->z + p2->z ) );
  142.         b += (float)( ( p1->z - p2->z ) * ( p1->x + p2->x ) );
  143.         c += (float)( ( p1->x - p2->x ) * ( p1->y + p2->y ) );
  144.         p1 ++ ;
  145.         p2 ++ ;
  146.     }
  147.     p2 = vers ;
  148.     a += (float)( ( p1->y - p2->y ) * ( p1->z + p2->z ) );
  149.     b += (float)( ( p1->z - p2->z ) * ( p1->x + p2->x ) );
  150.     c += (float)( ( p1->x - p2->x ) * ( p1->y + p2->y ) );
  151.  
  152.     d = - a * (float)vers->x - b * (float)vers->y - c * (float)vers->z ;
  153.  
  154.     switch( plane )
  155.     {
  156.         case VIEW_XY:
  157.             if ( c != 0.0 )
  158.                 ver->z = (int)( - ( a * (float)ver->x + b * (float)ver->y + d ) / c );
  159.             else
  160.                 MessageWarning( "平面投射できません" );
  161.             break ;
  162.         case VIEW_YZ:
  163.             if ( a != 0.0 )
  164.                 ver->x = (int)( - ( b * (float)ver->y + c * (float)ver->z + d ) / a );
  165.             else
  166.                 MessageWarning( "平面投射できません" );
  167.             break ;
  168.         case VIEW_ZX:
  169.             if ( b != 0.0 )
  170.                 ver->y = (int)( - ( a * (float)ver->x + c * (float)ver->z + d ) / b );
  171.             else
  172.                 MessageWarning( "平面投射できません" );
  173.             break ;
  174.         case VIEW_PERS:
  175.             {
  176.                 double  p[3], v0[3], v1[3];
  177.                 double l, t;
  178.                 p[0] = PersMatInv[3][0];
  179.                 p[1] = PersMatInv[3][1];
  180.                 p[2] = PersMatInv[3][2];
  181.                 v1[0] = (double)ver->x - p[0];
  182.                 v1[1] = (double)ver->y - p[1];
  183.                 v1[2] = (double)ver->z - p[2];
  184.                 l =   a * v1[0] + b * v1[1] + c * v1[2];
  185.                 t = -(a * p[0]  + b * p[1]  + c * p[2] + d) / l;
  186.                 ver->x = (int)( p[0] + v1[0] * t + 0.5);
  187.                 ver->y = (int)( p[1] + v1[1] * t + 0.5);
  188.                 ver->z = (int)( p[2] + v1[2] * t + 0.5);
  189.             }
  190.             break;
  191.         default:
  192.             ;
  193.     }
  194. }
  195.