home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / graphics / fractals / amountains / amountains.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-11-20  |  12.4 KB  |  571 lines
  1. #include <workbench/workbench.h>
  2. #include <workbench/startup.h>
  3.  
  4. #include <proto/exec.h>
  5. #include <proto/dos.h>
  6. #include <proto/icon.h>
  7.  
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #include <stdio.h>
  11. #include <m68881.h>
  12. #include <math.h>
  13. #include <signal.h>
  14. #include <time.h>
  15.  
  16. #include <DoArgs.h>
  17.  
  18. #include "crinkle.h"
  19. #include "paint.h"
  20. #include "global.h"
  21. #include "patchlevel.h"
  22.  
  23. #define VERSION 2
  24. #define SIDE 1.0
  25.  
  26. #ifndef FALSE
  27. #define FALSE 0
  28. #endif
  29.  
  30. #ifndef TRUE
  31. #define TRUE (!FALSE)
  32. #endif
  33.  
  34. /* -------------------------------------------------------------------- */
  35. /* update strips                                                        */
  36. /* -------------------------------------------------------------------- */
  37.  
  38. Col *next_col( int paint, int reflec )
  39. {
  40.     Col    *res;
  41.     int    i, offset = 0;
  42.   
  43.     if ( paint ) {
  44.         if( reflec ) {
  45.             res = mirror( a_strip, b_strip, shadow );
  46.         }
  47.         else {
  48.             res = camera( a_strip, b_strip, shadow );
  49.         }
  50.     }
  51.     else {
  52.         res = makemap( a_strip, b_strip, shadow );
  53.     }
  54.     free( a_strip );
  55.     a_strip = b_strip;
  56.     b_strip = extract( next_strip( top ) );
  57.  
  58.     /* ---------------------------------------------------------------- */
  59.     /* update the shadows                                                */
  60.     /* shadow_slip is the Y component of the light vector.                */
  61.     /* The shadows can only step an integer number of points in the Y    */
  62.     /* direction so we maintain shadow_register as the deviation        */
  63.     /* between where the shadows are and where they should be. When the    */
  64.     /*  magnitude of this gets larger then 1 the shadows are slipped by    */
  65.     /*  the required number of points.                                    */
  66.     /* This will not work for very oblique angles so the horizontal        */
  67.     /* angle of illumination should be constrained.                        */
  68.     /* ---------------------------------------------------------------- */
  69.  
  70.     shadow_register += shadow_slip;
  71.     if ( shadow_register >= 1.0 ) {
  72.  
  73.         /* ------------------------------------------------------------ */
  74.         /* negative offset                                                */
  75.         /* ------------------------------------------------------------ */
  76.  
  77.         while ( shadow_register >= 1.0 ) {
  78.             shadow_register -= 1.0;
  79.             offset++;
  80.         }
  81.         for ( i = width - 1; i >= offset; i-- ) {
  82.             shadow[i] = shadow[i-offset] - delta_shadow;
  83.             if ( shadow[i] < b_strip[i] ) {
  84.                 shadow[i] = b_strip[i];
  85.             }
  86.  
  87.             /* -------------------------------------------------------- */
  88.             /* stop shadow at sea level                                    */
  89.             /* -------------------------------------------------------- */
  90.  
  91.             if ( shadow[i] < sealevel ) {
  92.                 shadow[i] = sealevel;
  93.             }
  94.         }
  95.  
  96.         for ( i = 0; i < offset; i++ ) {
  97.             shadow[i] = b_strip[i];
  98.  
  99.             /* -------------------------------------------------------- */
  100.             /* stop shadow at sea level                                    */
  101.             /* -------------------------------------------------------- */
  102.  
  103.             if ( shadow[i] < sealevel ) {
  104.                 shadow[i] = sealevel;
  105.             }
  106.         }
  107.     }
  108.     else if ( shadow_register <= -1.0 ) {
  109.  
  110.         /* ------------------------------------------------------------ */
  111.         /* positive offset                                                */
  112.         /* ------------------------------------------------------------ */
  113.  
  114.         while ( shadow_register <= -1.0 ) {
  115.             shadow_register += 1.0;
  116.             offset++;
  117.         }
  118.         for ( i = 0; i < width - offset; i++ ) {
  119.             shadow[i] = shadow[i+offset] - delta_shadow;
  120.             if ( shadow[i] < b_strip[i] ) {
  121.                 shadow[i] = b_strip[i];
  122.             }
  123.  
  124.             /* -------------------------------------------------------- */
  125.             /* stop shadow at sea level                                    */
  126.             /* -------------------------------------------------------- */
  127.  
  128.             if ( shadow[i] < sealevel ) {
  129.                 shadow[i] = sealevel;
  130.             }
  131.         }
  132.         for( ; i < width; i++ ) {
  133.             shadow[i] = b_strip[i];
  134.  
  135.             /* -------------------------------------------------------- */
  136.             /* stop shadow at sea level                                    */
  137.             /* -------------------------------------------------------- */
  138.  
  139.             if ( shadow[i] < sealevel ) {
  140.                 shadow[i] = sealevel;
  141.             }
  142.         }
  143.     }
  144.     else {
  145.  
  146.         /* ------------------------------------------------------------ */
  147.         /* no offset                                                    */
  148.         /* ------------------------------------------------------------ */
  149.  
  150.         for ( i = 0; i < width; i++ ) {
  151.             shadow[i] -= delta_shadow;
  152.             if ( shadow[i] < b_strip[i] ) {
  153.                 shadow[i] = b_strip[i];
  154.             }
  155.  
  156.             /* -------------------------------------------------------- */
  157.             /* stop shadow at sea level                                    */
  158.             /* -------------------------------------------------------- */
  159.  
  160.             if ( shadow[i] < sealevel ) {
  161.                 shadow[i] = sealevel;
  162.             }
  163.         }
  164.     }
  165.     return res;
  166. }
  167.  
  168. void init_graphics( int, int *, int *, int, Gun *, Gun *, Gun *, char *, ULONG, char * );
  169. void finish_graphics( void );
  170. void plot_pixel(int, int, unsigned char );
  171. void scroll_screen( int );
  172. void zap_events( int );
  173. void finish_prog( int );
  174.  
  175. int        s_height,
  176.         s_width,
  177.         mapwid;
  178.  
  179. void plot_column( int p, int map, int reflec, int snooze )
  180. {
  181.     Col    *l;
  182.     int    j;
  183.   
  184.     l = next_col( 1 - map, reflec ); 
  185.     if ( map ) {
  186.         for ( j = 0; j < s_height - mapwid; j++ ) {
  187.             plot_pixel( p, s_height - 1 - j, BLACK );
  188.         }
  189.         for ( j = 0; j < mapwid; j++ ) {
  190.             plot_pixel( p, mapwid - 1 - j, l[j] );
  191.         }
  192.     }
  193.     else {
  194.         for ( j = 0; j < height; j++ ) {
  195.  
  196.             /* -------------------------------------------------------- */
  197.             /* we assume that the scroll routine fills the new region    */
  198.             /* with a SKY value. This allows us to use a textured sky    */
  199.             /* for B/W displays                                            */
  200.             /* -------------------------------------------------------- */
  201.  
  202.             if ( l[j] != SKY ) {
  203.                 plot_pixel( p, s_height - 1 - j, l[j] );
  204.             }
  205.         }
  206.     }
  207.     free( l );
  208.     zap_events( snooze );
  209. }
  210.  
  211. extern LONG activepri, inactivepri;
  212.  
  213. static char *pubscreen, *displaymode;
  214. static ULONG depth;
  215.  
  216. void main( int argc, char **argv )
  217. {
  218.     int        i, p;
  219.     int        repeat;
  220.     int        map;
  221.     int        reflec;
  222.     int        root;
  223.  
  224.     Gun        *clut[3];
  225.     DAKey    *dak;
  226.  
  227.     double    minv_phi        =    0.0,
  228.             maxv_phi        =  180.0 / 180.0 * PI,
  229.             def_phi            =   40.0 / 180.0 * PI,
  230.             minv_alpha        =  -60.0 / 180.0 * PI,
  231.             maxv_alpha        =   60.0 / 180.0 * PI,
  232.             def_alpha        =    0.0,
  233.             def_stretch        =    0.6,
  234.             def_shift        =    0.5,
  235.             def_sealevel    =    0.0,
  236.             def_forceheight    =    -1.0,
  237.             def_contour        =    0.3,
  238.             def_altitude    =    2.5,
  239.             def_distance    =    4.0,
  240.             minv_contrast    =    0.0,
  241.             def_contrast    =    1.0,
  242.             minv_ambient    =    0.0,
  243.             maxv_ambient    =    1.0,
  244.             def_ambient        =    0.3,
  245.             minv_vfract        =    0.0,
  246.             def_vfract        =    0.6,
  247.             minv_fdim        =    0.5,
  248.             maxv_fdim        =    1.0,
  249.             def_fdim        =    0.65,
  250.             def_mix            =    0.0,
  251.             def_midmix        =    0.0;
  252.  
  253.     BOOL    passed_n_col        = FALSE,
  254.             passed_band_size    = FALSE;
  255.  
  256.     /* ---------------------------------------------------------------- */
  257.     /* handle command line/tool type arguents                            */
  258.     /* ---------------------------------------------------------------- */
  259.  
  260.     dak = DoArgs( argc, argv,
  261.  
  262.         DA_TTIconName,        argc ? argv[0] : ((struct WBStartup *) argv)->sm_ArgList[0].wa_Name,
  263.  
  264.         DA_Name,            "BACKDROP",
  265.         DA_Type,            DAT_BOOL,
  266.         DA_Result,            &root,
  267.         TAG_DONE,
  268.  
  269.         DA_Name,            "WIDTH",
  270.         DA_Type,            DAT_UNSIGNED,
  271.         DA_Minval,            40,
  272.         DA_Default,            320,
  273.         DA_Result,            &s_width,
  274.         TAG_DONE,
  275.  
  276.         DA_Name,            "HEIGHT",
  277.         DA_Type,            DAT_UNSIGNED,
  278.         DA_Minval,            40,
  279.         DA_Default,            240,
  280.         DA_Result,            &s_height,
  281.         TAG_DONE,
  282.  
  283.         DA_Name,            "PUBSCREEN",
  284.         DA_Type,            DAT_STRING,
  285.         DA_Default,            "Workbench",
  286.         DA_Result,            &pubscreen,
  287.         DA_ProvideMem,        TRUE,
  288.         TAG_DONE,
  289.  
  290.         DA_Name,            "DISPLAYMODE",
  291.         DA_Type,            DAT_STRING,
  292.         DA_Result,            &displaymode,
  293.         DA_ProvideMem,        TRUE,
  294.         TAG_DONE,
  295.  
  296.         DA_Name,            "DEPTH",
  297.         DA_Type,            DAT_UNSIGNED,
  298.         DA_Default,            0,
  299.         DA_Result,            &depth,
  300.         TAG_DONE,
  301.  
  302.         DA_Name,            "MAP",
  303.         DA_Type,            DAT_BOOL,
  304.         DA_Result,            &map,
  305.         TAG_DONE,
  306.  
  307.         DA_Name,            "REFLECTIONS",
  308.         DA_Type,            DAT_BOOL,
  309.         DA_Result,            &reflec,
  310.         TAG_DONE,
  311.  
  312.         DA_Name,            "SCROLLCOLUMNS",
  313.         DA_Type,            DAT_UNSIGNED,
  314.         DA_Minval,            2,
  315.         DA_Default,            20,
  316.         DA_Result,            &repeat,
  317.         TAG_DONE,
  318.  
  319.         DA_Name,            "BANDSIZE",
  320.         DA_Type,            DAT_UNSIGNED,
  321.         DA_Minval,            2,
  322.         DA_Result,            &band_size,
  323.         DA_Passed,            &passed_band_size,
  324.         TAG_DONE,
  325.  
  326.         DA_Name,            "COLOURS",
  327.         DA_Type,            DAT_UNSIGNED,
  328.         DA_Minval,            MIN_COL,
  329.         DA_Result,            &n_col,
  330.         DA_Passed,            &passed_n_col,
  331.         TAG_DONE,
  332.  
  333.         DA_Name,            "SLEEP",
  334.         DA_Type,            DAT_UNSIGNED,
  335.         DA_Result,            &snooze_time,
  336.         DA_Default,            0,
  337.         TAG_DONE,
  338.  
  339.         DA_Name,            "VLIGHTANGLE",
  340.         DA_Type,            DAT_ANGLE,
  341.         DA_Minval,            &minv_phi,
  342.         DA_Maxval,            &maxv_phi,
  343.         DA_Default,            &def_phi,
  344.         DA_Result,            &phi,
  345.         TAG_DONE,
  346.  
  347.         DA_Name,            "HLIGHTANGLE",
  348.         DA_Type,            DAT_ANGLE,
  349.         DA_Minval,            &minv_alpha,
  350.         DA_Maxval,            &maxv_alpha,
  351.         DA_Default,            &def_alpha,
  352.         DA_Result,            &alpha,
  353.         TAG_DONE,
  354.  
  355.         DA_Name,            "VSTRETCH",
  356.         DA_Type,            DAT_DOUBLE,
  357.         DA_Default,            &def_stretch,
  358.         DA_Result,            &stretch,
  359.         TAG_DONE,
  360.  
  361.         DA_Name,            "VSHIFT",
  362.         DA_Type,            DAT_DOUBLE,
  363.         DA_Default,            &def_shift,
  364.         DA_Result,            &shift,
  365.         TAG_DONE,
  366.  
  367.         DA_Name,            "SEALEVEL",
  368.         DA_Type,            DAT_DOUBLE,
  369.         DA_Default,            &def_sealevel,
  370.         DA_Result,            &sealevel,
  371.         TAG_DONE,
  372.  
  373.         DA_Name,            "SLOPE",
  374.         DA_Type,            DAT_UNSIGNED,
  375.         DA_Minval,            2,
  376.         DA_Default,            2,
  377.         DA_Result,            &slope,
  378.         TAG_DONE,
  379.  
  380.         DA_Name,            "FORCEHEIGHT",
  381.         DA_Type,            DAT_DOUBLE,
  382.         DA_Default,            &def_forceheight,
  383.         DA_Result,            &forceheight,
  384.         TAG_DONE,
  385.  
  386.         DA_Name,            "CONTOUR",
  387.         DA_Type,            DAT_DOUBLE,
  388.         DA_Default,            &def_contour,
  389.         DA_Result,            &contour,
  390.         TAG_DONE,
  391.  
  392.         DA_Name,            "ALTITUDE",
  393.         DA_Type,            DAT_DOUBLE,
  394.         DA_Default,            &def_altitude,
  395.         DA_Result,            &altitude,
  396.         TAG_DONE,
  397.  
  398.         DA_Name,            "DISTANCE",
  399.         DA_Type,            DAT_DOUBLE,
  400.         DA_Default,            &def_distance,
  401.         DA_Result,            &distance,
  402.         TAG_DONE,
  403.  
  404.         DA_Name,            "CONTRAST",
  405.         DA_Type,            DAT_DOUBLE,
  406.         DA_Minval,            &minv_contrast,
  407.         DA_Default,            &def_contrast,
  408.         DA_Result,            &contrast,
  409.         TAG_DONE,
  410.  
  411.         DA_Name,            "AMBIENT",
  412.         DA_Type,            DAT_DOUBLE,
  413.         DA_Minval,            &minv_ambient,
  414.         DA_Maxval,            &maxv_ambient,
  415.         DA_Default,            &def_ambient,
  416.         DA_Result,            &ambient,
  417.         TAG_DONE,
  418.  
  419.         DA_Name,            "VFRACT",
  420.         DA_Type,            DAT_DOUBLE,
  421.         DA_Minval,            &minv_vfract,
  422.         DA_Default,            &def_vfract,
  423.         DA_Result,            &vfract,
  424.         TAG_DONE,
  425.  
  426.         DA_Name,            "FDIM",
  427.         DA_Type,            DAT_DOUBLE,
  428.         DA_Minval,            &minv_fdim,
  429.         DA_Maxval,            &maxv_fdim,
  430.         DA_Default,            &def_fdim,
  431.         DA_Result,            &fdim,
  432.         TAG_DONE,
  433.  
  434.         DA_Name,            "SEED",
  435.         DA_Type,            DAT_INTEGER,
  436.         DA_Default,            0,
  437.         DA_Result,            &seed,
  438.         TAG_DONE,
  439.  
  440.         DA_Name,            "LEVELS",
  441.         DA_Type,            DAT_UNSIGNED,
  442.         DA_Minval,            2,
  443.         DA_Default,            10,
  444.         DA_Result,            &levels,
  445.         TAG_DONE,
  446.  
  447.         DA_Name,            "CROSS",
  448.         DA_Type,            DAT_BOOL,
  449.         DA_Result,            &cross,
  450.         TAG_DONE,
  451.  
  452.         DA_Name,            "SMOOTH",
  453.         DA_Type,            DAT_UNSIGNED,
  454.         DA_Default,            1,
  455.         DA_Result,            &smooth,
  456.         TAG_DONE,
  457.  
  458.         DA_Name,            "MIX",
  459.         DA_Type,            DAT_DOUBLE,
  460.         DA_Default,            &def_mix,
  461.         DA_Result,            &mix,
  462.         TAG_DONE,
  463.  
  464.         DA_Name,            "MIDMIX",
  465.         DA_Type,            DAT_DOUBLE,
  466.         DA_Default,            &def_midmix,
  467.         DA_Result,            &midmix,
  468.         TAG_DONE,
  469.  
  470.         DA_Name,            "STOP",
  471.         DA_Type,            DAT_UNSIGNED,
  472.         DA_Default,            2,
  473.         DA_Result,            &stop,
  474.         TAG_DONE,
  475.  
  476.         DA_Name,            "ACTIVEPRI",
  477.         DA_Type,            DAT_INTEGER,
  478.         DA_Minval,            -127,
  479.         DA_Maxval,            128,
  480.         DA_Default,            0,
  481.         DA_Result,            &activepri,
  482.         TAG_DONE,
  483.  
  484.         DA_Name,            "INACTIVEPRI",
  485.         DA_Type,            DAT_INTEGER,
  486.         DA_Minval,            -127,
  487.         DA_Maxval,            128,
  488.         DA_Default,            -25,
  489.         DA_Result,            &inactivepri,
  490.         TAG_DONE,
  491.  
  492.         TAG_DONE
  493.     );
  494.  
  495.     if ( dak ) {
  496.         if ( passed_n_col ) {
  497.             band_size = ( n_col - BAND_BASE ) / N_BANDS;
  498.         }
  499.         else if ( passed_band_size ) {
  500.             n_col = BAND_BASE + N_BANDS * band_size;
  501.         }
  502.         else {
  503.             band_size = BAND_SIZE;
  504.             n_col     = BAND_BASE + N_BANDS * BAND_SIZE;
  505.         }
  506.  
  507.         if ( repeat & 1 ) repeat++;
  508.     }    
  509.     else {
  510.         PutStr( "Error: Cannot allocate argument array!\n" );
  511.         exit( 5 );
  512.     }
  513.  
  514.     for ( i = 0; i < 3; i++ ) {
  515.         clut[i] = (Gun *) malloc( n_col * sizeof(Gun) );
  516.         if( ! clut[i] ) {
  517.             PutStr( "malloc failed for clut\n" );
  518.             exit( 1 );
  519.         }
  520.     }
  521.     set_clut( n_col, clut[0], clut[1], clut[2] );
  522.     init_graphics( root, &s_width, &s_height, n_col, clut[0], clut[1], clut[2], displaymode, depth, pubscreen );
  523.     for ( i = 0; i < 3; i++ ) {
  524.         free( clut[i] );
  525.     }
  526.  
  527.     height = s_height;
  528.     
  529.     srand48( seed ? seed : time( NULL ) );
  530.  
  531.     init_artist_variables();
  532.  
  533.     if ( s_height > width ) {
  534.         mapwid = width;
  535.     }
  536.     else {
  537.         mapwid = s_height;
  538.     }
  539.     if ( repeat > 0 ) {
  540.         for ( p = 0; p < s_width; p++ ) {
  541.             plot_column( p, map, reflec, 0 );
  542.         }
  543.     }
  544.     else {
  545.         for ( p = s_width - 1; p >= 0; p-- ) {
  546.             plot_column( p, map, reflec, 0 );
  547.         }
  548.     }
  549.     while ( TRUE ) {
  550.  
  551.         /* ------------------------------------------------------------ */
  552.         /* do the scroll                                                */
  553.         /* ------------------------------------------------------------ */
  554.  
  555.         scroll_screen( repeat );
  556.         if( repeat > 0) {
  557.             for ( p = s_width - repeat; p < s_width - 1; p++ ) {
  558.                 plot_column( p, map, reflec, 0 );
  559.             }
  560.         }
  561.         else {
  562.             for ( p = -1 - repeat; p >= 0; p-- ) {
  563.                 plot_column( p, map, reflec, 0 );
  564.             }
  565.         }
  566.         plot_column( p, map, reflec, snooze_time );
  567.     }
  568.  
  569.     FreeDAKey( dak );
  570. }
  571.