home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / grafik / tc_3d / tc-13.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-02-13  |  17.1 KB  |  430 lines
  1. /* TC-13.C */
  2. /* This program demonstrates a mirror reflection of
  3.     a computer generated 3d solid cube */
  4.  
  5. /* ----------------------------------------------------------------------- */
  6. /* INCLUDE FILES */
  7. #include <process.h>
  8. #include <bios.h>
  9. #include <stdio.h>
  10. #include <graphics.h>
  11. #include <math.h>
  12.  
  13. /* ----------------------------------------------------------------------- */
  14. /* DECLARATIONS */
  15.  
  16. float        x=0.0,y=0.0,z=0.0;                                              /* world coordinates */
  17. float        x1=0.0,x2=0.0,x3=0.0;                                        /* polygon vertices */
  18. float        y01=0.0,y2=0.0,y3=0.0;                                        /* polygon vertices */
  19. float        z1=0.0,z2=0.0,z3=0.0;                                        /* polygon vertices */
  20. float        sx1=0.0,sx2=0.0,sx3=0.0,sx4=0.0,sx5=0.0;                /* display coordinaes */
  21. float        sy1=0.0,sy2=0.0,sy3=0.0,sy4=0.0,sy5=0.0;                /* display coordinates */
  22. float        sx=0.0,sy=0.0;                                                    /* output of 3d perspective formulas */
  23. float        xa=0.0,ya=0.0,za=0.0;                                        /* temporary values in 3d formulas */
  24. float        d=1200.0;                                                        /* angular perspective value */
  25. double    r1=5.68319;                                                        /* yaw angle in radians */
  26. double    r2=6.28319;                                                        /* roll angle in radians */
  27. double    r3=5.79778;                                                        /* pitch angle in radians */
  28. double    sr1=0.0,sr2=0.0,sr3=0.0;                                    /* sine rotation factors */
  29. double    cr1=0.0,cr2=0.0,cr3=0.0;                                    /* cosine rotation factors */
  30. float        mx=0.0,my=0.0,mz=-450.0;                                    /* viewpoint position */
  31. int        maxx=639,minx=0,maxy=199,miny=0;                            /* scaling viewport */
  32. float        screen_x=639,screen_y=199;                                    /* dimensions of screen mode */
  33. int        C0=0,C1=1,C2=2,C3=3,C4=4,C5=5,C6=6,C7=7,C8=8,        /* color varariables */
  34.             C9=9,C10=10,C11=11,C12=12,C13=13,C14=14,C15=15,
  35.             mode_flag=0;
  36. float        rx=0.0,ry=0.0;                                                    /* scaling values used in mapping routine */
  37. int        t=0,t1=0,t2=0;                                                    /* loop counters */
  38. int        p1=0;                                                                /* array indexer */
  39. int        key_matte_clr=6;                                                /* exclusive key matte color */
  40. int        edge_clr=7;                                                        /* used to draw edges on models */
  41. int        solid_clr=0;                                                    /* used to fill surfaces of solid models */
  42. float        x_res,y_res;                                                    /* used for 2d mappinf from 640*480 template */
  43. float        sp=0.0;                                                            /* visibility factor in hidden surface routine */
  44. float        sp1=0.0,sp2=0.0,sp3=0.0;                                    /* temporary values of sp */
  45.  
  46. int        NORM_HUE=0;                                                        /* halftoning color */
  47. int        BASE_CLR=0;                                                        /* prep cooor for dithering */
  48. int        CC4=0;                                                            /* underlay color for dithering */
  49. int        CC5=0;                                                            /* overlay color for dithering */
  50. unsigned short CC6=0xffff;                                                /* pattern for dithering */
  51. float        xx1=.5,yy1=.70711,zz1=.5;                                    /* location of light source - elevation 45 degrees, compas 135 degrees {{REDIFINED !!}}*/
  52. float        v4=0.0;                                                            /* illumination factor 0 to 1 range */
  53. int        v5=0;                                                                /* illumination factor base 1 range */
  54. int        v6=11;                                                            /* VGA and EGA illumination range */
  55. int        v7=0;                                                                /* temporary varaible used for illumination range */
  56. float        xu=0.0,yu=0.0,zu=0.0;                                        /* vector from vertex one to vertex two */
  57. float        xv=0.0,yv=0.0,zv=0.0;                                        /* vector from vertex 1 to vertex 3 */
  58. float        xn=0.0,y0n=0.0,zn=0.0;                                        /* surface perpendicular factor */
  59. float        v1=0.0,v2=0.0;                                                    /* length of surface perpendicular vector */
  60. float        v3=0.0;                                                            /* ratio of length to unit vector magnitude */
  61. float        xw=0.0,yw=0.0,zw=0.0;                                        /* surface perpendicual unit vector */
  62. int        polary[4][2];  /* used in my 3d solid polygon draw routine */
  63.  
  64. /* define halftone codes */
  65. char fill_0[]={0,0,0,0,0,0,0,0};                                        /* 0% fill */
  66. char fill_3[]={0,32,0,0,0,2,0,0};                                    /* 3% fill */
  67. char fill_6[]={32,0,2,0,128,0,8,0};                                    /* 6% fill */
  68. char fill_12[]={32,2,128,8,32,2,128,8};                            /* 12% fill */
  69. char fill_25[]={68,17,68,17,68,17,68,17};                            /* 25% fill */
  70. char fill_37[]={170,68,170,17,170,68,170,17};                    /* 37% fill */
  71. char fill_50[]={85,170,85,170,85,170,85,170};                    /* 50% fill */
  72. char fill_62[]={85,187,85,238,85,187,85,238};                    /* 62% fill */
  73. char fill_75[]={187,238,187,238,187,238,187,238};                /* 75% fill */
  74. char fill_87[]={223,253,127,247,223,253,127,247};                /* 87% fill */
  75. char fill_93[]={255,223,255,223,255,223,255,223};                /* 93% fill */
  76. char fill_100[]={255,255,255,255,255,255,255,255};                /* 100% fill */
  77.  
  78. /* database of vertices for 3d model */
  79. int        array1[][3]={
  80.             30,-30,30,    30,30,30,    -30,30,30,    -30,-30,30,    30,30,-30,
  81.             -30,30,-30,    -30,-30,-30,    30,-30,-30};
  82.  
  83. /* database of fill origins for 3d model */
  84. int        array2[][3]={
  85.             0,-30,0,    0,0,-30,    -30,0,0,    0,0,30,    30,0,0,    0,30,0};
  86.  
  87. /* database of mirror image coordinates */
  88. int        array3[][3]={
  89.             -30,-90,30,    30,-90,30,    30,-90,-30};
  90.  
  91. /* database of mirror fill coordinates */
  92. int        array4[][3]={
  93.             0,-60,30,    30,-60,0};
  94.  
  95. float        B1[8][3];                                                        /* array of 8 sets of xyz coordinates */
  96. float        B2[8][2];                                                        /* array of 8 sets of sx,sy diaplay coordinates */
  97. float        B3[6][2];                                                        /* array of 6 sets of sx,sy fill coordinates */
  98. float        B5[3][2];                                                        /* array of 3 sets of sx,sy mirror image coords */
  99. float        B6[2][2];                                                        /* array of 2 sets of sx,sy mirrir fill coordinates */
  100.  
  101. void keyboard(void);void quit_pgm(void);void calc_3d(void);
  102. void rotation(void);void window(void);void graphics_setup(void);
  103. void coords(void);void draw_poly(void);void notice(int x,int y);
  104. void visibility_test(void);void store_coords(void);
  105. void illumination(void);void dither(void);void shade(void);
  106. void values(void);
  107.  
  108. /* ----------------------------------------------------------------------- */
  109. /* MAIN ROUTINES */
  110.  
  111. main(){
  112. graphics_setup();
  113. setviewport(0,0,maxx,maxy,1);
  114. key_matte_clr=C11;
  115. edge_clr=C7;solid_clr=C0;
  116. NORM_HUE=C11;
  117. store_coords();
  118.  
  119. setcolor(C7);setfillpattern(fill_50,C7);                            /* draw the mirror */
  120. x=-80;y=-30;z=80;calc_3d();window();moveto(sx,sy);putpixel(sx,sy,C7);
  121. x=80;y=-30;z=80;calc_3d();window();lineto(sx,sy);
  122. x=80;y=-30;z=-80;calc_3d();window();lineto(sx,sy);
  123. x=-80;y=-30;z=-80;calc_3d();window();lineto(sx,sy);
  124. x=-80;y=-30;z=80;calc_3d();window();lineto(sx,sy);
  125. x=0;y=-30;z=0;calc_3d();window();floodfill(sx,sy,C7);
  126.  
  127. surface3:
  128. x1=B1[0][0];y01=B1[0][1];z1=B1[0][2];x2=B1[1][0];y2=B1[1][1];
  129. z2=B1[1][2];x3=B1[2][0];y3=B1[2][1];z3=B1[2][2];visibility_test();
  130. if (sp>0) goto surface4;
  131. sx1=B2[0][0];sy1=B2[0][1];sx2=B2[1][0];sy2=B2[1][1];sx3=B2[2][0];
  132. sy3=B2[2][1];sx4=B2[3][0];sy4=B2[3][1];sx5=B3[3][0];sy5=B3[3][1];
  133. draw_poly();
  134. illumination();v5=4;
  135. shade();dither();
  136. mirror_surface3:
  137. sx1=B2[0][0];sy1=B2[0][1];sx2=B2[3][0];sy2=B2[3][1];sx3=B5[0][0];
  138. sy3=B5[0][1];sx4=B5[1][0];sy4=B5[1][1];sx5=B6[0][0];sy5=B6[0][1];
  139. draw_poly();
  140. v5=v5-1;                                                                        /* reduce light to account for mirror */
  141. shade();dither();
  142.  
  143. surface4:
  144. x1=B1[7][0];y01=B1[7][1];z1=B1[7][2];x2=B1[4][0];y2=B1[4][1];
  145. z2=B1[4][2];x3=B1[1][0];y3=B1[1][1];z3=B1[1][2];visibility_test();
  146. if (sp>0) goto surface5;
  147. sx1=B2[7][0];sy1=B2[7][1];sx2=B2[4][0];sy2=B2[4][1];sx3=B2[1][0];
  148. sy3=B2[1][1];sx4=B2[0][0];sy4=B2[0][1];sx5=B3[4][0];sy5=B3[4][1];
  149. draw_poly();illumination();shade();dither();
  150. mirror_surface4:
  151. sx1=B2[7][0];sy1=B2[7][1];sx2=B2[0][0];sy2=B2[0][1];sx3=B5[1][0];
  152. sy3=B5[1][1];sx4=B5[2][0];sy4=B5[2][1];sx5=B6[1][0];sy5=B6[1][1];
  153. draw_poly();
  154. v5=v5-1;                                                                        /* reduce light to account for mirror */
  155. shade();dither();
  156.  
  157. surface5:
  158. x1=B1[1][0];y01=B1[1][1];z1=B1[1][2];x2=B1[4][0];y2=B1[4][1];
  159. z2=B1[4][2];x3=B1[5][0];y3=B1[5][1];z3=B1[5][2];visibility_test();
  160. if (sp>0) goto surfaces_done;
  161. sx1=B2[1][0];sy1=B2[1][1];sx2=B2[4][0];sy2=B2[4][1];sx3=B2[5][0];
  162. sy3=B2[5][1];sx4=B2[2][0];sy4=B2[2][1];sx5=B3[5][0];sy5=B3[5][1];
  163. draw_poly();illumination();shade();dither();
  164.  
  165. /* tidy up the background */
  166. setcolor(C6);setlinestyle(USERBIT_LINE,0xffff,NORM_WIDTH);
  167. x=-80;y=-30;z=80;calc_3d();window();moveto(sx,sy);putpixel(sx,sy,C6);
  168. x=80;y=-30;z=80;calc_3d();window();lineto(sx,sy);sx2=sx;sy2=sy;
  169. x=80;y=-30;z=180;calc_3d();window();lineto(sx,sy);sx3=sx;sy3=sy;
  170. x=-80;y=-30;z=180;calc_3d();window();lineto(sx,sy);sx4=sx;sy4=sy;
  171. x=-80;y=-30;z=80;calc_3d();window();lineto(sx,sy);sx1=sx;sy1=sy;
  172. x=0;y=-30;z=90;calc_3d();window();
  173. setfillstyle(SOLID_FILL,C0);floodfill(sx,sy,C6);
  174. setfillstyle(SOLID_FILL,C0);floodfill(sx,sy,C6);
  175. setcolor(C0);
  176. moveto(sx1,sy1);lineto(sx2,sy2);lineto(sx3,sy3);
  177. lineto(sx4,sy4);lineto(sx1,sy1);
  178. setcolor(C7);moveto(sx1,sy1);lineto(sx2,sy2);
  179.  
  180. surfaces_done:setcolor(C7);notice(0,0);
  181. for (t1=1;t1!=2;) keyboard();
  182. quit_pgm();
  183. }
  184.  
  185. /* ----------------------------------------------------------------------- */
  186. /* SUBROUTINE: CALCULATE SIN,COS FACTORS */
  187.  
  188. void rotation(void){
  189. sr1=sin(r1);sr2=sin(r2);sr3=sin(r3);cr1=cos(r1);cr2=cos(r2);
  190. cr3=cos(r3);return;}
  191.  
  192. /* ----------------------------------------------------------------------- */
  193. /* SUBROUTINE: STANDARD 3D FORMULAS */
  194. /* Pass: x,y,z cartesian world coordinates.
  195.    Returns: sx,sy cartesian display coordinates.
  196.           x,y,z catesian view coordinates */
  197.  
  198. void calc_3d(void){
  199. x=(-1)*x;xa=cr1*x-sr1*z;za=sr1*x+cr1*z;x=cr2*xa+sr2*y;
  200. ya=cr2*y-sr2*xa;z=cr3*za-sr3*ya;y=sr3*za+cr3*ya;x=x+mx;y=y+my;
  201. z=z+mz;sx=d*x/z;sy=d*y/z;return;}
  202.  
  203. void store_coords(void){
  204. rotation();                                                                    /* store roll,pitch yaw rotation factors */
  205. for (t=0;t<=7;t++){
  206.     x=array1[t][0];y=array1[t][1];z=array1[t][2];
  207.     calc_3d();window();
  208.     B1[t][0]=x;B1[t][1]=y;B1[t][2]=z;
  209.     B2[t][0]=sx;B2[t][1]=sy;
  210.     };
  211.  
  212. for (t=0;t<=5;t++){
  213.     x=array2[t][0];y=array2[t][1];z=array2[t][2];
  214.     calc_3d();window();
  215.     B3[t][0]=sx;B3[t][1]=sy;                                            /* store fill display coordinates */
  216.     };
  217.  
  218. for (t=0;t<=2;t++){
  219.     x=array3[t][0];y=array3[t][1];z=array3[t][2];
  220.     calc_3d();window();
  221.     B5[t][0]=sx;B5[t][1]=sy;                                            /* store mirrored display coordinates */
  222.     };
  223.  
  224. for (t=0;t<=1;t++){
  225.     x=array4[t][0];y=array4[t][1];z=array4[t][2];
  226.     calc_3d();window();
  227.     B6[t][0]=sx;B6[t][1]=sy;                                            /* store mirrored fill display coordinates */
  228.     };
  229.  
  230.     return;
  231.     }
  232.  
  233. /* ----------------------------------------------------------------------- */
  234. /* HIDDEN SURFACE VISIBILTY TEST */
  235. void visibility_test(void){
  236. sp1=x1*(y2*z3-y3*z2);sp1=(-1)*sp1;sp2=x2*(y3*z1-y01*z3);
  237. sp3=x3*(y01*z2-y2*z1);sp=sp1-sp2-sp3;return;}
  238.  
  239. /* ----------------------------------------------------------------------- */
  240. /* SUBROUTINE: DRAW 4-SIDED SOLID POLYGON IN 3D SPACE */
  241.  
  242. void draw_poly(void){
  243. setlinestyle(USERBIT_LINE,0xffff,NORM_WIDTH);
  244. setfillstyle(SOLID_FILL,key_matte_clr);
  245. setcolor(edge_clr);
  246.  
  247. polary[0][0]=sx1;polary[0][1]=sy1;polary[1][0]=sx2;polary[1][1]=sy2;
  248. polary[2][0]=sx3;polary[2][1]=sy3;polary[3][0]=sx4;polary[3][1]=sy4;
  249.  
  250. fillpoly (4,(int far*) polary);
  251. return;
  252. }
  253.  
  254. /* ----------------------------------------------------------------------- */
  255. /* SUBROUTINES: CALCULATE ILLUMINATION LEVEL */
  256.  
  257. void illumination(void){
  258. xu=x2-x1;yu=y2-y01;zu=z2-z1;                                        /* vector from vertex 1 to vertex 2 */
  259. xv=x3-x1;yv=y3-y01;zv=z3-z1;                                        /* vector from vertex 1 to vertex 3 */
  260. xn=(yu*zv)-(zu*yv);y0n=(zu*xv)-(xu*zv);
  261.     zn=(xu*yv)-(yu*xv);                                                /* surface perpendicular vector */
  262. y0n=y0n*(-1);zn=zn*(-1);                                            /* convert to cartesian system */
  263. v1=(xn*xn)+(y0n*y0n)+(zn*zn);
  264. v2=sqrt(v1);                                                            /* magnitude of surface perpendicular vector */
  265. v3=1/v2;                                                                    /* ratio of magnitude to length of unit vector */
  266. xw=v3*xn;yw=v3*y0n;zw=v3*zn;                                        /* surface perpendicular to unit vector */
  267. v4=(xw*xx1)+(yw*yy1)+(zw*zz1);                                    /* illumination factor 0 to 1 */
  268. v4=v4*v6;                                                                /* expand illumination range from base 0 */
  269. v7=v4;                                                                    /* convert illumination range to integer */
  270. v5=v7+1;                                                                    /* illumination range from base 1 */
  271. return;
  272. }
  273.  
  274. /* ----------------------------------------------------------------------- */
  275. /* SUBROUTINE: ILLUMINATION MATRIX */
  276.  
  277. void shade(void){
  278. switch (v5){
  279.     case 1:setfillpattern(fill_6,NORM_HUE);CC6=0x1010;values();return;
  280.     case 2:setfillpattern(fill_6,NORM_HUE);CC6=0x1010;values();return;
  281.     case 3:setfillpattern(fill_6,NORM_HUE);CC6=0x1010;values();return;
  282.     case 4:setfillpattern(fill_12,NORM_HUE);CC6=0x2020;values();return;
  283.     case 5:setfillpattern(fill_25,NORM_HUE);CC6=0x2222;values();return;
  284.     case 6:setfillpattern(fill_37,NORM_HUE);CC6=0xaaaa;values();return;
  285.     case 7:setfillpattern(fill_50,NORM_HUE);CC6=0xaaaa;values();return;
  286.     case 8:setfillpattern(fill_62,NORM_HUE);CC6=0xaaaa;values();return;
  287.     case 9:setfillpattern(fill_75,NORM_HUE);CC6=0xbbbb;values();return;
  288.     case 10:setfillpattern(fill_87,NORM_HUE);CC6=0xdddd;values();return;
  289.     case 11:setfillpattern(fill_93,NORM_HUE);CC6=0xefef;values();return;
  290.     case 12:setfillpattern(fill_100,NORM_HUE);CC6=0xffff;values();return;
  291.     defualt:setfillpattern(fill_6,NORM_HUE);CC6=0x1010;values();}
  292. return;}
  293.  
  294. /* ----------------------------------------------------------------------- */
  295. /* LOCAL SUBROUTINE: prep fill and set dithering variables */
  296. void values(void){
  297. floodfill(sx5,sy5,edge_clr);CC4=BASE_CLR;CC5=NORM_HUE;return;}
  298.  
  299. /* ----------------------------------------------------------------------- */
  300. /* SUBROUTINE: APPLY DITHERING */
  301.  
  302. void dither(void){
  303. setlinestyle(USERBIT_LINE,0xffff,NORM_WIDTH);setcolor(CC4);
  304. moveto (sx1,sy1);lineto(sx2,sy2);lineto(sx3,sy3);
  305. lineto(sx4,sy4);lineto(sx1,sy1);
  306. setlinestyle(USERBIT_LINE,CC6,NORM_WIDTH);setcolor(CC5);
  307. moveto(sx1,sy1);lineto(sx2,sy2);lineto(sx3,sy3);
  308. lineto(sx4,sy4);lineto(sx1,sy1);
  309. return;
  310. }
  311.  
  312. /* ----------------------------------------------------------------------- */
  313. /* SUBROUTINE: MAP CARTESIAN COORDS TO PHYSICAL SCREEN COORDS */
  314.  
  315. void window(void){
  316. sx=sx+399;sy=sy+299;rx=screen_x/799;ry=screen_y/599;sx=sx*rx;
  317. sy=sy*ry;return;}
  318.  
  319. /* ----------------------------------------------------------------------- */
  320. /* SUBROUTINE: CHACK THE KEYBOARD BUFFER */
  321. void keyboard(void){
  322. if (bioskey(1)==0) return; else quit_pgm();}
  323.  
  324. /* ----------------------------------------------------------------------- */
  325. /* SUBROUTINE: GRACEFUL EXIT FROM PROGRAM */
  326.  
  327. void quit_pgm(void){
  328. cleardevice();restorecrtmode();exit(0);}
  329.  
  330. /* ----------------------------------------------------------------------- */
  331. /* SUBROUTINE: VGA/EGA/MCGA/CGA COMPATIBILITY MODULE */
  332.  
  333. void graphics_setup(void){
  334. int graphics_adapter,graphics_mode;
  335. detectgraph(&graphics_adapter,&graphics_mode);
  336. if (graphics_adapter==VGA) goto VGA_mode;
  337. if (graphics_mode==EGAHI) goto EGA_ECD_mode;
  338. if (graphics_mode==EGALO) goto EGA_SCD_mode;
  339. if (graphics_adapter==CGA) goto CGA_mode;
  340. if (graphics_adapter==MCGA) goto CGA_mode;
  341. goto abort_message;
  342.  
  343. VGA_mode:
  344. graphics_adapter=VGA;graphics_mode=VGAHI;
  345. initgraph(&graphics_adapter,&graphics_mode,"");
  346. x_res=640;y_res=480;mode_flag=1;
  347.         maxx=639;minx=0;maxy=479;miny=0;screen_x=639;screen_y=479;
  348.           setcolor(7);moveto(0,30);
  349.           outtext("Revisions by A. Helder");
  350.         moveto(472,472);
  351.         outtext("Press any key to quit");
  352.         moveto(160,0);
  353.           outtext("USING C TO GENERATE MIRROR REFLECTIONS");
  354.         return;
  355.  
  356. EGA_ECD_mode:
  357. graphics_adapter=EGA;graphics_mode=EGAHI;
  358. initgraph(&graphics_adapter,&graphics_mode,"");
  359. x_res=640;y_res=350;mode_flag=2;
  360.         maxx=639;minx=0;maxy=349;miny=0;screen_x=639;screen_y=349;
  361.           setcolor(7);moveto(0,20);
  362.           outtext("Revisions by A. Helder");
  363.         moveto(472,342);
  364.         outtext ("Press any key to quit");
  365.         moveto(160,0);
  366.           outtext("USING C TO GENERATE MIRROR REFLECTIONS");
  367.         return;
  368.  
  369. EGA_SCD_mode:
  370. graphics_adapter=EGA;graphics_mode=EGALO;
  371. initgraph(&graphics_adapter,&graphics_mode,"");
  372. x_res=640;y_res=200;mode_flag=3;
  373.         maxx=639;minx=0;maxy=199;miny=0;screen_x=639;screen_y=199;
  374.           setcolor(7);moveto(0,19);
  375.           outtext("Revisions by A. Helder");
  376.         moveto(472,192);
  377.         outtext("PRESS ANY KEY TO QUIT");
  378.         moveto(160,0);
  379.           outtext("USING C TO GENERATE MIRROR REFLECTIONS");
  380.         return;
  381.  
  382. CGA_mode:
  383. graphics_adapter=CGA;graphics_mode=CGAC3;
  384. initgraph(&graphics_adapter,&graphics_mode,"");
  385. x_res=320;y_res=200;mode_flag=1;C7=3;
  386.         maxx=319;minx=0;maxy=199;miny=0;screen_x=319;screen_y=199;
  387.           setcolor(3);moveto(48,10);
  388.           outtext("Revisions by A. Helder");
  389.         moveto(88,0);
  390.           outtext ("MIRROR REFLECTIONS");
  391.         return;
  392.  
  393. abort_message:
  394. printf("\n\nUnable to proceed - Requires VGA,EGA,CGA or MCGA adapter");
  395. printf("\nWith appropriate monitor");
  396. exit(0);
  397. }
  398.  
  399. /* ----------------------------------------------------------------------- */
  400. /* SUBROUTINE: MAP 640*480 TEMPLATE TO 2D SCREEN */
  401. void coords(void)
  402. {
  403. sx=sx*(x_res/640);sy=sy*(y_res/480);return;
  404. }
  405.  
  406. /* ----------------------------------------------------------------------- */
  407. /* SUBROUTINE: COPYRIGHT NOTICE */
  408.  
  409. int copyright[][3]={0x7c00,0x0000,0x0000,0x8231,
  410. 0x819c,0x645e,0xba4a,0x4252,0x96d0,0xa231,0x8252,0x955e,0xba4a,
  411. 0x43d2,0xf442,0x8231,0x825c,0x945e,0x7c00,0x0000,0x0000};
  412.  
  413. void notice(int x, int y){
  414. int a,b,c; int t1=0;
  415.  
  416. for (t1=0;t1<=6;t1++)
  417.     {
  418.     a=copyright[t1][0];b=copyright[t1][1];
  419.     c=copyright[t1][2];
  420.     setlinestyle(USERBIT_LINE,a,NORM_WIDTH);
  421.     moveto(x,y);lineto(x+15,y);
  422.     setlinestyle(USERBIT_LINE,b,NORM_WIDTH);
  423.     moveto(x+16,y);lineto(x+31,y);
  424.     setlinestyle(USERBIT_LINE,c,NORM_WIDTH);
  425.     moveto(x+32,y);lineto(x+47,y);y++;
  426.     };
  427. setlinestyle(USERBIT_LINE,0xFFFF,NORM_WIDTH);
  428. return;}
  429.  
  430. /* end of source code */