home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 March / VPR9703A.ISO / VPR_DATA / DOGA / SOURCES / REND.LZH / REND / COLOR.C < prev    next >
C/C++ Source or Header  |  1996-06-30  |  30KB  |  1,116 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <math.h>
  5. #include <assert.h>
  6.  
  7. #include "reader.h"
  8. #include "glib.h"
  9.  
  10. static    Pointer(Atr*)    patr ;                        /*    アトリビュート            */
  11. static    int        shift[] = { 16, 24, 8 } ;    /*    r g b のシフト数        */
  12. #define COLORBITS    8
  13. /*
  14.     proto -s color.c > temp
  15. */
  16. #ifdef    XC
  17.     static    void    getposcolor();
  18.     static    void    lightcolor();
  19.     static    const    long    lpow();
  20. #else
  21. #ifdef SPEC
  22.     static    void    getposcolor( ShadeTable *, Point, Vector, Frame* );
  23.     static    void    lightcolor( Color, Color, Light*, Vector, Point, Vector );
  24. #else
  25.     static    void    getposcolor( Color, Point, Vector, Frame* );
  26.     static    void    lightcolor( Color, Light*, Vector, Point, Vector );
  27. #endif
  28.     static    const    long    lpow( long, long );
  29. #endif
  30.  
  31. /*
  32.     光度計算
  33. */
  34. int    GetAtrTable( atrtable, frame, poly, world, worldit )
  35. AtrTable    *atrtable ;
  36. Frame        *frame ;
  37. Poly        *poly ;        /*    対象ポリゴン    */
  38. Matrix        world ;        /*    ワールド座標変換行列    */
  39. Matrix        worldit ;    /*    world の転置逆行列        */
  40. {
  41.     int            i, j, n, lockpoint ;
  42.     Point        cm, pos ;    /*    重心            */
  43.     Color        col ;        /*    面の明るさ        */
  44. #ifdef SPEC
  45.     Color        spec ;        /*  面のスペキュラー    */
  46. #endif
  47.     Point        *point ;
  48.     Vector        *vecp ;
  49.     Vector        nvec ;        /*    法線ベクトル    */
  50.     Vector        vec ;
  51.     Atr            *atr ;
  52.  
  53.     patr = poly->atr ;
  54.     n = poly->pointnum ;
  55.  
  56.     /*    法線ベクトルを求める  */
  57.     vec_mult_mat( &nvec, (Vector*)poly->coe, worldit, 1, FALSE );
  58.     v_copy( pos, *pointer( poly->point ) );
  59.     vec_mult_mat( &pos, &pos, world, 1, TRUE );
  60.  
  61.     for( i = 0 ; i < 3 ; ++i )
  62.         vec[i] = frame->eye.mat[3][i] - pos[i] ;
  63. #ifdef BACKFACE
  64.     if ( s_pro( nvec, vec ) < 0.0 ) {
  65.         extern int backface;
  66.         if (backface) {
  67.             return FALSE;
  68.         } else {
  69.             v_s_mult( nvec, nvec, -1.0 );
  70.         }
  71.     }
  72. #else
  73.     if ( s_pro( nvec, vec ) < 0.0 )
  74.         v_s_mult( nvec, nvec, -1.0 );
  75. #endif
  76.     v_unit( nvec, nvec );
  77.  
  78.     if ( ShadingModel == GOURAUD_SHADE )
  79.     {
  80.         point = (Point*)pointer( poly->point );
  81.         lockpoint = datalock();
  82.         for( i = 0 ; i < n ; ++i )
  83.         {
  84.             v_copy( pos, point[i] );
  85.             vec_mult_mat( (Point*)pos, point+i, world, 1, TRUE );
  86.             if ( poly->type & SHADE )
  87.             {
  88.                 vecp = (Vector*)pointer( poly->vec );
  89.                 vec_mult_mat( (Vector*)vec, vecp+i, worldit, 1, FALSE );
  90.                 v_unit( vec, vec );
  91.                 if ( s_pro( nvec, vec ) < 0.0 )
  92.                     v_s_mult( vec, vec, -1.0 );
  93. #ifdef SPEC
  94.                 getposcolor( &(atrtable[i].shade), pos, vec, frame );
  95. #else
  96.                 getposcolor( col, pos, vec, frame );
  97. #endif
  98.             }
  99.             else
  100.             {
  101. #ifdef SPEC
  102.                 getposcolor( &(atrtable[i].shade), pos, nvec, frame );
  103. #else
  104.                 getposcolor( col, pos, nvec, frame );
  105. #endif
  106.             }
  107. #if 0
  108.             ColorToShadeTable( &(atrtable[i].shade), col );
  109.             ColorToShadeSpecularTable( &(atrtable[i].shade), spec );
  110. #endif
  111. #ifndef SPEC
  112.             ColorToShadeTable( &(atrtable[i].shade), col );
  113. #endif
  114.             atrtable[i].map.map = NULL ;
  115.         }
  116.         dataunlock( lockpoint );
  117.         atr = pointer( patr );
  118.         if ( poly->type & UVPOLY && atr->maptype != NO_MAP )
  119.             SetMapTable( atrtable, poly->uv, n, patr );
  120.     }
  121.     else
  122.     {
  123.         /*    重心の計算    */
  124.         cm[0] = cm[1] = cm[2] = 0.0 ;
  125.         point = (Point*)pointer( poly->point );
  126.         for( i = 0 ; i < n ; ++i )
  127.         {
  128.             for( j = 0 ; j < 3 ; ++j )
  129.                 cm[j] += point[i][j] ;
  130.         }
  131.         for( j = 0 ; j < 3 ; ++j )
  132.             cm[j] /= (Float)n ;
  133.         vec_mult_mat( (Point*)cm, (Point*)cm, world, 1, TRUE );
  134. #ifdef SPEC
  135.         getposcolor( &(atrtable->shade), cm, nvec, frame);
  136.         for (i = 0; i < 3; ++i) {
  137.             long c;
  138.             c = (atrtable->shade.curcolor[i] + atrtable->shade.curspecular[i]);
  139.             if (atrtable->shade.depthrate > 0) {
  140.                 c = (long)
  141.                     ((((Float)c * (SHADE_POINT - atrtable->shade.depthrate))+
  142.                     ((Float)atrtable->shade.depthcolor[i]
  143.                     *atrtable->shade.depthrate)) / (Float) SHADE_POINT);
  144.             }
  145.             if (c >= SHADE_POINT) {
  146.                 c = SHADE_POINT-1;
  147.             }
  148.             atrtable->shade.curcolor[i] = c;
  149.         }
  150. #else
  151.         getposcolor( col, cm, nvec, frame );
  152.         ColorToShadeTable( &(atrtable->shade), col );
  153. #endif
  154.         atrtable->map.map = NULL ;
  155.     }
  156.     return TRUE;
  157. }
  158.  
  159. #ifdef SPEC
  160. static void getrefdir(ShadeTable *shade, Vector nvec, Vector evec);
  161.  
  162. static    void    getposcolor( shade, pos, nvec, frame )
  163. ShadeTable *shade;
  164. Point    pos ;
  165. Vector    nvec ;
  166. Frame    *frame ;
  167. {
  168.     int        i ;
  169.     Float    r ;
  170.     Light    *light ;
  171.     Vector    evec, uevec ;
  172.     Atr        *atr ;
  173.     Color    spec;
  174.     Color    col ;
  175.  
  176.     /*    視線方向ベクトルを求める  */
  177.     for( i = 0 ; i < 3 ; ++i )
  178.         evec[i] = frame->eye.mat[3][i] - pos[i] ;
  179.     v_unit( uevec, evec );
  180.  
  181.     /*　光度計算  */
  182.     atr = pointer( patr );
  183.     c_mult( col, atr->col, atr->amb );
  184.     spec[0] = 0;spec[1] = 0; spec[2] = 0;
  185.     light = frame->light ;
  186.     for( i = 0 ; i < frame->lightnum ; ++i )
  187.         lightcolor( col, spec, light+i, uevec, pos, nvec );
  188.  
  189.     ColorToShadeTable( shade, col );
  190.     ColorToShadeSpecularTable( shade, spec );
  191.  
  192.     shade->depthrate = 0;
  193.     if ( frame->env.depth > 0.0 )
  194.     {
  195.         ColorToShadeDepthTable( shade, frame->env.depthcol );
  196. #if 0
  197.         r = pow( 0.5, v_length( evec ) / frame->env.depth );
  198. #else
  199.         r = exp(log(0.5) * v_length( evec ) / frame->env.depth );
  200. #endif
  201.         shade->depthrate = (1.0 - r) * SHADE_POINT;
  202.     }
  203. #ifdef REFMAP
  204.     if (RefMap && (atr->ref[0] > 0 || atr->ref[1] > 0 || atr->ref[2] > 0)) {
  205.         getrefdir(shade, nvec, uevec);
  206.         shade->refcolor[0] = (long)(atr->ref[0] * (Float)(SHADE_POINT/COLOR_POINT));
  207.         shade->refcolor[1] = (long)(atr->ref[1] * (Float)(SHADE_POINT/COLOR_POINT));
  208.         shade->refcolor[2] = (long)(atr->ref[2] * (Float)(SHADE_POINT/COLOR_POINT));
  209.     } else {
  210.         shade->refcolor[0] =
  211.         shade->refcolor[1] =
  212.         shade->refcolor[2] = 0;
  213.     }
  214. #endif
  215.  
  216. }
  217. #ifdef REFMAP
  218. static void getrefdir(ShadeTable *shade, Vector nvec, Vector evec)
  219. {
  220.     Vector y, r;
  221.     Float l;
  222.     int i;
  223.     v_pro(y, evec, nvec);
  224.     v_pro(r, nvec, y);
  225.     l = s_pro(nvec, evec);
  226.     for (i = 0; i < 3; ++i) {
  227.         shade->currefdir[i] = (long)((l * nvec[i]-r[i]) * (Float)SHADE_POINT);
  228.     }
  229. #if 0
  230.     fprintf(stderr, "反射:");
  231. /*
  232.     fprintf( errfp, "n:(%5.3lf %5.3lf %5.3lf)", nvec[0], nvec[1], nvec[2] ) ;
  233.     fprintf( errfp, "e:(%5.3lf %5.3lf %5.3lf)\n", evec[0], evec[1], evec[2] ) ;
  234. */
  235.     fprintf( errfp, "(%6.3lf %6.3lf %6.3lf\t",
  236.         (double)shade->currefdir[0]/(double)SHADE_POINT,
  237.         (double)shade->currefdir[1]/(double)SHADE_POINT,
  238.         (double)shade->currefdir[2]/(double)SHADE_POINT);
  239. #endif
  240. }
  241. #endif
  242.  
  243.  
  244. #else
  245.  
  246. static    void    getposcolor( col, pos, nvec, frame )
  247. Color    col ;
  248. Point    pos ;
  249. Vector    nvec ;
  250. Frame    *frame ;
  251. {
  252.     int        i ;
  253.     Float    r ;
  254.     long    dif ;
  255.     Light    *light ;
  256.     Vector    evec, uevec ;
  257.     Atr        *atr ;
  258.  
  259.     /*    視線方向ベクトルを求める  */
  260.     for( i = 0 ; i < 3 ; ++i )
  261.         evec[i] = frame->eye.mat[3][i] - pos[i] ;
  262.     v_unit( uevec, evec );
  263.  
  264.     /*　光度計算  */
  265.     atr = pointer( patr );
  266.     c_mult( col, atr->col, atr->amb );
  267.     light = frame->light ;
  268.     for( i = 0 ; i < frame->lightnum ; ++i )
  269.         lightcolor( col, light+i, uevec, pos, nvec );
  270.     if ( frame->env.depth > 0.0 )
  271.     {
  272. #if 0
  273.         r = pow( 0.5, v_length( evec ) / frame->env.depth );
  274. #else
  275.         r = exp(log(0.5) * v_length( evec ) / frame->env.depth );
  276. #endif
  277.         for( i =0 ; i < 3 ; ++i )
  278.         {
  279.             dif = (long)( r * (Float)( col[i] - frame->env.depthcol[i] ) );
  280.             col[i] = dif + frame->env.depthcol[i] ;
  281.         }
  282.     }
  283. }
  284.  
  285. #endif
  286.  
  287. #ifdef SPEC
  288. static    void    lightcolor( color, spec, light, evec, pos, nvec )
  289. Color spec;
  290. #else
  291. static    void    lightcolor( color, light, evec, pos, nvec )
  292. #endif
  293. Color    color ;
  294. Light    *light ;
  295. Vector    evec ;
  296. Point    pos ;
  297. Vector    nvec ;
  298. {
  299.     Float    r ;            /*    光源までの距離        */
  300.     Color    lcol ;        /*    光線の強さ            */
  301.     Vector    lvec ;        /*    光源方向ベクトル    */
  302.     Float    co ;        /*  余弦                */
  303.     Color    cwork ;
  304.     Vector    vwork ;
  305.     Float    dwork ;
  306.     int        j ;
  307.     long    l, lco ;
  308.     Atr        *atr ;
  309.  
  310.     c_copy( lcol, light->col );
  311.  
  312.     /*    光線方向のベクトル及び光線の強さを求める  */
  313.     switch( light->type )
  314.     {
  315.         case LIGHT_POINT :
  316.             /*    光線方向ベクトル  */
  317.             v_sub( lvec, light->point, pos );
  318.             r = v_length( lvec );
  319.             if ( fabs( r ) < minscale )
  320.                 return;
  321.             v_unit( lvec, lvec );
  322.             /*    光線の強さ    */
  323.             dwork = (light->dist*light->dist) / (r*r) ;
  324.             if ( dwork > 1.0 )
  325.                 l = COLOR_POINT ;
  326.             else
  327.                 l = (long)( dwork * (Float)COLOR_POINT );
  328.             c_s_mult( lcol, lcol, l );
  329.             break ;
  330.         case LIGHT_PAL :
  331.             v_s_mult( lvec, light->vec, -1.0 );
  332.             break ;
  333.         case LIGHT_SPOT :
  334.             v_sub( vwork, light->point, pos );
  335.             r = v_length( vwork );
  336.             if (light->dist > 0.0) {
  337.                 dwork = (light->dist*light->dist) / (r*r) ;
  338.             } else {
  339.                 dwork = 1.0;
  340.             }
  341.             v_unit( vwork, vwork );
  342.             v_s_mult( lvec, light->vec, -1.0 );
  343.             co = s_pro( vwork, lvec );
  344.             if ( co > 0.0 )
  345.             {
  346.                 lco = (long)( co * (Float)COLOR_POINT );
  347.                 l = lpow( lco, (long)( light->size * 100.0 ) );
  348.                 if (dwork < 1.0) {
  349.                     l *= dwork;
  350.                 }
  351.                 c_s_mult( lcol, lcol, l );
  352.             }
  353.             else
  354.                 lcol[0] = lcol[1] = lcol[2] = 0L ;
  355.             break ;
  356.         default :
  357.             assert( FALSE );
  358.     }
  359.  
  360.     atr = pointer( patr );
  361.  
  362.     /*    影になっているかどうか    */
  363.     co = s_pro( nvec, lvec ) ;
  364.     if ( co < 0.0 )
  365.         return;
  366.  
  367.     /*  ベクトル設定  */
  368.     v_add( vwork, evec, lvec );
  369.     v_unit( vwork, vwork );
  370.  
  371.     if ( atr->rgbflag )
  372.     {
  373.         /*    ディフューズ  */
  374.         c_mult( cwork, lcol, atr->col );
  375.         c_mult( cwork, cwork, atr->dif );
  376.         lco = (long)( co * (Float)COLOR_POINT );
  377.         c_s_mult( cwork, cwork, lco );
  378.         c_add( color, color, cwork );
  379.  
  380.         /*    スペキュラー　*/
  381.         lco = (long)( s_pro( nvec, vwork ) * (Float)COLOR_POINT );
  382.         for( j = 0 ; j < 3 ; ++j )
  383.         {
  384.             l = atr->spc[j] * lpow( lco, atr->size[j] ) >> COLOR_SHIFT ;
  385.             cwork[j] = ( atr->h * atr->col[j] + ( COLOR_POINT - atr->h ) * lcol[j] )
  386.                     >> COLOR_SHIFT ;
  387.             cwork[j] = ( l * cwork[j] ) >> COLOR_SHIFT ;
  388.         }
  389. #ifdef SPEC
  390.         c_add( spec, spec, cwork ) ;
  391. #else
  392.         c_add( color, color, cwork ) ;
  393. #endif
  394.     }
  395.     else
  396.     {
  397.         /*    ディフューズ  */
  398.         c_mult( cwork, lcol, atr->col );
  399. #if 1
  400.         l = ( (long)( co * (Float)COLOR_POINT ) * atr->dif[0] ) >> COLOR_SHIFT ;
  401. #else
  402.         l = (long)( co * (Float)atr->dif[0] );
  403. #endif
  404.         c_s_mult( cwork, cwork, l );
  405.         c_add( color, color, cwork );
  406.  
  407.         /*    スペキュラー　*/
  408.         lco = (long)( s_pro( nvec, vwork ) * (Float)COLOR_POINT );
  409.         lco = atr->spc[0] * lpow( lco, atr->size[0] ) >> COLOR_SHIFT ;
  410.         if ( atr->h == 0L )
  411.             c_s_mult( cwork, lcol, lco );
  412.         else
  413.         {
  414.             for( j = 0 ; j < 3 ; ++j )
  415.             {
  416.                 l = ( atr->h * atr->col[j] + ( COLOR_POINT - atr->h ) * lcol[j] )
  417.                         >> COLOR_SHIFT ;
  418.                 cwork[j] = ( lco * l ) >> COLOR_SHIFT ;
  419.             }
  420.         }
  421. #ifdef SPEC
  422.         c_add( spec, spec, cwork );
  423. #else
  424.         c_add( color, color, cwork );
  425. #endif
  426.     }
  427. }
  428.  
  429. static    const    long    lpow( a, n )
  430. long    a ;
  431. long    n ;
  432. {
  433.     long    ret ;
  434.  
  435.     ret = COLOR_POINT ;
  436.     while( n > 0 )
  437.     {
  438.         if ( n & 1 )
  439.             ret = ( ret * a ) >> COLOR_SHIFT ;
  440.         n = n / 2 ;
  441.         a = ( a * a ) >> COLOR_SHIFT ;
  442.     }
  443.     return( ret );
  444. }
  445.  
  446. ColorCode X68kcolorToColorCode( unsigned short color)
  447. {
  448.     ColorCode code;
  449. /*
  450.      -6 + 16 = 10
  451.     -11 + 24 = 13
  452.      -1 +  8 =  7
  453.                         gggg grrr rrbb bbbt
  454.     gggg gggg rrrr rrrr bbbb bbbb 0000 000t
  455. */
  456. #if 0
  457.     code = ((color & 0x07c0) << 13)
  458.          | ((color & 0xf800) << 16)
  459.          | ((color & 0x003e) << 10)
  460.          | ((color & 0x0001) ? 0xff : 0);
  461.     return code;
  462. #else
  463.     code = ((unsigned long)(color & 0xf800) << 11L)
  464.          | ((unsigned long)(color & 0x07c0) <<  8L)
  465.          | ((unsigned long)(color & 0x003e) <<  5L);
  466.     return  (code << 5L) | (code & 0x07070700L) | ((color & 0x0001) ? 0xff : 0);
  467. #endif
  468. }
  469.  
  470. ColorCode ColorCodeToX68kcolor( code )
  471. ColorCode code;
  472. {
  473.     unsigned short color;
  474. /*
  475.      -6 + 16 = 10
  476.     -11 + 24 = 13
  477.      -1 +  8 =  7
  478. */
  479.     color = (unsigned short)
  480.            (((code >> 13) & 0x07c0)
  481.           | ((code >> 16) & 0xf800)
  482.           | ((code >> 10) & 0x003e)
  483.           | ((code & 0x0080) ? 1 : 0));
  484.     return color;
  485. }
  486.  
  487. /*    カラーコードの計算    */
  488. const    ColorCode    ColorToCode( color )
  489. Color    color ;
  490. {
  491.     ColorCode    code, c ;
  492.     int        i ;
  493.     code = 0 ;
  494.     for( i = 0 ; i < 3 ; ++i )
  495.     {
  496.         c = (ColorCode)( color[i] >> ( COLOR_SHIFT - COLORBITS ) );
  497.         if ( c >= (1 << COLORBITS) )
  498.             c = (1 << COLORBITS)-1 ;
  499.         code += c << shift[i] ;
  500.     }
  501.     return( code );
  502. }
  503.  
  504. #ifdef MAPANTI
  505. ColorCode ColorMix(ColorCode c11, ColorCode c12, ColorCode c21, ColorCode c22,
  506.                     int urate, int vrate)
  507. {
  508.     unsigned long r, g, b, t;
  509.     g = (unsigned long)
  510.         (( c11 >> 24       ) * (256 - urate) * (256 - vrate)
  511.        + ( c12 >> 24       ) * (256 - urate) *        vrate
  512.        + ( c21 >> 24       ) *        urate  * (256 - vrate)
  513.        + ( c22 >> 24       ) *        urate  *        vrate );
  514.     r = (unsigned long)
  515.         (((c11 >> 16) & 255) * (256 - urate) * (256 - vrate)
  516.        + ((c12 >> 16) & 255) * (256 - urate) *        vrate
  517.        + ((c21 >> 16) & 255) *        urate  * (256 - vrate)
  518.        + ((c22 >> 16) & 255) *        urate  *        vrate );
  519.     b = (unsigned long)
  520.         (((c11 >>  8) & 255) * (256 - urate) * (256 - vrate)
  521.        + ((c12 >>  8) & 255) * (256 - urate) *        vrate
  522.        + ((c21 >>  8) & 255) *        urate  * (256 - vrate)
  523.        + ((c22 >>  8) & 255) *        urate  *        vrate );
  524.     t = (unsigned long)
  525.         (( c11        & 255) * (256 - urate) * (256 - vrate)
  526.        + ( c12        & 255) * (256 - urate) *        vrate
  527.        + ( c21        & 255) *        urate  * (256 - vrate)
  528.        + ( c22        & 255) *        urate  *        vrate );
  529.     return ((g & 0xff0000L) << 8)
  530.          |  (r & 0xff0000L)
  531.          | ((b & 0xff0000L) >> 8) | (t>>16);
  532. }
  533.  
  534. #endif
  535.  
  536. /*    カラーコードの計算    */
  537. ColorCode    GetColorCode( shade, maptable )
  538. ShadeTable    *shade ;
  539. MapTable    *maptable ;
  540. {
  541.     unsigned long cc ;
  542.     long            u, v ;
  543.     Map            *map ;
  544.     REGISTER    ColorCode    code, c ;
  545.     REGISTER    int            i ;
  546.  
  547.     if ( maptable == NULL || maptable->map == NULL )
  548.     {
  549.         /*  マッピングなし  */
  550.         code = 0 ;
  551.         for( i = 0 ; i < 3 ; ++i )
  552.         {
  553.             c = (ColorCode)( shade->curcolor[i] >> ( SHADE_SHIFT - COLORBITS ) );
  554.             if ( c >= (1 << COLORBITS) )
  555.                 c = (1 << COLORBITS)-1 ;
  556.             code += c << shift[i] ;
  557.         }
  558.     }
  559.     else
  560.     {
  561. #ifdef  MAPANTI
  562.         extern int MapAntiFlag;
  563.         if (MapAntiFlag) {
  564.             int u1, u2, urate;
  565.             int v1, v2, vrate;
  566.             ColorCode c11, c12, c21, c22;
  567.             /*    マッピングの処理    */
  568.             map = maptable->map ;
  569.             u = maptable->curuv[0];
  570.             v = maptable->curuv[1];
  571.             if (u >= 0) {
  572.                 u = u % (map->h << 16);
  573.             } else {
  574.                 u = (map->h << 16) - 1 - ( (-u) % (map->h << 16));
  575.             }
  576.             if (v >= 0) {
  577.                 v = v % (map->v << 16);
  578.             } else {
  579.                 v = (map->v << 16) - 1 - ( (-v) % (map->v << 16));
  580.             }
  581.             u1 = (int)(u >> 16);
  582.             u2 = (u1+1) % map->h;
  583.             v1 = (int)(v >> 16);
  584.             v2 = (v1+1) % map->v;
  585.             urate = (int)((u & 65535L) >> 8);
  586.             vrate = (int)((v & 65535L) >> 8);
  587.             if (map->fullcolor) {
  588.                 c11 = ( (ColorCode*)pointer( map->buf[v1] ) )[u1] ;
  589.                 c12 = ( (ColorCode*)pointer( map->buf[v2] ) )[u1] ;
  590.                 c21 = ( (ColorCode*)pointer( map->buf[v1] ) )[u2] ;
  591.                 c22 = ( (ColorCode*)pointer( map->buf[v2] ) )[u2] ;
  592.             } else {
  593.                 c11 = X68kcolorToColorCode(( (unsigned short *)pointer( map->buf[v1] ) )[u1]) ;
  594.                 c12 = X68kcolorToColorCode(( (unsigned short *)pointer( map->buf[v2] ) )[u1]) ;
  595.                 c21 = X68kcolorToColorCode(( (unsigned short *)pointer( map->buf[v1] ) )[u2]) ;
  596.                 c22 = X68kcolorToColorCode(( (unsigned short *)pointer( map->buf[v2] ) )[u2]) ;
  597.             }
  598.             c = ColorMix(c11, c12, c21, c22, urate, vrate);
  599.         } else
  600. #endif
  601.         {
  602.             /*    マッピングの処理    */
  603.             map = maptable->map ;
  604.             u = (int)( maptable->curuv[0] >> 16 );
  605.             v = (int)( maptable->curuv[1] >> 16 );
  606.             if ( u >= 0 )
  607.                 u = u % map->h ;
  608.             else
  609.                 u = map->h - 1 - ( ( - u ) % map->h ) ;
  610.             if ( v >= 0 )
  611.                 v = v % map->v ;
  612.             else
  613.                 v = map->v - 1 - ( ( - v ) % map->v );
  614.  
  615.             if (map->fullcolor) {
  616.                 c = ( (ColorCode*)pointer( map->buf[(int)v] ) )[(int)u] ;
  617.             } else {
  618.                 c = X68kcolorToColorCode(( (unsigned short *)pointer( map->buf[(int)v] ) )[(int)u]) ;
  619.             }
  620.         }
  621.         if ((c & 0xff) == 0xff) {
  622.             return 0xff;
  623.         }
  624.         code = c & 255; ;
  625.         for( i = 0 ; i < 3 ; ++i )
  626.         {
  627.             cc = (ColorCode)(
  628.                     ( ( ( (long)c >> shift[i] ) & ((1 << COLORBITS)-1) ) * shade->curcolor[i] )
  629.                      >> SHADE_SHIFT
  630.                 ) ;
  631.             if ( cc >= (1 << COLORBITS) )
  632.                 cc = (1 << COLORBITS)-1 ;
  633.             code += cc << shift[i] ;
  634.         }
  635.     }
  636.     return( code );
  637. }
  638.  
  639. #ifdef REFMAP
  640. static ColorCode GetRefMapColor(long *direction)
  641. {
  642.     extern int MapAntiFlag;
  643.     ColorCode c;
  644.     Map *map = RefMapData[0];
  645.     int u = 0, v = 0;
  646.     Float l;
  647.     if (RefMap == 1) {
  648.         l = sqrt((Float)(direction[0]) * (Float)(direction[0])
  649.                 + (Float)(direction[1]) * (Float)(direction[1]));
  650.         if (l <= 1) {
  651.             u = 0;
  652.             if (direction[2] > 0) {
  653.                 v = 0;
  654.             } else {
  655.                 v = (map->v-2)*256;
  656.             }
  657.         } else {
  658.             double fu, fv;
  659.             fu = atan2(-direction[1], direction[0]);
  660.             u = (int)(fu * (map->h-1) * (1.0 / 3.14159265 / 2.0 * 256.0)) + (map->h-1)*(256/2);
  661.             fv = atan(-direction[2]/ l);
  662.             v = (int)(fv * (map->v-1) * (1.0 / 3.14159265  * 256.0))      + (map->v-1)*(256/2);
  663.         }
  664.     } else if (RefMap == 2) {
  665.         l = sqrt((Float)(direction[0]) * (Float)(direction[0])
  666.                 + (Float)(direction[1]) * (Float)(direction[1])
  667.                 + (Float)(direction[2]) * (Float)(direction[2]));
  668.         if (l < 1.0) {
  669.             u = v = 0;
  670.         } else {
  671.             u = -(int)((Float)direction[1] / l * (Float)(map->h-1) * (256.0/2.0)) + (map->h-1)*(256/2) ;
  672.             v =  (int)((Float)direction[0] / l * (Float)(map->v-1) * (256.0/2.0));
  673.             if (direction[2] > 0) {
  674.                 v = (map->v-1)*(256/2) + v;        /*上*/
  675.             } else {
  676.                 map = RefMapData[1];
  677.                 v = (map->v-1)*(256/2) - v;        /*下*/
  678.             }
  679.         }
  680.     } else if (RefMap == 6) {
  681.         Float x, y, z;
  682.         x = direction[0] > 0 ? direction[0] : -direction[0];
  683.         y = direction[1] > 0 ? direction[1] : -direction[1];
  684.         z = direction[2] > 0 ? direction[2] : -direction[2];
  685.         if (x > y && x > z && x > 1.0) {
  686.             if (direction[0] > 0) {
  687.                 u =  (int)((Float)direction[1] / x * (Float)(map->h-1) * (256.0/2.0));
  688.                 u = (map->h-1)*(256/2) - u;        /*前(X+)*/
  689.             } else {
  690.                 map = RefMapData[2];
  691.                 u =  (int)((Float)direction[1] / x * (Float)(map->h-1) * (256.0/2.0));
  692.                 u = (map->h-1)*(256/2) + u;        /*後(X-)*/
  693.             }
  694.             v = -(int)((Float)direction[2] / x * (Float)(map->v-1) * (256.0/2.0)) + (map->v-1)*256/2;
  695.         } else if (y > z && y > 1.0) {
  696.             if (direction[1] > 0) {
  697.                 map = RefMapData[3];
  698.                 u =  (int)((Float)direction[0] / y * (Float)(map->h-1) * (256.0/2.0));
  699.                 u = (map->h-1)*(256/2) + u;        /*左(Y+)*/
  700.             } else {
  701.                 map = RefMapData[1];
  702.                 u =  (int)((Float)direction[0] / y * (Float)(map->h-1) * (256.0/2.0));
  703.                 u = (map->h-1)*(256/2) - u;        /*右(Y-)*/
  704.             }
  705.             v = -(int)((Float)direction[2] / y * (Float)(map->v-1) * (256.0/2.0)) + (map->v-1)*(256/2);
  706.         } else if (z > 1.0) {
  707.             if (direction[2] > 0) {
  708.                 map = RefMapData[4];
  709.                 v =  (int)((Float)direction[0] / z * (Float)(map->v-1) * (256.0/2.0));
  710.                 v = (map->v-1)*(256/2) + v;        /*上(Z+)*/
  711.             } else {
  712.                 map = RefMapData[5];
  713.                 v =  (int)((Float)direction[0] / z * (Float)(map->v-1) * (256.0/2.0));
  714.                 v = (map->v-1)*(256/2) - v;        /*下(Z-)*/
  715.             }
  716.             u = -(int)((Float)direction[1] / z * (Float)(map->h-1) * (256.0/2.0)) + (map->h-1)*(256/2);
  717.         }
  718.     }
  719. #ifdef  MAPANTI
  720.     if (MapAntiFlag) {
  721.         int urate, vrate;
  722.         int u2, v2;
  723.         ColorCode c11, c12, c21, c22;
  724.         urate = u & 255;
  725.         vrate = v & 255;
  726.         u >>= 8;
  727.         u2 = (u < map->h-1) ? u+1 : u;
  728.         v >>= 8;
  729.         v2 = (v < map->v-1) ? v+1 : v;
  730.         if (map->fullcolor) {
  731.             c11 = ( (ColorCode*)pointer( map->buf[v ] ) )[u] ;
  732.             c12 = ( (ColorCode*)pointer( map->buf[v2] ) )[u] ;
  733.             c21 = ( (ColorCode*)pointer( map->buf[v ] ) )[u2] ;
  734.             c22 = ( (ColorCode*)pointer( map->buf[v2] ) )[u2] ;
  735.         } else {
  736.             c11 = X68kcolorToColorCode(( (unsigned short *)pointer( map->buf[v ] ) )[u]) ;
  737.             c12 = X68kcolorToColorCode(( (unsigned short *)pointer( map->buf[v2] ) )[u]) ;
  738.             c21 = X68kcolorToColorCode(( (unsigned short *)pointer( map->buf[v ] ) )[u2]) ;
  739.             c22 = X68kcolorToColorCode(( (unsigned short *)pointer( map->buf[v2] ) )[u2]) ;
  740.         }
  741.         c = ColorMix(c11, c12, c21, c22, urate, vrate);
  742.     } else
  743. #endif
  744.     if (map->fullcolor) {
  745.         c = ( (ColorCode*)pointer( map->buf[v>>8] ) )[u>>8] ;
  746.     } else {
  747.         c = X68kcolorToColorCode(( (unsigned short *)pointer( map->buf[v>>8] ) )[u>>8]) ;
  748.     }
  749.     return c;
  750. }
  751. #endif
  752.  
  753. #ifdef SPEC
  754. ColorCode    GetColorAllCode( shade, maptable )
  755. ShadeTable    *shade ;
  756. MapTable    *maptable ;
  757. {
  758.     unsigned long cc ;
  759.     int            u, v ;
  760.     Map            *map ;
  761.     REGISTER    ColorCode    code, c ;
  762.     REGISTER    int            i ;
  763.  
  764. #ifdef REFMAP
  765.     long refcolor[3];
  766.     refcolor[0] = refcolor[1] = refcolor[2] = 0;
  767.     if (RefMap && (shade->refcolor[0] > 0 || shade->refcolor[1] > 0 || shade->refcolor[2] > 0)) {        c = GetRefMapColor(shade->currefdir);
  768.         for( i = 0 ; i < 3 ; ++i )
  769.         {
  770.             if (shade->refcolor[i] > 0) {
  771.                 refcolor[i] =
  772.                     ( ( ( (unsigned long)c >> shift[i] ) & ((1 << COLORBITS)-1) ) * shade->refcolor[i] )
  773.                          >> COLORBITS;
  774.             }
  775.         }
  776.     }
  777. #endif
  778.     if ( maptable == NULL || maptable->map == NULL )
  779.     {
  780.         /*  マッピングなし  */
  781.         code = 0 ;
  782.         for( i = 0 ; i < 3 ; ++i )
  783.         {
  784. #ifdef REFMAP
  785.             c = (ColorCode)(
  786.                 (shade->curcolor[i]+shade->curspecular[i]+refcolor[i])
  787.                      >> ( SHADE_SHIFT - COLORBITS ) );
  788. #else
  789.             c = (ColorCode)(
  790.                 (shade->curcolor[i]+shade->curspecular[i])
  791.                      >> ( SHADE_SHIFT - COLORBITS ) );
  792. #endif
  793.             if ( c >= (1 << COLORBITS) )
  794.                 c = (1 << COLORBITS)-1 ;
  795.             if (shade->depthrate > 0) {
  796.                 c = ( c * (SHADE_POINT - shade->depthrate)
  797.                      + (shade->depthcolor[i] >> (SHADE_SHIFT - COLORBITS))
  798.                        * shade->depthrate) / SHADE_POINT;
  799.             }
  800.  
  801.             code += c << shift[i] ;
  802.         }
  803.     }
  804. /*    ここから下にくることはない(マッピング時はGetColorCode, GetSpecularColorCode使用)    */
  805.     else
  806.     {
  807.         /*    マッピングの処理    */
  808.         map = maptable->map ;
  809.         u = (int)( maptable->curuv[0] >> 16 );
  810.         v = (int)( maptable->curuv[1] >> 16 );
  811.         if ( u >= 0 )
  812.             u = u % map->h ;
  813.         else
  814.             u = map->h - ( ( - u ) % map->h ) ;
  815.         if ( v >= 0 )
  816.             v = v % map->v ;
  817.         else
  818.             v = map->v - ( ( - v ) % map->v );
  819.         if (map->fullcolor) {
  820.             c = ( (ColorCode*)pointer( map->buf[v] ) )[u] ;
  821.         } else {
  822.             c = X68kcolorToColorCode(( (unsigned short *)pointer( map->buf[v] ) )[u]) ;
  823.         }
  824.  
  825.         if ((c & 1) != 0) {
  826.             return 1;
  827.         }
  828.         code = 0 ;
  829.         for( i = 0 ; i < 3 ; ++i )
  830.         {
  831.             cc = (ColorCode)(
  832.                 (
  833.                     ( ( ( (long)c >> shift[i] ) & ((1 << COLORBITS)-1) ) * shade->curcolor[i] )
  834.                      >> SHADE_SHIFT
  835.                 ) + (
  836.                     shade->curspecular[i] >> (SHADE_SHIFT - COLORBITS)
  837.                 )) ;
  838.             if (shade->depthrate > 0) {
  839.                 cc = ( cc * (SHADE_POINT - shade->depthrate)
  840.                      + (shade->depthcolor[i] >> (SHADE_SHIFT - COLORBITS))
  841.                        * shade->depthrate) / SHADE_POINT;
  842.             }
  843.             if ( cc >= (1 << COLORBITS) )
  844.                 cc = (1 << COLORBITS)-1 ;
  845.             code += cc << shift[i] ;
  846.         }
  847.     }
  848.     return( code );
  849. }
  850.  
  851. /*    カラーコードの計算    */
  852. ColorCode    GetSpecularColorCode( shade )
  853. ShadeTable    *shade ;
  854. {
  855.     unsigned long cc ;
  856.     REGISTER    ColorCode    code, c ;
  857.     REGISTER    int            i ;
  858.  
  859.     /*  マッピングなし  */
  860.     code = 0 ;
  861.  
  862. #ifdef REFMAP
  863.     c = 0;
  864.     if (RefMap) {
  865.         c = GetRefMapColor(shade->currefdir);
  866.         for( i = 0 ; i < 3 ; ++i )
  867.         {
  868.             cc = 0;
  869.             if (shade->refcolor[i] > 0) {
  870.                 cc = (ColorCode)
  871.                     (
  872.                         ( ( ( (unsigned long)c >> shift[i] ) & ((1 << COLORBITS)-1) ) * shade->refcolor[i] )
  873.                          >> SHADE_SHIFT
  874.                     );
  875.             }
  876.             if (shade->curspecular[i] > 0) {
  877.                 cc += (ColorCode)( shade->curspecular[i] >> ( SHADE_SHIFT - COLORBITS ) );
  878.             }
  879.             if ( cc >= (1 << COLORBITS) )
  880.                 cc = (1 << COLORBITS)-1 ;
  881.             code += cc << shift[i] ;
  882.         }
  883.     } else
  884. #endif
  885.     for( i = 0 ; i < 3 ; ++i )
  886.     {
  887.         if (shade->curspecular[i] > 0) {
  888.             c = (ColorCode)( shade->curspecular[i] >> ( SHADE_SHIFT - COLORBITS ) );
  889.  
  890.             if ( c >= (1 << COLORBITS) )
  891.                 c = (1 << COLORBITS)-1 ;
  892.             code += c << shift[i] ;
  893.         }
  894.     }
  895.     return code;
  896. }
  897. #endif
  898.  
  899. /*    アトリビュートデータの計算    */
  900. void    ColorToShadeTable( shade, col )
  901. ShadeTable    *shade ;
  902. Color        col ;
  903. {
  904.     REGISTER    int        i ;
  905.  
  906.     for( i = 0 ; i < 3 ; ++i )
  907.     {
  908.         if ( col[i] >= COLOR_POINT )
  909.             shade->curcolor[i] = SHADE_POINT - 1;
  910.         else
  911.             shade->curcolor[i] = col[i] << (SHADE_SHIFT - COLOR_SHIFT);
  912.     }
  913. }
  914.  
  915. #ifdef SPEC
  916. void    ColorToShadeSpecularTable( shade, col )
  917. ShadeTable    *shade ;
  918. Color        col ;
  919. {
  920.     REGISTER    int        i ;
  921.  
  922.     for( i = 0 ; i < 3 ; ++i )
  923.     {
  924.         if ( col[i] >= COLOR_POINT )
  925.             shade->curspecular[i] = SHADE_POINT - 1;
  926.         else
  927.             shade->curspecular[i] = col[i] << (SHADE_SHIFT - COLOR_SHIFT);
  928.     }
  929. }
  930. void    ColorToShadeDepthTable( shade, col )
  931. ShadeTable    *shade ;
  932. Color        col ;
  933. {
  934.     REGISTER    int        i ;
  935.  
  936.     for( i = 0 ; i < 3 ; ++i )
  937.     {
  938.         if ( col[i] >= COLOR_POINT )
  939.             shade->depthcolor[i] = SHADE_POINT - 1;
  940.         else
  941.             shade->depthcolor[i] = col[i] << (SHADE_SHIFT - COLOR_SHIFT);
  942.     }
  943. }
  944. #endif
  945.  
  946.  
  947. /*    アトリビュートデータの更新  */
  948. void    IncAtrTable( shade, map )
  949. REGISTER    ShadeTable    *shade ;
  950. REGISTER    MapTable    *map ;
  951. {
  952.     shade->curcolor[0] += shade->stepcolor[0] ;
  953.     shade->curcolor[1] += shade->stepcolor[1] ;
  954.     shade->curcolor[2] += shade->stepcolor[2] ;
  955. #ifdef SPEC
  956.     shade->curspecular[0] += shade->stepspecular[0] ;
  957.     shade->curspecular[1] += shade->stepspecular[1] ;
  958.     shade->curspecular[2] += shade->stepspecular[2] ;
  959.  
  960.     shade->depthrate += shade->stepdepthrate;
  961. #endif
  962.  
  963.     if ( map != NULL && map->map != NULL )
  964.     {
  965.         map->curuv[0] += map->stepuv[0] ;
  966.         map->curuv[1] += map->stepuv[1] ;
  967. #ifdef EXTENDMAP
  968.         map->stepuv[0] += map->stepstepuv[0];
  969.         map->stepuv[1] += map->stepstepuv[1];
  970. #endif
  971.     }
  972. #ifdef REFMAP
  973.     if (RefMap) {
  974.         shade->currefdir[0] += shade->steprefdir[0];
  975.         shade->currefdir[1] += shade->steprefdir[1];
  976.         shade->currefdir[2] += shade->steprefdir[2];
  977.     }
  978. #endif
  979. }
  980.  
  981. /*    アトリビュートデータの更新  */
  982. void    AddAtrTable( shade, map, count )
  983. REGISTER    ShadeTable    *shade ;
  984. REGISTER    MapTable    *map ;
  985. int        count ;
  986. {
  987.     shade->curcolor[0] += count * shade->stepcolor[0] ;
  988.     shade->curcolor[1] += count * shade->stepcolor[1] ;
  989.     shade->curcolor[2] += count * shade->stepcolor[2] ;
  990. #ifdef SPEC
  991.     shade->curspecular[0] += count * shade->stepspecular[0] ;
  992.     shade->curspecular[1] += count * shade->stepspecular[1] ;
  993.     shade->curspecular[2] += count * shade->stepspecular[2] ;
  994.  
  995.     shade->depthrate += count * shade->stepdepthrate;
  996. #endif
  997.     if ( map != NULL && map->map != NULL )
  998.     {
  999. #ifdef EXTENDMAP
  1000.         int i;
  1001.         for (i = count; i > 0; --i) {
  1002.             map->curuv[0] += map->stepuv[0] ;
  1003.             map->curuv[1] += map->stepuv[1] ;
  1004.             map->stepuv[0] += map->stepstepuv[0];
  1005.             map->stepuv[1] += map->stepstepuv[1];
  1006.         }
  1007. #else
  1008.         map->curuv[0] += count * map->stepuv[0] ;
  1009.         map->curuv[1] += count * map->stepuv[1] ;
  1010. #endif
  1011.     }
  1012. #ifdef REFMAP
  1013.     if (RefMap &&
  1014.         (shade->refcolor[0] > 0 || shade->refcolor[1] > 0 || shade->refcolor[2] > 0)) {
  1015.         shade->currefdir[0] += count * shade->steprefdir[0];
  1016.         shade->currefdir[1] += count * shade->steprefdir[1];
  1017.         shade->currefdir[2] += count * shade->steprefdir[2];
  1018.     }
  1019. #endif
  1020. }
  1021. /*    アトリビュートデータの設定  */
  1022. void    SetAtrStep( shade, toshade, map, tomap, step )
  1023. REGISTER    ShadeTable    *shade ;
  1024. ShadeTable    *toshade ;
  1025. REGISTER    MapTable    *map ;
  1026. MapTable    *tomap ;
  1027. int            step ;
  1028. {
  1029.     shade->stepcolor[0]
  1030.         = (toshade->curcolor[0] - shade->curcolor[0] + step / 2) / step ;
  1031.     shade->stepcolor[1]
  1032.         = (toshade->curcolor[1] - shade->curcolor[1] + step / 2) / step ;
  1033.     shade->stepcolor[2]
  1034.         = (toshade->curcolor[2] - shade->curcolor[2] + step / 2) / step ;
  1035. #ifdef SPEC
  1036.     shade->stepspecular[0]
  1037.         = (toshade->curspecular[0] - shade->curspecular[0] + step / 2) / step ;
  1038.     shade->stepspecular[1]
  1039.         = (toshade->curspecular[1] - shade->curspecular[1] + step / 2) / step ;
  1040.     shade->stepspecular[2]
  1041.         = (toshade->curspecular[2] - shade->curspecular[2] + step / 2) / step ;
  1042.  
  1043.     shade->stepdepthrate
  1044.         = (toshade->depthrate - shade->depthrate + step / 2) / step ;
  1045. #endif
  1046.  
  1047.     if ( map != NULL && map->map != NULL )
  1048.     {
  1049.         map->stepuv[0]
  1050.             = ( tomap->curuv[0] - map->curuv[0] + step / 2 ) / step ;
  1051.         map->stepuv[1]
  1052.             = ( tomap->curuv[1] - map->curuv[1] + step / 2 ) / step ;
  1053.     }
  1054. #ifdef REFMAP
  1055.     if (RefMap && (shade->refcolor[0] > 0 || shade->refcolor[1] > 0 || shade->refcolor[2] > 0)) {
  1056.         shade->steprefdir[0]
  1057.             = (toshade->currefdir[0] - shade->currefdir[0] + step / 2) / step ;
  1058.         shade->steprefdir[1]
  1059.             = (toshade->currefdir[1] - shade->currefdir[1] + step / 2) / step ;
  1060.         shade->steprefdir[2]
  1061.             = (toshade->currefdir[2] - shade->currefdir[2] + step / 2) / step ;
  1062.     }
  1063. #endif
  1064.  
  1065. }
  1066.  
  1067. void    SetAtrStepMap( z1, z2, map, tomap, step )
  1068. long z1, z2;
  1069. MapTable    *map, *tomap;
  1070. int step;
  1071. {
  1072.     Float gamma;
  1073.  
  1074.     gamma = (Float)z2 / ((Float)(z1)+(Float)(z2));
  1075.  
  1076.     if (step == 1) {
  1077.         map->stepuv[0] = tomap->curuv[0] - map->curuv[0];
  1078.         map->stepuv[1] = tomap->curuv[1] - map->curuv[1];
  1079.         map->stepstepuv[0] = 0;
  1080.         map->stepstepuv[1] = 0;
  1081.     } else if (gamma < 0.25) {
  1082.         map->stepuv[0] = 0;
  1083.         map->stepuv[1] = 0;
  1084.         map->stepstepuv[0]
  1085.             = 2 * ( tomap->curuv[0] - map->curuv[0] + step / 2 )
  1086.             / step / (step-1);
  1087.         map->stepstepuv[1]
  1088.             = 2 * ( tomap->curuv[1] - map->curuv[1] + step / 2 )
  1089.             / step / (step-1);
  1090.     } else if (gamma > 0.75) {
  1091.         map->stepuv[0]
  1092.             = 2 * ( tomap->curuv[0] - map->curuv[0] + step / 2 )
  1093.             / (step+1);
  1094.         map->stepuv[1]
  1095.             = 2 * ( tomap->curuv[1] - map->curuv[1] + step / 2 )
  1096.             / (step+1);
  1097.         map->stepstepuv[0] = -map->stepuv[0] / step;
  1098.         map->stepstepuv[1] = -map->stepuv[1] / step;
  1099.     } else {
  1100.         map->stepuv[0]
  1101.             = ( tomap->curuv[0] - map->curuv[0] + step / 2 )
  1102.             * ( 4.0 * gamma - 1.0) / step;
  1103.         map->stepuv[1]
  1104.             = ( tomap->curuv[1] - map->curuv[1] + step / 2 )
  1105.             * ( 4.0 * gamma - 1.0) / step;
  1106.         map->stepstepuv[0]
  1107.             = 4 * ( tomap->curuv[0] - map->curuv[0] + step / 2 )
  1108.             * ( 1.0 - 2.0 * gamma ) / step / (step-1);
  1109.         map->stepstepuv[1]
  1110.             = 4 * ( tomap->curuv[1] - map->curuv[1] + step / 2 )
  1111.             * ( 1.0 - 2.0 * gamma ) / step / (step-1);
  1112.         map->stepuv[0] += map->stepstepuv[0];
  1113.         map->stepuv[1] += map->stepstepuv[1];
  1114.     }
  1115. }
  1116.