home *** CD-ROM | disk | FTP | other *** search
/ Photo CD Demo 1 / Demo.bin / gle / gle / d_regis.c < prev    next >
C/C++ Source or Header  |  1992-11-29  |  10KB  |  421 lines
  1. /*--------------------------------------------------------------*/
  2. /*    Regis Driver 1.0 (TURBO  C) , for GLE V3.0        */
  3. /*--------------------------------------------------------------*/
  4.  
  5. /*---------------------------------------------------------------------------*/
  6. #include "all.h"
  7. #include <math.h>
  8. #include "core.h"
  9. #include "mygraph.h"
  10. #include "mydev.h"
  11. int ingraphmode;
  12. extern struct gmodel g;
  13. /*---------------------------------------------------------------------------*/
  14. #define pi 3.141592653
  15. #define true (!false)
  16. #define BLACKANDWHITE 1
  17. #define ESC 27
  18. #define false 0
  19. #define dbg if ((gle_debug & 64)>0)
  20. #define stop if ((gle_debug & 128)>0) return
  21. extern int gle_debug;
  22. int incap=true;
  23. int getch(void);
  24. /*---------------------------------------------------------------------------*/
  25. /* The global variables for the PC screen driver */
  26. /*-----------------------------------------------*/
  27.  
  28. int i,l,j,ix,iy;
  29. double f;
  30.  
  31.  
  32. #define gerr() i = graphresult(); if (i!=0) printf("Graph error: %s \n",grapherrormsg(i));
  33. #define xsizecm 21.0
  34. #define ysizecm 18.0
  35. #define sx(v) ( (int) ((v) * d_xscale))
  36. #define sy(v) ( d_maxy - ((int) ((v) * d_yscale)))
  37. #define rx(v) ( (int) ((v) * d_xscale))
  38. #define ry(v) ( d_maxy - ((int) ((v) * d_yscale)))
  39.  
  40. double d_scale, d_xscale, d_yscale;
  41. int d_graphmode;
  42. int d_fillstyle=1,d_fillcolor;
  43. int d_lstyle,d_lwidth;
  44. int d_maxy;
  45.  
  46. d_devcmd(char *s)
  47. {}
  48. dxy(double x, double y, int *dx, int *dy)
  49. {
  50.     static double fx,fy;
  51.     g_dev(x,y,&fx,&fy);
  52.     *dx = sx(fx);
  53.     *dy = sy(fy);
  54. }
  55. rxy(double x, double y, int *dx, int *dy)
  56. {
  57.     static double fx,fy,zx,zy;
  58.     g_dev(x,y,&fx,&fy);
  59.     g_dev(0.0,0.0,&zx,&zy);
  60.     *dx = (int) ( (fx-zx) * d_xscale);
  61.     *dy = (int) ( (fy-zy) * d_yscale);
  62. }
  63. /*---------------------------------------------------------------------------*/
  64. d_dfont(char *c)
  65. {
  66.     /* only used for the DFONT driver which builds fonts */
  67. }
  68. /*---------------------------------------------------------------------------*/
  69. static char lastline[80];
  70. d_message(char *s)
  71. {
  72.     static int single_step;
  73.     int oldcolor,oldx,oldy;
  74.     if (ingraphmode) {
  75.         textmode();
  76.         printf("%s\n",s);
  77.         graphmode();
  78.     } else {
  79.         w_message(s);
  80.     }
  81. }
  82. /*---------------------------------------------------------------------------*/
  83. d_source(char *s)
  84. {
  85.     s=s;
  86. }
  87. /*---------------------------------------------------------------------------*/
  88. d_get_type(char *t)
  89. {
  90.     strcpy(t,"INTERACTIVE, REGIS, VAX");
  91. }
  92. /*---------------------------------------------------------------------------*/
  93. d_set_path(int onoff)
  94. {}
  95. /*---------------------------------------------------------------------------*/
  96. d_newpath()
  97. {
  98. }
  99. /*---------------------------------------------------------------------------*/
  100. d_open(double width, double height)
  101. {
  102.  
  103.     graphmode();
  104.     ingraphmode = true;
  105.  
  106.     /* Get largest rectangle we can fit on the screen */
  107.     d_scale = xsizecm / width;
  108.     f = ysizecm / height;
  109.     if (f<d_scale) d_scale = f;
  110.  
  111.     d_xscale = d_scale * getmaxx() / xsizecm; /* Device Scale X, Device Scale y */
  112.     d_yscale = d_scale * (getmaxy()-20) / ysizecm;
  113.     d_maxy = getmaxy()-20;
  114.     g.userwidth = width;
  115.     g.userheight = height;
  116. }
  117. /*---------------------------------------------------------------------------*/
  118. d_tidyup()
  119. {
  120.     textmode();
  121. }
  122. d_close()
  123. {
  124.  
  125.     g_flush();
  126.     textmode();
  127.     d_message("Press <RETURN> to continue");
  128.     text_inkey();
  129. }
  130. /*---------------------------------------------------------------------------*/
  131. d_set_line_cap(int i)
  132. {
  133.     i++;
  134. }
  135. /*---------------------------------------------------------------------------*/
  136. d_set_line_join(int i)
  137. {
  138.     i++;
  139. }
  140. /*---------------------------------------------------------------------------*/
  141. d_set_line_miterlimit(double d)
  142. {
  143.     i++;
  144. }
  145. /*---------------------------------------------------------------------------*/
  146. d_set_line_width(double w)
  147. {
  148. }
  149. /*---------------------------------------------------------------------------*/
  150. d_set_line_styled(double dd)
  151. {}
  152. d_set_line_style(char *s)
  153. {
  154.     d_lstyle = 2;
  155.     if (strcmp(s,"")==0) d_lstyle = 1;
  156.     if (strcmp(s,"1")==0) d_lstyle = 1;
  157.     printf("W(P%d);\n",d_lstyle);
  158. }
  159. /*---------------------------------------------------------------------------*/
  160. d_fill()
  161. {
  162. }
  163. /*---------------------------------------------------------------------------*/
  164. d_fill_ary(int nwk,double (*wkx)[],double (*wky)[])
  165. {
  166.     int i;
  167. /*    fprintf(psfile,"%g %g moveto \n",(*wkx)[0],(*wky)[0]);
  168.     for (i=1;i<nwk;i++)
  169.         fprintf(psfile,"%g %g l \n",(*wkx)[i],(*wky)[i]);
  170. */
  171. }
  172. d_line_ary(int nwk,double (*wkx)[],double (*wky)[])
  173. {
  174.     int i;
  175. /*
  176.     dxy( (*wkx)[0], (*wky)[0], &ix, &iy);
  177.     moveto(ix,iy);
  178.     for (i=1;i<nwk;i++) {
  179.         dxy( (*wkx)[i], (*wky)[i], &ix, &iy);
  180.         lineto(ix,iy);
  181.     }
  182. */
  183. }
  184. /*---------------------------------------------------------------------------*/
  185. d_stroke()
  186. {
  187. }
  188. /*---------------------------------------------------------------------------*/
  189. d_clip()
  190. {
  191. }
  192. /*---------------------------------------------------------------------------*/
  193. d_set_matrix(double newmat[3][3])
  194. {
  195. }
  196. /*---------------------------------------------------------------------------*/
  197. d_move(double zx,double zy)
  198. {
  199. }
  200. /*---------------------------------------------------------------------------*/
  201. d_reverse()     /* reverse the order of stuff in the current path */
  202. {
  203. }
  204. /*---------------------------------------------------------------------------*/
  205. d_closepath()
  206. {
  207.     g_line(g.closex,g.closey);
  208. }
  209. /*---------------------------------------------------------------------------*/
  210. d_line(double zx,double zy)
  211. {
  212.     static int ux,uy;
  213.     if (g.xinline==false) {
  214.         dxy(g.curx,g.cury,&ux,&uy);
  215.         printf("P[%d,%d]",ux,uy);
  216.     }
  217.     dxy(zx,zy,&ix,&iy);
  218.     printf("V[%d,%d];\n",ix,iy);
  219. }
  220. /*---------------------------------------------------------------------------*/
  221. d_clear()
  222. {
  223.     double width,height;
  224.     int x1,y1,x2,y2;
  225.     width = g.userwidth;
  226.     height = g.userheight;
  227.     /* now draw bounding box of screen */
  228.     x1 = 0;
  229.     y1 = d_maxy-height*d_yscale;
  230.     x2 = width*d_xscale;
  231.     y2 = d_maxy;
  232.      printf("F(W(I15)V[%d,%d][%d,%d][%d,%d][%d,%d][%d,%d])"
  233.         ,x1,y1,x2,y1,x2,y2,x1,y2,x1,y1);
  234.     printf("W(I0)W(R)");
  235. }
  236. /*---------------------------------------------------------------------------*/
  237. d_flush()
  238. {
  239. }
  240. /*---------------------------------------------------------------------------*/
  241. d_arcto(dbl x1,dbl y1,dbl x2,dbl y2,dbl rrr)
  242. {
  243. }
  244. /*---------------------------------------------------------------------------*/
  245. d_arc(dbl r,dbl t1,dbl t2,dbl cx,dbl cy)
  246. {
  247.     static int ixr,iyr,icx,icy,ixs,iys;
  248.     double ux,uy,z,xs,ys;
  249.  
  250.     if (t1>t2) {z = t1; t1 = t2; t2 = z;}
  251.     polar_xy(r,t1,&xs,&ys);
  252.     rxy(xs,ys,&ixs,&iys);
  253.  
  254.     dxy(cx,cy,&icx,&icy);
  255.     rxy(r,r,&ixr,&iyr);
  256.     printf("P[%d,%d]C(A%d)[%d,%d]\n",icx,icy,(int) t2-t1,ixs,iys);
  257.     g.xinline = false;
  258. }
  259. /*---------------------------------------------------------------------------*/
  260. d_narc(dbl r,dbl t1,dbl t2,dbl cx,dbl cy)
  261. {
  262.     static int ixr,iyr,icx,icy,ixs,iys;
  263.     double ux,uy,z,xs,ys;
  264.  
  265.     if (t1>t2) {z = t1; t1 = t2; t2 = z;}
  266.     polar_xy(r,t1,&xs,&ys);
  267.     rxy(xs,ys,&ixs,&iys);
  268.  
  269.     dxy(cx,cy,&icx,&icy);
  270.     rxy(r,r,&ixr,&iyr);
  271.     printf("P[%d,%d]C(A%d)[%d,%d]",icx,icy,(int) t2-t1,ixs,iys);
  272.     g.xinline = false;
  273. }
  274. /*---------------------------------------------------------------------------*/
  275. d_box_fill(dbl x1, dbl y1, dbl x2, dbl y2)
  276. {
  277.     static int ix1,iy1,ix2,iy2;
  278.     static int ii;
  279.     dxy(x1,y1,&ix1,&iy1);
  280.     dxy(x2,y2,&ix2,&iy2);
  281.     if (ix1>ix2) { ii = ix1; ix1 = ix2; ix2 = ii; }
  282.     if (iy1>iy2) { ii = iy1; iy1 = iy2; iy2 = ii; }
  283.     printf("P[%d,%d]F(V[%d,%d][%d,%d][%d,%d][%d,%d]);\n",ix1,iy1,ix2,iy1
  284.         ,ix2,iy2,ix1,iy2,ix1,iy1);
  285.     g.xinline = false;
  286. }
  287. d_box_stroke(dbl x1, dbl y1, dbl x2, dbl y2)
  288. {
  289.     static int ix1,iy1,ix2,iy2,ix3,iy3,ix4,iy4;
  290.     static int ii;
  291.     dxy(x1,y1,&ix1,&iy1);
  292.     dxy(x2,y2,&ix2,&iy2);
  293.     if (ix1>ix2) { ii = ix1; ix1 = ix2; ix2 = ii; }
  294.     if (iy1>iy2) { ii = iy1; iy1 = iy2; iy2 = ii; }
  295.     printf("P[%d,%d]V[%d,%d][%d,%d][%d,%d][%d,%d];\n",ix1,iy1,ix2,iy1
  296.         ,ix2,iy2,ix1,iy2,ix1,iy1);
  297.     g.xinline = false;
  298. }
  299. /*---------------------------------------------------------------------------*/
  300. d_circle_stroke(double zr)
  301. {
  302.     static int ixr,iyr;
  303.     int ux,uy;
  304.     rxy(zr,zr,&ixr,&iyr);
  305.     dxy(g.curx,g.cury,&ux,&uy);
  306.     printf("P[%d,%d]C(A%d)[%d,%d]",ux,uy,360,ixr);
  307.     g.xinline = false;
  308. }
  309. d_circle_fill(double zr)
  310. {
  311.     static int ixr,iyr;
  312.     int ux,uy;
  313.     dxy(g.curx,g.cury,&ux,&uy);
  314.     rxy(zr,zr,&ixr,&iyr);
  315.     printf("P[%d,%d]F(C(A%d)[%d,%d])",ux,uy,360,ixr);
  316.     g.xinline = false;
  317. }
  318. /*---------------------------------------------------------------------------*/
  319. d_bezier(dbl x1,dbl y1,dbl x2,dbl y2,dbl x3,dbl y3)
  320. {
  321.     double ax,bx,cx,ay,by,cy,dist;
  322.     double xxx,yyy,i,t,nstep,x0,y0;
  323.     g_get_xy(&x0,&y0);
  324.     dist = fabs(x3-x0) + fabs(y3-y0);
  325.     nstep = 10;
  326.     if (dist>3) nstep = 20;
  327.     if (dist<.5) nstep = 5;
  328.     if (dist<.3) nstep = 3;
  329.      if (dist<.1) {
  330.         g_line(x3,y3);
  331.         return;
  332.     }
  333.     cx = (x1-x0)*3;
  334.     bx = (x2-x1)*3-cx;
  335.     ax = x3-x0-cx-bx;
  336.     cy = (y1-y0)*3;
  337.     by = (y2-y1)*3-cy;
  338.     ay = y3-y0-cy-by;
  339.     for (i=0;i<=nstep;i++) {
  340.         t = i/nstep;
  341.         xxx = ax*pow(t,3.0) + bx*t*t + cx*t + x0;
  342.         yyy = ay*pow(t,3.0) + by*t*t + cy*t + y0;
  343.         g_line(xxx,yyy);
  344.     }
  345. }
  346. /*---------------------------------------------------------------------------*/
  347. d_set_color(long f)
  348. {
  349.     int i;
  350.     colortyp  cc;
  351.     cc.l = f;
  352.     i = 0;
  353.     if (cc.b[B_R]>100) i = 4;
  354.     if (cc.b[B_B]>100) i = 1;
  355.     if (cc.b[B_G]>100) i = 2;
  356. /*
  357.     if (cc.b[B_R]>100 && cc.b[B_G]>100 && cc.b[B_B]>100) i = getmaxcolor();
  358.     if (i>getmaxcolor()) i = getmaxcolor();
  359. */
  360. }
  361. d_set_fill(long f)
  362. {
  363. }
  364. /*---------------------------------------------------------------------------*/
  365. d_beginclip()
  366. {
  367. }
  368. d_endclip()
  369. {
  370. }
  371. struct char_data {float wx,wy,x1,y1,x2,y2; };
  372. int font_get_chardata(struct char_data *cd, int ff, int cc);
  373. /*---------------------------------------------------------------------------*/
  374. d_char(int font, int cc)
  375. {
  376.     static struct char_data cd;
  377.     static int ix,iy,ix1,ix2,iy1,iy2,fz,fzx;
  378.     static int ux,uy;
  379.     char ss[2];
  380.  
  381.     ss[0] = cc;
  382.     ss[1] = 0;
  383.     stop;
  384.  
  385.     if (font_get_encoding(font)>2) {
  386.         my_char(font,cc);
  387.         return;
  388.     }
  389.     font_get_chardata(&cd,font,cc);
  390.     if (g.fontsz==0) g.fontsz = 1;
  391.     dxy(g.curx, g.cury , &ix1, &iy1);
  392.  
  393.     rxy(g.fontsz * .5,g.fontsz * .7,&fzx,&fz);
  394.     printf("P[%d,%d]T(W(V),S[400,400],U[%d,%d])'%c';\n"
  395.         ,ix1,iy1-fz,fzx,fz,cc);
  396. }
  397. graphmode()
  398. {
  399.     ingraphmode = true;
  400.     printf("%cPp",ESC);
  401. }
  402. textmode()
  403. {
  404.     ingraphmode = false;
  405.     printf("%c%c",ESC,'\\');
  406. }
  407. getmaxx()
  408. {
  409.     return 799;
  410. }
  411. getmaxy()
  412. {
  413.     return 479;
  414. }
  415.  
  416.  
  417.  
  418.  
  419.  
  420.  
  421.