home *** CD-ROM | disk | FTP | other *** search
/ Fractal Creations (Second Edition) / FRACTALS_2E.iso / frasrc.exe / JB.C < prev    next >
C/C++ Source or Header  |  1993-05-08  |  12KB  |  476 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include "fractint.h"
  4. #include "mpmath.h"
  5. #include "helpdefs.h"
  6. #include "prototyp.h"
  7. #include "fractype.h"
  8.  
  9. extern int savedac;
  10. extern int c_exp;
  11. extern int debugflag;
  12. extern int maxit;
  13. extern int num_fractal_types;
  14. extern struct fractalspecificstuff far fractalspecific[];
  15. extern int row, col, xdots, ydots, bitshift, fractype;
  16. extern int ixstart, ixstop, iystart, iystop, colors, helpmode;
  17. extern double param[], xxmin, xxmax, yymin, yymax;
  18. extern long delx, dely, ltempsqrx, ltempsqry, far * lx0, far * ly0;
  19. extern double tempsqrx, tempsqry, qc, qci, qcj, qck;
  20. extern _LCMPLX lold, lnew, *longparm;
  21. extern _CMPLX old, new, *floatparm;
  22. extern llimit2;
  23.  
  24. /* these need to be accessed elsewhere for saving data */
  25. double mxminfp = -.83;
  26. double myminfp = -.25;
  27. double mxmaxfp = -.83;
  28. double mymaxfp =  .25;
  29.  
  30. static long mxmin, mymin;
  31. static long x_per_inch, y_per_inch, inch_per_xdot, inch_per_ydot;
  32. static double x_per_inchfp, y_per_inchfp, inch_per_xdotfp, inch_per_ydotfp;
  33. static int bbase;
  34. static long xpixel, ypixel;
  35. static double xpixelfp, ypixelfp;
  36. static long initz, djx, djy, dmx, dmy;
  37. static double initzfp, djxfp, djyfp, dmxfp, dmyfp;
  38. static long jx, jy, mx, my, xoffset, yoffset;
  39. static double jxfp, jyfp, mxfp, myfp, xoffsetfp, yoffsetfp;
  40.  
  41. struct Perspective
  42. {
  43.    long x, y, zx, zy;
  44. };
  45.  
  46. struct Perspectivefp
  47. {
  48.    double x, y, zx, zy;
  49. };
  50.  
  51. struct Perspective LeftEye, RightEye, *Per;
  52. struct Perspectivefp LeftEyefp, RightEyefp, *Perfp;
  53.  
  54. _LCMPLX jbc;
  55. _CMPLX jbcfp;
  56.  
  57. extern char Glasses1Map[];
  58. extern char GreyFile[];
  59.  
  60. static double fg, fg16;
  61. int zdots = 128;
  62.  
  63. double originfp = 8, heightfp = 7, widthfp = 10, distfp = 24, eyesfp = 2.5, depthfp = 8, brratiofp = 1;
  64. static long width, dist, eyes, depth, brratio;
  65.  
  66. int juli3Dmode = 0;
  67.  
  68. int lastorbittype = -1;
  69. int neworbittype = JULIA;
  70.  
  71. int
  72. JulibrotSetup(void)
  73. {
  74.    long origin, height;
  75.    int numparams;
  76.    struct fractalspecificstuff far *oldcurfractalspecific;
  77.    int oldfractype;
  78.    int i;
  79.    int r;
  80.    int oldhelpmode;
  81.    char *mapname;
  82.  
  83. #ifndef XFRACT
  84.    if (colors < 255)
  85.    {
  86.       static char far msg[] =
  87.       {"Sorry, but Julibrots require a 256-color video mode"};
  88.       stopmsg(0, msg);
  89.       return (0);
  90.    }
  91. #endif
  92.  
  93.    stackscreen();
  94.    oldhelpmode = helpmode;
  95.    helpmode = HT_JULIBROT;
  96.    xoffsetfp = (xxmax + xxmin) / 2;     /* Calculate average */
  97.    yoffsetfp = (yymax + yymin) / 2;     /* Calculate average */
  98.    dmxfp = (mxmaxfp - mxminfp) / zdots;
  99.    dmyfp = (mymaxfp - myminfp) / zdots;
  100.    floatparm = &jbcfp;
  101.  
  102.  
  103.    x_per_inchfp = (xxmin - xxmax) / widthfp;
  104.    y_per_inchfp = (yymax - yymin) / heightfp;
  105.    inch_per_xdotfp = widthfp / xdots;
  106.    inch_per_ydotfp = heightfp / ydots;
  107.  
  108.    initzfp = originfp - (depthfp / 2);
  109.    if(juli3Dmode == 0)
  110.       RightEyefp.x = 0.0;
  111.    else
  112.       RightEyefp.x = eyesfp / 2;
  113.    LeftEyefp.x = -RightEyefp.x;
  114.    LeftEyefp.y = RightEyefp.y = 0;
  115.    LeftEyefp.zx = RightEyefp.zx = distfp;
  116.    LeftEyefp.zy = RightEyefp.zy = distfp;
  117.    bbase = 128;
  118.    oldcurfractalspecific = curfractalspecific;
  119.    oldfractype = fractype;
  120.    fractype = neworbittype;
  121.    curfractalspecific = &fractalspecific[fractype];
  122.    lastorbittype = neworbittype;
  123.    curfractalspecific = oldcurfractalspecific;
  124.    fractype = oldfractype;
  125. #ifndef XFRACT
  126.    if (fractalspecific[fractype].isinteger > 0)
  127.    {
  128.       long jxmin, jxmax, jymin, jymax, mxmax, mymax;
  129.       if (fractalspecific[neworbittype].isinteger == 0)
  130.       {
  131.          char msg[80];
  132.          sprintf(msg, "Julibrot orbit type isinteger mismatch");
  133.          stopmsg(0, msg);
  134.       }
  135.       if (fractalspecific[neworbittype].isinteger > 1)
  136.          bitshift = fractalspecific[neworbittype].isinteger;
  137.       fg = (double) (1L << bitshift);
  138.       fg16 = (double) (1L << 16);
  139.       jxmin = (long) (xxmin * fg);
  140.       jxmax = (long) (xxmax * fg);
  141.       xoffset = (jxmax + jxmin) / 2;    /* Calculate average */
  142.       jymin = (long) (yymin * fg);
  143.       jymax = (long) (yymax * fg);
  144.       yoffset = (jymax + jymin) / 2;    /* Calculate average */
  145.       mxmin = (long) (mxminfp * fg);
  146.       mxmax = (long) (mxmaxfp * fg);
  147.       mymin = (long) (myminfp * fg);
  148.       mymax = (long) (mymaxfp * fg);
  149.       origin = (long) (originfp * fg16);
  150.       depth = (long) (depthfp * fg16);
  151.       height = (long) (heightfp * fg16);
  152.       width = (long) (widthfp * fg16);
  153.       dist = (long) (distfp * fg16);
  154.       eyes = (long) (eyesfp * fg16);
  155.       brratio = (long) (brratiofp * fg16);
  156.       dmx = (mxmax - mxmin) / zdots;
  157.       dmy = (mymax - mymin) / zdots;
  158.       longparm = &jbc;
  159.  
  160.       x_per_inch = (long) ((xxmin - xxmax) / widthfp * fg);
  161.       y_per_inch = (long) ((yymax - yymin) / heightfp * fg);
  162.       inch_per_xdot = (long) ((widthfp / xdots) * fg16);
  163.       inch_per_ydot = (long) ((heightfp / ydots) * fg16);
  164.       initz = origin - (depth / 2);
  165.       if(juli3Dmode == 0)
  166.          RightEye.x = 0l;
  167.       else
  168.          RightEye.x = eyes / 2;
  169.       LeftEye.x = -RightEye.x;
  170.       LeftEye.y = RightEye.y = 0l;
  171.       LeftEye.zx = RightEye.zx = dist;
  172.       LeftEye.zy = RightEye.zy = dist;
  173.       bbase = (int) (128.0 * brratiofp);
  174.    }
  175. #endif
  176.  
  177.    helpmode = oldhelpmode;
  178.    unstackscreen();
  179.    if (juli3Dmode == 3)
  180.    {
  181.       savedac = 0;
  182.       mapname = Glasses1Map;
  183.    }
  184.    else
  185.       mapname = GreyFile;
  186.    if(savedac != 1)
  187.    {
  188.    if (ValidateLuts(mapname) != 0)
  189.       return (0);
  190.    spindac(0, 1);               /* load it, but don't spin */
  191.       if(savedac == 2)
  192.         savedac = 1;
  193.    }
  194.    return (r >= 0);
  195. }
  196.  
  197.  
  198. int
  199. jb_per_pixel(void)
  200. {
  201.    jx = multiply(Per->x - xpixel, initz, 16);
  202.    jx = divide(jx, dist, 16) - xpixel;
  203.    jx = multiply(jx << (bitshift - 16), x_per_inch, bitshift);
  204.    jx += xoffset;
  205.    djx = divide(depth, dist, 16);
  206.    djx = multiply(djx, Per->x - xpixel, 16) << (bitshift - 16);
  207.    djx = multiply(djx, x_per_inch, bitshift) / zdots;
  208.  
  209.    jy = multiply(Per->y - ypixel, initz, 16);
  210.    jy = divide(jy, dist, 16) - ypixel;
  211.    jy = multiply(jy << (bitshift - 16), y_per_inch, bitshift);
  212.    jy += yoffset;
  213.    djy = divide(depth, dist, 16);
  214.    djy = multiply(djy, Per->y - ypixel, 16) << (bitshift - 16);
  215.    djy = multiply(djy, y_per_inch, bitshift) / zdots;
  216.  
  217.    return (1);
  218. }
  219.  
  220. int
  221. jbfp_per_pixel(void)
  222. {
  223.    jxfp = ((Perfp->x - xpixelfp) * initzfp / distfp - xpixelfp) * x_per_inchfp;
  224.    jxfp += xoffsetfp;
  225.    djxfp = (depthfp / distfp) * (Perfp->x - xpixelfp) * x_per_inchfp / zdots;
  226.  
  227.    jyfp = ((Perfp->y - ypixelfp) * initzfp / distfp - ypixelfp) * y_per_inchfp;
  228.    jyfp += yoffsetfp;
  229.    djyfp = depthfp / distfp * (Perfp->y - ypixelfp) * y_per_inchfp / zdots;
  230.  
  231.    return (1);
  232. }
  233.  
  234. static int n, zpixel, plotted, color;
  235.  
  236. int
  237. zline(long x, long y)
  238. {
  239.    xpixel = x;
  240.    ypixel = y;
  241.    mx = mxmin;
  242.    my = mymin;
  243.    switch(juli3Dmode)
  244.    {
  245.    case 0:
  246.    case 1:
  247.       Per = &LeftEye;
  248.       break;
  249.    case 2:
  250.       Per = &RightEye;
  251.       break;
  252.    case 3:
  253.       if ((row + col) & 1)
  254.          Per = &LeftEye;
  255.       else
  256.          Per = &RightEye;
  257.       break;
  258.    }
  259.    jb_per_pixel();
  260.    for (zpixel = 0; zpixel < zdots; zpixel++)
  261.    {
  262.       lold.x = jx;
  263.       lold.y = jy;
  264.       jbc.x = mx;
  265.       jbc.y = my;
  266.       if (check_key())
  267.          return (-1);
  268.       ltempsqrx = multiply(lold.x, lold.x, bitshift);
  269.       ltempsqry = multiply(lold.y, lold.y, bitshift);
  270.       for (n = 0; n < maxit; n++)
  271.          if (fractalspecific[neworbittype].orbitcalc())
  272.             break;
  273.       if (n == maxit)
  274.       {
  275.          if (juli3Dmode==3)
  276.          {
  277.             color = (int) (128l * zpixel / zdots);
  278.             if ((row + col) & 1)
  279.             {
  280.  
  281.                (*plot) (col, row, 127 - color);
  282.             }
  283.             else
  284.             {
  285.                color = (int) (multiply((long) color << 16, brratio, 16) >> 16);
  286.                if (color < 1)
  287.                   color = 1;
  288.                if (color > 127)
  289.                   color = 127;
  290.                (*plot) (col, row, 127 + bbase - color);
  291.             }
  292.          }
  293.          else
  294.          {
  295.             color = (int) (254l * zpixel / zdots);
  296.             (*plot) (col, row, color + 1);
  297.          }
  298.          plotted = 1;
  299.          break;
  300.       }
  301.       mx += dmx;
  302.       my += dmy;
  303.       jx += djx;
  304.       jy += djy;
  305.    }
  306.    return (0);
  307. }
  308.  
  309. int
  310. zlinefp(double x, double y)
  311. {
  312.    static int keychk = 0;
  313.    xpixelfp = x;
  314.    ypixelfp = y;
  315.    mxfp = mxminfp;
  316.    myfp = myminfp;
  317.    switch(juli3Dmode)
  318.    {
  319.    case 0:
  320.    case 1:
  321.       Perfp = &LeftEyefp;
  322.       break;
  323.    case 2:
  324.       Perfp = &RightEyefp;
  325.       break;
  326.    case 3:
  327.       if ((row + col) & 1)
  328.          Perfp = &LeftEyefp;
  329.       else
  330.          Perfp = &RightEyefp;
  331.       break;
  332.    }
  333.    jbfp_per_pixel();
  334.    for (zpixel = 0; zpixel < zdots; zpixel++)
  335.    {
  336.       old.x = jxfp;
  337.       old.y = jyfp;
  338.       jbcfp.x = mxfp;
  339.       jbcfp.y = myfp;
  340.       qc = param[0];
  341.       qci = param[1];
  342.       qcj = param[2];
  343.       qck = param[3];
  344. #ifdef XFRACT      
  345.       if (keychk++ > 500)
  346.       {
  347.          keychk = 0;
  348.          if (check_key())
  349.             return (-1);
  350.       }
  351. #else
  352.       if (check_key())
  353.          return (-1);
  354. #endif      
  355.       tempsqrx = sqr(old.x);
  356.       tempsqry = sqr(old.y);
  357.  
  358.       for (n = 0; n < maxit; n++)
  359.          if (fractalspecific[neworbittype].orbitcalc())
  360.             break;
  361.       if (n == maxit)
  362.       {
  363.          if (juli3Dmode == 3)
  364.          {
  365.             color = (int) (128l * zpixel / zdots);
  366.             if ((row + col) & 1)
  367.                (*plot) (col, row, 127 - color);
  368.             else
  369.             {
  370.                color = color * brratiofp;
  371.                if (color < 1)
  372.                   color = 1;
  373.                if (color > 127)
  374.                   color = 127;
  375.                (*plot) (col, row, 127 + bbase - color);
  376.             }
  377.          }
  378.          else
  379.          {
  380.             color = (int) (254l * zpixel / zdots);
  381.             (*plot) (col, row, color + 1);
  382.          }
  383.          plotted = 1;
  384.          break;
  385.       }
  386.       mxfp += dmxfp;
  387.       myfp += dmyfp;
  388.       jxfp += djxfp;
  389.       jyfp += djyfp;
  390.    }
  391.    return (0);
  392. }
  393.  
  394. int
  395. Std4dFractal(void)
  396. {
  397.    long x, y;
  398.    int xdot, ydot;
  399.    c_exp = param[2];
  400.    if(neworbittype == LJULIAZPOWER)
  401.    {
  402.       if(c_exp < 1)
  403.          c_exp = 1;
  404.       if(param[3] == 0.0 && debugflag != 6000 && (double)c_exp == param[2])
  405.           fractalspecific[neworbittype].orbitcalc = longZpowerFractal;
  406.       else
  407.           fractalspecific[neworbittype].orbitcalc = longCmplxZpowerFractal;
  408.    }
  409.  
  410.    for (y = 0, ydot = (ydots >> 1) - 1; ydot >= 0; ydot--, y -= inch_per_ydot)
  411.    {
  412.       plotted = 0;
  413.       x = -(width >> 1);
  414.       for (xdot = 0; xdot < xdots; xdot++, x += inch_per_xdot)
  415.       {
  416.          col = xdot;
  417.          row = ydot;
  418.          if (zline(x, y) < 0)
  419.             return (-1);
  420.          col = xdots - col - 1;
  421.          row = ydots - row - 1;
  422.          if (zline(-x, -y) < 0)
  423.             return (-1);
  424.       }
  425.       if (plotted == 0)
  426.       {
  427.          if (y == 0)
  428.            plotted = -1;  /* no points first pass; don't give up */
  429.          else  
  430.            break;
  431.       }     
  432.    }
  433.    return (0);
  434. }
  435. int
  436. Std4dfpFractal(void)
  437. {
  438.    double x, y;
  439.    int xdot, ydot;
  440.    c_exp = param[2];
  441.  
  442.    if(neworbittype == FPJULIAZPOWER)
  443.    {
  444.       if(param[3] == 0.0 && debugflag != 6000 && (double)c_exp == param[2])
  445.           fractalspecific[neworbittype].orbitcalc = floatZpowerFractal;
  446.       else
  447.           fractalspecific[neworbittype].orbitcalc = floatCmplxZpowerFractal;
  448.       get_julia_attractor (param[0], param[1]);    /* another attractor? */
  449.    }
  450.  
  451.    for (y = 0, ydot = (ydots >> 1) - 1; ydot >= 0; ydot--, y -= inch_per_ydotfp)
  452.    {
  453.       plotted = 0;
  454.       x = -widthfp / 2;
  455.       for (xdot = 0; xdot < xdots; xdot++, x += inch_per_xdotfp)
  456.       {
  457.          col = xdot;
  458.          row = ydot;
  459.          if (zlinefp(x, y) < 0)
  460.             return (-1);
  461.          col = xdots - col - 1;
  462.          row = ydots - row - 1;
  463.          if (zlinefp(-x, -y) < 0)
  464.             return (-1);
  465.       }
  466.       if (plotted == 0)
  467.       {
  468.          if (y == 0)
  469.            plotted = -1;  /* no points first pass; don't give up */
  470.          else  
  471.            break;
  472.       }     
  473.    }
  474.    return (0);
  475. }
  476.