home *** CD-ROM | disk | FTP | other *** search
/ APDL Public Domain 2 / APDL_PD2A.iso / demos / demo_1 / demo4 / !Demo4 / c / horizon next >
Encoding:
Text File  |  1992-02-08  |  5.8 KB  |  241 lines
  1. /******************************************************************************
  2. *                                                                             *
  3. *    horizon.c                                                                *
  4. *                                                                             *
  5. ******************************************************************************/
  6.  
  7. #include <stdlib.h>
  8. #include <math.h>
  9. #include "GrpLib.h"
  10. #include "extern.h"
  11.  
  12. /*****************************************************************************/
  13.  
  14. int sgn(int i)
  15. {
  16.   return(i>=0 ? 1 : -1);
  17. }
  18.  
  19. /*****************************************************************************/
  20.  
  21. void Horizon(vec4 normal,vec4 point)
  22. {
  23.   int a,b,c;
  24.   int d,x,y,p;
  25.   int col1 = BLUE,col2 = GREEN;
  26.   int pts[10][2];
  27.   int l1[6],l2[6],l3[6],i3[6];
  28.   int j,i=0,n1=0,n2=0,n3=0;
  29.   int lg=50;
  30.   int xmin=-160,xmax=160,ymin=-128,ymax=128;  
  31.  
  32.   a = normal[0];
  33.   b = normal[1];
  34.   c = normal[2];
  35.  
  36.   c = c*dist;
  37.  
  38. /* liste de points */
  39.  
  40.   x = xmin; y = ymax;
  41.   pts[i][0] = x; pts[i][1] = y;
  42.   p = a*x+b*y+c;
  43.   if (p >= 0) l1[n1++]=i;
  44.     else      l2[n2++]=i;
  45.   i++;
  46.   if (a!=0) {
  47.     x = (- c - b*y)/a;
  48.     if (x>xmin && x<xmax) {
  49.       pts[i][0] = x; pts[i][1] = y;
  50.       l1[n1++]=i;
  51.       l2[n2++]=i;
  52.       i++;
  53.     }
  54.   }
  55.      
  56.   x = xmax; y = ymax;
  57.   pts[i][0] = x; pts[i][1] = y;
  58.   p = a*x+b*y+c;
  59.   if (p >= 0) l1[n1++]=i;
  60.     else      l2[n2++]=i;
  61.   i++;
  62.   if (b!=0) {
  63.     y = (- c - a*x)/b;
  64.     if (y>ymin && y<ymax) {
  65.       pts[i][0] = x; pts[i][1] = y;
  66.       l1[n1++]=i;
  67.       l2[n2++]=i;
  68.       i++;
  69.     }
  70.   }
  71.  
  72.   x = xmax; y = ymin;
  73.   pts[i][0] = x; pts[i][1] = y;
  74.   p = a*x+b*y+c;
  75.   if (p >= 0) l1[n1++]=i;
  76.     else      l2[n2++]=i;
  77.   i++;
  78.   if (a!=0) {
  79.     x = (- c - b*y)/a;
  80.     if (x>xmin && x<xmax) {
  81.       pts[i][0] = x; pts[i][1] = y;
  82.       l1[n1++]=i;
  83.       l2[n2++]=i;
  84.       i++;
  85.     }
  86.   } 
  87.  
  88.   x = xmin; y = ymin;
  89.   pts[i][0] = x; pts[i][1] = y;
  90.   p = a*x+b*y+c;
  91.   if (p >= 0) l1[n1++]=i;
  92.     else      l2[n2++]=i;
  93.   i++;
  94.   if (b!=0) {
  95.     y = (- c - a*x)/b;
  96.     if (y>ymin && y<ymax) {
  97.       pts[i][0] = x; pts[i][1] = y;
  98.       l1[n1++]=i;
  99.       l2[n2++]=i;
  100.       i++;
  101.     }
  102.   }
  103.  
  104. /* calcul horizon */
  105.  
  106.   if (abs(a)<abs(b)) {
  107.     int dy,d,y1,y2;
  108.     dy = (int)(lg*sqrt(a*a+b*b)/b);
  109.     d  = abs(dy);
  110.     y1 = (- c - a*xmin)/b;
  111.     y2 = (- c - a*xmax)/b;
  112.     if (((y1>ymin-d) && (y1<ymax+d)) || ((y2>ymin-d) && (y2<ymax+d))) {
  113.       pts[i][0] = xmin; pts[i][1] = y1-4*sgn(dy);
  114.       l3[n3]    = i;
  115.       i3[n3]    = 255;
  116.       n3++; i++;
  117.       pts[i][0] = xmax; pts[i][1] = y2-4*sgn(dy);
  118.       l3[n3]    = i;
  119.       i3[n3]    = 255;
  120.       n3++; i++;
  121.       pts[i][0] = xmax; pts[i][1] = y2+dy;
  122.       l3[n3]    = i;
  123.       i3[n3]    = 100;
  124.       n3++; i++;
  125.       pts[i][0] = xmin; pts[i][1] = y1+dy;
  126.       l3[n3]    = i;
  127.       i3[n3]    = 100;
  128.       n3++; i++;
  129.     }
  130.   }
  131.   else {
  132.     int dx,d,x1,x2;
  133.     dx = (int)(lg*sqrt(a*a+b*b)/a);
  134.     d  = abs(dx);
  135.     x1 = (- c - b*ymin)/a;
  136.     x2 = (- c - b*ymax)/a;
  137.     if (((x1>xmin-d) && (x1<xmax+d)) || ((x2>xmin-d) && (x2<xmax+d))) {
  138.       pts[i][0] = x1-4*sgn(dx); pts[i][1] = ymin;
  139.       l3[n3]    = i;
  140.       i3[n3]    = 255;
  141.       n3++; i++;
  142.       pts[i][0] = x2-4*sgn(dx); pts[i][1] = ymax;
  143.       l3[n3]    = i;
  144.       i3[n3]    = 255;
  145.       n3++; i++;
  146.       pts[i][0] = x2+dx; pts[i][1] = ymax;
  147.       l3[n3]    = i;
  148.       i3[n3]    = 100;
  149.       n3++; i++;
  150.       pts[i][0] = x1+dx; pts[i][1] = ymin;
  151.       l3[n3]    = i;
  152.       i3[n3]    = 100;
  153.       n3++; i++;
  154.     }
  155.   }
  156.   
  157. /* trace */
  158.   
  159.   if (n1>=3)
  160.     for (j=1 ; j<=n1-2 ; j++) {
  161.       GrpReg[0] =  pts[l1[0  ]][0]+xorg;
  162.       GrpReg[1] = -pts[l1[0  ]][1]+yorg;
  163.       GrpReg[2] =  pts[l1[j  ]][0]+xorg;
  164.       GrpReg[3] = -pts[l1[j  ]][1]+yorg;
  165.       GrpReg[4] =  pts[l1[j+1]][0]+xorg;
  166.       GrpReg[5] = -pts[l1[j+1]][1]+yorg;
  167.       GrpReg[8] = col1;
  168.      CallGrp(GrpReg,GrpStack,Uni2DPoly3);
  169.     }
  170.  
  171.   if (n3>=3)
  172.     for (j=1 ; j<=n3-2 ; j++) {
  173.       GrpReg[0] =  pts[l3[0  ]][0]+xorg;
  174.       GrpReg[1] = -pts[l3[0  ]][1]+yorg;
  175.       GrpReg[2] =  pts[l3[j  ]][0]+xorg;
  176.       GrpReg[3] = -pts[l3[j  ]][1]+yorg;
  177.       GrpReg[4] =  pts[l3[j+1]][0]+xorg;
  178.       GrpReg[5] = -pts[l3[j+1]][1]+yorg;
  179.       GrpReg[6] =      i3[0  ];
  180.       GrpReg[7] =      i3[j  ];
  181.       GrpReg[8] =      i3[j+1];
  182.       GrpReg[9] = (int)TblCol + 32*7 +8;
  183.       CallGrp(GrpReg,GrpStack,Grd2DPoly3);
  184.     }
  185.  
  186.   if (n2>=3)
  187.     for (j=1 ; j<=n2-2 ; j++) {
  188.       GrpReg[0] =  pts[l2[0  ]][0]+xorg;
  189.       GrpReg[1] = -pts[l2[0  ]][1]+yorg;
  190.       GrpReg[2] =  pts[l2[j  ]][0]+xorg;
  191.       GrpReg[3] = -pts[l2[j  ]][1]+yorg;
  192.       GrpReg[4] =  pts[l2[j+1]][0]+xorg;
  193.       GrpReg[5] = -pts[l2[j+1]][1]+yorg;
  194.       GrpReg[8] = col2;
  195.       CallGrp(GrpReg,GrpStack,Uni2DPoly3);
  196.     }
  197. }
  198.  
  199. /*****************************************************************************/
  200.  
  201. void PlotHorizon(Envi *envi,Object *obs,Object *obj)
  202. {
  203.   vec4  Obj4Rep[4];
  204.   mat33 invobs;
  205.   vec3  transl;
  206.   int   env[3];
  207.  
  208.   InvMat(invobs,obs->Rep);
  209.   MkVec3(transl,obj->Org[0] - obs->Org[0],
  210.                 obj->Org[1] - obs->Org[1],
  211.                 obj->Org[2] - obs->Org[2]);
  212.  
  213.   GrpReg[0] = (int)invobs;
  214.   GrpReg[1] = (int)Obj4Rep;
  215.   GrpReg[2] = (int)obj->Rep;
  216.   GrpReg[3] = (int)transl;
  217.   CallGrp(GrpReg,GrpStack,RepToRepIn4Rep); /*Obj4Rep=invobs*(transl o ObjRep)*/
  218.  
  219.   env[0] = (int)(envi->AmbLight);    /* ambient light (0-255) */
  220.   env[1] = (int)(envi->NbDirecSrc << 24) + ((int)(envi->DirecSrc) & 0x00FFFFFF);
  221.   env[2] = (int)(envi->NbPonctSrc << 24) + ((int)(envi->PonctSrc) & 0x00FFFFFF);
  222.  
  223.   Horizon(Obj4Rep[1],Obj4Rep[3]);
  224. }
  225.  
  226. /*****************************************************************************/
  227.  
  228. int CollisionHorizon(Object *obs,Object *hor)
  229. {
  230.   mat33 inv;
  231.   vec3  transl,p;
  232.  
  233.   InvMat(inv,hor->Rep);
  234.   MkVec3(transl,- hor->Org[0],
  235.                 - hor->Org[1],
  236.                 - hor->Org[2]);
  237.   TransformPt(p,inv,transl,obs->Org);
  238.  
  239.   if (p[1]<0) return(1); else return(0);
  240. }
  241.