home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / gfx / 3d / irit / scripts / smorph.irt < prev    next >
Encoding:
Text File  |  1994-09-03  |  9.5 KB  |  333 lines
  1. #
  2. # A simple example of surface morphing.
  3. #
  4. #                    Gershon Elber, July 1992.
  5. #
  6. # render with raysahde with a unit matrix and the following:
  7. #
  8. # eyep   10 8  6
  9. # lookp  0  0  0
  10. # up     0  0  1
  11. # fov 12
  12. # 
  13. # light 0.8 directional 0 0 1
  14. # light 0.7 directional 0 1 0
  15. # light 0.6 directional 1 0 0
  16. # 
  17.  
  18. save_res = resolution;
  19. view(list(view_mat), on);
  20.  
  21. if ( machine == msdos, resolution = 7, resolution = 10 );
  22. if ( machine == msdos, step = 0.2, step = 0.05 );
  23.  
  24. FloorLvl = -0.72;
  25. FloorXYMin = -1.4;
  26.  
  27. v1 = vector( -16.0, -16.0, FloorLvl );
  28. V2 = vector( -16.0,  16.0, FloorLvl );
  29. v3 = vector(  16.0,  16.0, FloorLvl );
  30. v4 = vector(  16.0, -16.0, FloorLvl );
  31. Floor = poly( list( v1, v2, v3, v4 ), false );
  32. color( Floor, red );
  33. attrib( Floor, "rgb", "244,164,96" );
  34. attrib( Floor, "texture", "wood" );
  35. attrib( Floor, "reflect", "0.3" );
  36.  
  37. Wall1 = poly( list( vector( FloorXYMin,       16.0, FloorLvl ),
  38.             vector( FloorXYMin, FloorXYMin, FloorLvl ),
  39.             vector( FloorXYMin, FloorXYMin, 16.0 ),
  40.             vector( FloorXYMin,       16.0, 16.0 ) ),
  41.           false );
  42. Wall2 = poly( list( vector(       16.0, FloorXYMin, FloorLvl ),
  43.             vector( FloorXYMin, FloorXYMin, FloorLvl ),
  44.             vector( FloorXYMin, FloorXYMin, 16.0 ),
  45.             vector(       16.0, FloorXYMin, 16.0 ) ),
  46.           false );
  47. color( Wall1, white );
  48. attrib( Wall1, "rgb", "255,255,255" );
  49. color( Wall2, white );
  50. attrib( Wall2, "rgb", "255,255,255" );
  51.  
  52. Backgrd = list( Floor, Wall1, Wall2 );
  53.  
  54. #############################################################################
  55. # First Morphing Sequence.                            #
  56. #############################################################################
  57.  
  58. Srf1 = ruledsrf( circle( vector( 0.0, 0.0, FloorLvl + 0.01 ), 1.0 ),
  59.          circle( vector( 0.0, 0.0, FloorLvl + 0.01 ), 0.01 ) );
  60. color( Srf1, yellow );
  61.  
  62. bcross = cbspline( 3,
  63.            list( ctlpt( E3,  0.0,  0.0, -0.71 ),
  64.                  ctlpt( E3,  0.2,  0.0, -0.72 ),
  65.                  ctlpt( E3,  0.25, 0.0, -0.7 ),
  66.                  ctlpt( E3,  0.25, 0.0, -0.1 ),
  67.                  ctlpt( E3,  0.2,  0.0, -0.05 ),
  68.                  ctlpt( E3,  0.15, 0.0,  0.0 ),
  69.                  ctlpt( E3,  0.1,  0.0,  0.6 ),
  70.              ctlpt( E3,  0.11, 0.0,  0.61 ),
  71.              ctlpt( E3,  0.12, 0.0,  0.61 ),
  72.              ctlpt( E3,  0.12, 0.0,  0.65 ),
  73.              ctlpt( E3,  0.09, 0.0,  0.65 ),
  74.              ctlpt( E3,  0.07, 0.0,  0.64 ),
  75.              ctlpt( E3,  0.10, 0.0, -0.05 ),
  76.              ctlpt( E3,  0.21, 0.0, -0.1 ),
  77.              ctlpt( E3,  0.21, 0.0, -0.64 ),
  78.              ctlpt( E3,  0.18, 0.0, -0.67),
  79.              ctlpt( E3,  0.0,  0.0, -0.66 ) ),
  80.            list( KV_OPEN ) );
  81. Srf2 = surfrev( bcross );
  82. free( bcross );
  83. color( Srf2, green );
  84.  
  85. #
  86. # Must make them compatible before doing some morphing.
  87. #
  88. ffcompat( Srf1, Srf2 );
  89.  
  90. #
  91. # Since we would like the animation to look as good as possible we need
  92. # to precompute as much as possible before invoking view to erase old
  93. # drawing and display new one. That is why we precompute isolines.
  94. #
  95.  
  96. for ( i = 0, step, 1.0,
  97.     view( smorph( Srf1, Srf2, i ), true )
  98. );
  99.  
  100. #
  101. # Now dump 12 steps in this morphing sequence as 12 distinct files.
  102. #
  103. for ( i = 0.0, 1.0, 11.0,
  104.     Msrf = smorph( Srf1, Srf2, i / 11.0 ):
  105.     color( Msrf, white ):
  106.     attrib( Msrf, "rgb", "255,255,255" ):
  107.     attrib( Msrf, "reflect", 1.0 ):
  108.     attrib( Msrf, "transp", 0.95 ):
  109.     attrib( Msrf, "index", 1.4 ):
  110.     save( "morp1-" + i, list( Msrf, Backgrd ) )
  111. );
  112.  
  113. #############################################################################
  114. # Second Morphing Sequence.                            #
  115. #############################################################################
  116.  
  117. bcross = cbspline( 3,
  118.            list( ctlpt( E3,  0.0,  0.0, -0.71 ),
  119.                  ctlpt( E3,  0.2,  0.0, -0.72 ),
  120.                  ctlpt( E3,  0.25, 0.0, -0.7 ),
  121.                  ctlpt( E3,  0.25, 0.0, -0.1 ),
  122.                  ctlpt( E3,  0.2,  0.0, -0.05 ),
  123.                  ctlpt( E3,  0.15, 0.0,  0.0 ),
  124.                  ctlpt( E3,  0.1,  0.0,  0.6 ),
  125.              ctlpt( E3,  0.11, 0.0,  0.61 ),
  126.              ctlpt( E3,  0.12, 0.0,  0.61 ),
  127.              ctlpt( E3,  0.12, 0.0,  0.65 ),
  128.              ctlpt( E3,  0.09, 0.0,  0.65 ),
  129.              ctlpt( E3,  0.07, 0.0,  0.64 ),
  130.              ctlpt( E3,  0.10, 0.0, -0.05 ),
  131.              ctlpt( E3,  0.21, 0.0, -0.1 ),
  132.              ctlpt( E3,  0.21, 0.0, -0.64 ),
  133.              ctlpt( E3,  0.18, 0.0, -0.67),
  134.              ctlpt( E3,  0.0,  0.0, -0.66 ) ),
  135.            list( KV_OPEN ) );
  136. Srf2 = surfrev( bcross );
  137. free( bcross );
  138. color( Srf2, green );
  139.  
  140. gcross = cbspline( 3,
  141.            list( ctlpt( E3, 0.001, 0.0, 0.02 ),
  142.                ctlpt( E3, 0.2,   0.0, 0.02 ),
  143.              ctlpt( E3, 0.22,  0.0, 0. ),
  144.              ctlpt( E3, 0.22,  0.0, 0.03 ),
  145.              ctlpt( E3, 0.03,  0.0, 0.03 ),
  146.              ctlpt( E3, 0.03,  0.0, 0.07 ),
  147.              ctlpt( E3, 0.04,  0.0, 0.3 ),
  148.              ctlpt( E3, 0.3,   0.0, 0.3 ),
  149.              ctlpt( E3, 0.4,   0.0, 0.4 ),
  150.              ctlpt( E3, 0.3,   0.0, 0.7 ),
  151.              ctlpt( E3, 0.28,  0.0, 0.7 ),
  152.              ctlpt( E3, 0.37,  0.0, 0.42 ),
  153.              ctlpt( E3, 0.31,  0.0, 0.32 ),
  154.              ctlpt( E3, 0.001, 0.0, 0.32 ) ),
  155.            list( KV_OPEN ) );
  156. Srf3 = surfrev( gcross * trans( vector( 0.0, 0.0, -0.45 ) ) *
  157.              scale( vector( 1.6, 1.6, 1.6 ) ) );
  158. free( gcross );
  159. color( Srf3, cyan );
  160.  
  161. #
  162. # Must make them compatible before doing some morphing.
  163. #
  164. ffcompat( Srf2, Srf3 );
  165.  
  166. for ( i = 0, step, 1.0,
  167.     view( smorph( Srf2, Srf3, i ), true )
  168. );
  169.  
  170. #
  171. # Now dump 12 steps in this morphing sequence as 12 distinct files.
  172. #
  173.  
  174. for ( i = 0.0, 1.0, 11.0,
  175.     Msrf = smorph( Srf2, Srf3, i / 11.0 ):
  176.     color( Msrf, white ):
  177.     attrib( Msrf, "rgb", "255,255,255" ):
  178.     attrib( Msrf, "reflect", 1.0 ):
  179.     attrib( Msrf, "transp", 0.95 ):
  180.     attrib( Msrf, "index", 1.4 ):
  181.     save( "morp2-" + i, list( Msrf, Backgrd ) )
  182. );
  183.  
  184. #############################################################################
  185. # Third Morphing Sequence.                            #
  186. #############################################################################
  187.  
  188. gcross = cbspline( 3,
  189.            list( ctlpt( E3, 0.001, 0.0, 0.02 ),
  190.                ctlpt( E3, 0.2,   0.0, 0.02 ),
  191.              ctlpt( E3, 0.22,  0.0, 0. ),
  192.              ctlpt( E3, 0.22,  0.0, 0.03 ),
  193.              ctlpt( E3, 0.03,  0.0, 0.03 ),
  194.              ctlpt( E3, 0.03,  0.0, 0.07 ),
  195.              ctlpt( E3, 0.04,  0.0, 0.3 ),
  196.              ctlpt( E3, 0.3,   0.0, 0.3 ),
  197.              ctlpt( E3, 0.4,   0.0, 0.4 ),
  198.              ctlpt( E3, 0.3,   0.0, 0.7 ),
  199.              ctlpt( E3, 0.28,  0.0, 0.7 ),
  200.              ctlpt( E3, 0.37,  0.0, 0.42 ),
  201.              ctlpt( E3, 0.31,  0.0, 0.32 ),
  202.              ctlpt( E3, 0.001, 0.0, 0.32 ) ),
  203.         list( KV_OPEN ) );
  204. Srf3 = surfrev( gcross * trans( vector( 0.0, 0.0, -0.45 ) ) *
  205.              scale( vector( 1.6, 1.6, 1.6 ) ) );
  206. free( gcross );
  207. color( Srf3, cyan );
  208.  
  209. s45 = sin( pi / 4 );
  210. HelixAux = cbspline( 3,
  211.              list( ctlpt( P3, 1, 1, 0, 0 ),
  212.                ctlpt( P3, s45, s45, s45, 0.2 * s45 ),
  213.                ctlpt( P3, 1, 0, 1, 0.4 ),
  214.                ctlpt( P3, s45, -s45, s45, 0.6 * s45 ),
  215.                ctlpt( P3, 1, -1, 0, 0.8 ),
  216.                ctlpt( P3, s45, -s45, -s45, 1.0 * s45 ),
  217.                ctlpt( P3, 1, 0, -1, 1.2 ),
  218.                ctlpt( P3, s45, s45, -s45, 1.4 * s45 ),
  219.                ctlpt( P3, 1, 1, 0, 1.6 ) ),
  220.              list( 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 4 ) );
  221. HelixApx = HelixAux +
  222.        HelixAux * trans( vector( 0.0, 0.0, 1.6 ) ) +
  223.        HelixAux * trans( vector( 0.0, 0.0, 3.2 ) );
  224.  
  225. ScaleCrv = cbezier( list( ctlpt( E2, 0.0, 0.01 ),
  226.               ctlpt( E2, 1.0, 1.0 ) ) );
  227.  
  228. Srf4 = swpsclsrf( circle( vector( 0.0, 0.0, 0.0 ), 0.8 ), HelixApx, ScaleCrv,
  229.          off, 0 ) *
  230.     scale( vector( 0.2, 0.2, 0.2 ) ) *
  231.     trans( vector( 0.0, 0.0, FloorLvl ) );
  232.  
  233. free( HelixAux );
  234. free( HelixApx );
  235. free( ScaleCrv );
  236. color( Srf4, magenta );
  237.  
  238. #
  239. # Must make them compatible before doing some morphing.
  240. #
  241. ffcompat( Srf3, Srf4 );
  242.  
  243. for ( i = 0, step, 1.0,
  244.     view( smorph( Srf3, Srf4, i ), true )
  245. );
  246.  
  247. #
  248. # Now dump 12 steps in this morphing sequence as 12 distinct files.
  249. #
  250.  
  251. for ( i = 0.0, 1.0, 11.0,
  252.     Msrf = smorph( Srf3, Srf4, i / 11.0 ):
  253.     color( Msrf, white ):
  254.     attrib( Msrf, "rgb", "255,255,255" ):
  255.     attrib( Msrf, "reflect", 1.0 ):
  256.     attrib( Msrf, "transp", 0.95 ):
  257.     attrib( Msrf, "index", 1.4 ):
  258.     save( "morp3-" + i, list( Msrf, Backgrd ) )
  259. );
  260.  
  261. #############################################################################
  262. # Fourth Morphing Sequence.                            #
  263. #############################################################################
  264.  
  265. s45 = sin( pi / 4 );
  266. HelixAux = cbspline( 3,
  267.              list( ctlpt( P3, 1, 1, 0, 0 ),
  268.                ctlpt( P3, s45, s45, s45, 0.2 * s45 ),
  269.                ctlpt( P3, 1, 0, 1, 0.4 ),
  270.                ctlpt( P3, s45, -s45, s45, 0.6 * s45 ),
  271.                ctlpt( P3, 1, -1, 0, 0.8 ),
  272.                ctlpt( P3, s45, -s45, -s45, 1.0 * s45 ),
  273.                ctlpt( P3, 1, 0, -1, 1.2 ),
  274.                ctlpt( P3, s45, s45, -s45, 1.4 * s45 ),
  275.                ctlpt( P3, 1, 1, 0, 1.6 ) ),
  276.              list( 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 4 ) );
  277. HelixApx = HelixAux +
  278.        HelixAux * trans( vector( 0.0, 0.0, 1.6 ) ) +
  279.        HelixAux * trans( vector( 0.0, 0.0, 3.2 ) );
  280.  
  281. ScaleCrv = cbezier( list( ctlpt( E2, 0.0, 0.01 ),
  282.               ctlpt( E2, 1.0, 1.0 ) ) );
  283.  
  284. Srf4 = swpsclsrf( circle( vector( 0.0, 0.0, 0.0 ), 0.8 ), HelixApx, ScaleCrv,
  285.          off, 0 ) *
  286.     scale( vector( 0.2, 0.2, 0.2 ) ) *
  287.     trans( vector( 0.0, 0.0, FloorLvl ) );
  288.  
  289. free( HelixAux );
  290. free( HelixApx );
  291. free( ScaleCrv );
  292. color( Srf4, magenta );
  293.  
  294. Srf1 = ruledsrf( circle( vector( 0.0, 0.0, FloorLvl + 0.01 ), 1.0 ),
  295.          circle( vector( 0.0, 0.0, FloorLvl + 0.01 ), 0.01 ) );
  296. color( Srf1, yellow );
  297.  
  298. #
  299. # Must make them compatible before doing some morphing.
  300. #
  301. ffcompat( Srf4, Srf1 );
  302.  
  303. #
  304. # Since we would like the animation to look as good as possible we need
  305. # to precompute as much as possible before invoking view to erase old
  306. # drawing and display new one. That is why we precompute isolines.
  307. #
  308. for ( i = 0, step, 1.0,
  309.     view( smorph( Srf4, Srf1, i ), true )
  310. );
  311.  
  312. #
  313. # Now dump 12 steps in this morphing sequence as 12 distinct files.
  314. #
  315. for ( i = 0.0, 1.0, 11.0,
  316.     Msrf = smorph( Srf4, Srf1, i / 11.0 ):
  317.     color( Msrf, white ):
  318.     attrib( Msrf, "rgb", "255,255,255" ):
  319.     attrib( Msrf, "reflect", 1.0 ):
  320.     attrib( Msrf, "transp", 0.95 ):
  321.     attrib( Msrf, "index", 1.4 ):
  322.     save( "morp4-" + i, list( Msrf, Backgrd ) )
  323. );
  324.  
  325. free(Msrf);
  326. free(Srf1);
  327. free(Srf2);
  328. free(Srf3);
  329. free(Srf4);
  330.  
  331. resolution = save_res;
  332.  
  333.